Event.h

#ifndef FIRE_EVENT_H
#define FIRE_EVENT_H
 
#include <regex>
#include <boost/core/demangle.hpp>
 
#include "fire/io/Data.h"
#include "fire/io/ClassVersion.h"
#include "fire/EventHeader.h"
 
namespace fire {
 
class Process;
class UserReader;
 
class Event {
 public:
  class EventObjectTag {
   public:
    EventObjectTag(const std::string& name, const std::string& pass,
                   const std::string& type, int vers, bool keep)
      : name_{name}, pass_{pass}, type_{type}, version_{vers}, keep_{keep} {}
  
    const std::string& name() const { return name_; }
  
    const std::string& pass() const { return pass_; }
  
    const std::string& type() const { return type_; }
 
    int version() const { return version_; }
 
    const bool keep() const { return keep_; }
 
    const bool loaded() const { return loaded_; }
  
    friend std::ostream& operator<<(std::ostream& os, const EventObjectTag& t) {
      return os << "Object(pass=" << t.pass() <<", name=" << t.name() << "type=" << t.type() << ")";
    }
  
    inline bool match(const std::regex& name, const std::regex& pass, const std::regex& type) const {
      return std::regex_match(name_, name) and std::regex_match(pass_, pass) and std::regex_match(type_, type);
    }
  
   private:
    friend class Event;
 
    std::string name_;
  
    std::string pass_;
  
    std::string type_;
 
    int version_;
 
    bool keep_;
 
    mutable bool loaded_{false};
  };
 
 public:
  const EventHeader& header() const { return *header_; }
 
  EventHeader& header() { return *header_; }
 
  std::vector<EventObjectTag> search(const std::string& namematch,
                                 const std::string& passmatch,
                                 const std::string& typematch) const;
 
  bool exists(const std::string& name, const std::string& pass = "") const {
    return search("^" + name + "$", pass, "").size() == 1;
  }
 
  template <typename DataType>
  void add(const std::string& name, const DataType& data) {
    static const bool ADD_KEEP_DEFAULT = true;
    std::string full_name{fullName(name, pass_)};
    if (objects_.find(full_name) == objects_.end()) {
      // check available_objects_ listing so we don't in-advertently replace 
      //   any datasets of the same name read in from the inputfile
      // we know we are worried about data from the input file
      //   because data from previous producers in the sequence
      //   would already exist in the objects_ map
      // we rely on trusting that setInputFile gets the listing
      //   of event objects from the input file and puts them
      //   into availble_objects_
      if (search("^"+name+"$","^"+pass_+"$",".*").size() > 0) {
        throw Exception("Repeat",
            "Data named "+full_name+" already exists in the input file.");
      }
      auto& tag{available_objects_.emplace_back(name, pass_,
                  boost::core::demangle(typeid(DataType).name()),
                  io::class_version<DataType>,
                  keep(full_name, ADD_KEEP_DEFAULT))};
      tag.loaded_ = true;
 
      // a data set hasn't been created for this data yet
      // we good, lets create the new data set
      //
      // NOTES:
      // - check if new data is going to be written to output file 
      //   or just used during this run 
      // - without any applicable drop/keep rules, 
      //   we do save these datasets
      // - we mark these objects as should_load == false because
      //   they are new and not from an input file
      auto& obj{objects_[full_name]};
      obj.data_ = std::make_unique<io::Data<DataType>>(io::constants::EVENT_GROUP+"/"+full_name);
      obj.should_save_ = tag.keep_;
      obj.should_load_ = false;
      obj.updated_ = false;
 
      // if we are saving this object, we should save the structure and the default value 
      // for all entries up to this one. This (along with 'clearing' at the end of each event) 
      // allows users to asyncronously add event objects and the events without an 'add'
      // have a 'default' or 'cleared' object value.
      if (obj.should_save_) {
        obj.data_->structure(*output_file_);
        obj.data_->clear();
        for (std::size_t i{0}; i < i_entry_; i++)
          obj.data_->save(*output_file_);
      }
    }
 
    auto& obj{objects_.at(full_name)};
    if (obj.updated_) {
      // this data set has been updated by another processor in the sequence
      throw Exception("Repeat",
          "Data named " + full_name + " already added to the event"
          " by a previous producer in the sequence.");
    }
 
    try {
      obj.getDataRef<DataType>().update(data);
      obj.updated_ = true;
    } catch (std::bad_cast const&) {
      throw Exception("TypeMismatch",
          "Data corresponding to " + full_name + " has different type.");
    }
  }
 
  template <typename DataType>
  const DataType& get(const std::string& name,
                      const std::string& pass = "") const {
    std::string full_name, type;
    if (not pass.empty()) {
      // easy case, pass was specified explicitly
      full_name = fullName(name, pass);
    } else if (known_lookups_.find(name) != known_lookups_.end()) {
      full_name = known_lookups_.at(name);
    } else {
      // need to search current (and potential) available_objects using partial name
      auto options{search("^" + name + "$", ".*", ".*")};
      if (options.size() == 0) {
        throw Exception("Miss",
            "Data " + name + " not found.");
      } else if (options.size() > 1) {
        throw Exception("Ambig",
            "Data " + name + " is ambiguous. Provide a pass name.");
      }
 
      // exactly one option
      full_name = fullName(options.at(0).name(), options.at(0).pass());
      type = options.at(0).type();
      // add into cache
      known_lookups_[name] = full_name;
    }
 
    if (objects_.find(full_name) == objects_.end()) {
      // final check for input file, never should enter here without one
      if (not input_file_) {
        throw Exception("Miss",
            "Data " + full_name + " was not created by an earlier processor "
            "and there is no input file to attempt to read it from.");
      }
      
      // when setting up the in-memory object, we need to find the tag so we can
      // 1. get whether the object should be copied to the output file and
      // 2. set the loaded_ flag to true
      // we can do a simple linear search since this will only happen once per input file
      auto tag_it = std::find_if(available_objects_.begin(), available_objects_.end(), 
          [&full_name,this](const EventObjectTag& tag) {
            return fullName(tag.name(),tag.pass()) == full_name;
          });
      tag_it->loaded_ = true;
 
      // a data set hasn't been created for this data yet
      // we good, lets create the new data set
      //
      // NOTES:
      // - check if new data is going to be written to output file 
      //   or just used during this run 
      // - without any applicable drop/keep rules, 
      //   we do save these datasets
      // - we mark these objects as should_load == false because
      //   they are new and not from an input file
      auto& obj{objects_[full_name]};
      obj.data_ = std::make_unique<io::Data<DataType>>(io::constants::EVENT_GROUP+"/"+full_name, 
          input_file_);
      obj.should_save_ = tag_it->keep();
      obj.should_load_ = true;
      obj.updated_ = false;
 
      // get this object up to the current entry
      //    loading may throw an H5 error if the shape of the data on disk
      //    cannot be loaded into the input type
      try {
        // copy structure into output file if this object should be saved
        if (obj.should_save_) {
          obj.data_->structure(*output_file_);
        }
        
        if (not obj.should_save_ or not input_file_->canCopy()) {
          // only skip the first i_entry_ entries if the input file cannot copy
          // or the object is not being saved
          //  the objects that are being saved are being mirrored by the input file
          //  if the input file can copy
          for (std::size_t i{0}; i < i_entry_; i++) input_file_->load_into(*obj.data_);
        }
        input_file_->load_into(*obj.data_);
      } catch (const HighFive::DataSetException&) {
        throw Exception("BadType",
            "Data " + full_name + " could not be loaded into "
            + boost::core::demangle(typeid(DataType).name())
            + " from the type it was written as " + type);
      }
    }
 
    // type casting, 'bad_cast' thrown if unable
    try {
      return objects_[full_name].getDataRef<DataType>().get();
    } catch (const std::bad_cast&) {
      throw Exception("BadType",
          "Data " + full_name + " was initialy loaded with type " + type
          + " which cannot be casted into " 
          + boost::core::demangle(typeid(DataType).name()));
    }
  }
 
  Event(const Event&) = delete;
 
  void operator=(const Event&) = delete;
 
 private:
  inline std::string fullName(const std::string& name, const std::string& pass) const {
    return (pass.empty() ? pass_ : pass) + "/" + name;
  }
 
  bool keep(const std::string& full_name, bool def) const;
 
 private:
  friend class Process;
 
  friend class UserReader;
 
  Event(io::Writer* output_file,
        const std::string& pass,
        const std::vector<config::Parameters>& dk_rules);
 
  void save();
 
  void load();
 
  void setInputFile(io::Reader* r);
 
  void next();
 
  void done();
 
 private:
  std::unique_ptr<EventHeader> header_;
  io::Reader* input_file_;
  io::Writer* output_file_;
  std::string pass_;
  struct EventObject {
    std::unique_ptr<io::BaseData> data_;
    bool should_save_;
    bool should_load_;
    bool updated_;
    template <typename DataType>
    io::Data<DataType>& getDataRef() {
      return dynamic_cast<io::Data<DataType>&>(*data_);
    }
    void clear() {
      updated_ = false;
      data_->clear();
    }
  };
  mutable std::unordered_map<std::string, EventObject> objects_;
  long unsigned int i_entry_;
  std::vector<std::pair<std::regex, bool>> drop_keep_rules_;
  std::vector<EventObjectTag> available_objects_;
  mutable std::unordered_map<std::string, std::string> known_lookups_;
};  // Event
 
}  // namespace fire
 
#endif  // FIRE_EVENT_H