ProcessingHistory.h

#ifndef _PROCESSING_HISTORY_H_
#define _PROCESSING_HISTORY_H_
#include "mspass/utility/ErrorLogger.h"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/uuid_serialize.hpp>
#include <list>
#include <map>
#include <string>
#include <vector>
// #include "mspass/seismic/Ensemble.h"
namespace mspass {
namespace utility {
enum class ProcessingStatus { RAW, ORIGIN, VOLATILE, SAVED, UNDEFINED };
enum class AtomicType { SEISMOGRAM, TIMESERIES, UNDEFINED };
const std::string SAVED_ID_KEY("NODEDATA_AT_SAVE");
 
class BasicProcessingHistory {
public:
  BasicProcessingHistory() {
    jid = std::string();
    jnm = std::string();
  };
  virtual ~BasicProcessingHistory() {};
  BasicProcessingHistory(const std::string jobname, const std::string jobid) {
    jid = jobid;
    jnm = jobname;
  };
  BasicProcessingHistory(const BasicProcessingHistory &parent) {
    jid = parent.jid;
    jnm = parent.jnm;
  };
 
  virtual size_t number_of_stages() { return 0; };
  std::string jobid() const { return jid; };
  void set_jobid(const std::string &newjid) { jid = newjid; };
  std::string jobname() const { return jnm; };
  void set_jobname(const std::string jobname) { jnm = jobname; };
  BasicProcessingHistory &operator=(const BasicProcessingHistory &parent) {
    if (this != (&parent)) {
      jnm = parent.jnm;
      jid = parent.jid;
    }
    return *this;
  }
 
protected:
  std::string jid;
  std::string jnm;
 
private:
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & jid;
    ar & jnm;
  };
};
class NodeData {
public:
  mspass::utility::ProcessingStatus status;
  std::string uuid;
  mspass::utility::AtomicType type;
  int stage;
  std::string algorithm;
  std::string algid;
  /* These standard elements could be defaulted, but we implement them
  explicitly for clarity - implemented in the cc file. */
  NodeData();
  NodeData(const NodeData &parent);
  NodeData &operator=(const NodeData &parent);
  bool operator==(const NodeData &other);
  bool operator!=(const NodeData &other);
 
private:
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & status;
    ar & uuid;
    ar & type;
    ar & stage;
    ar & algorithm;
    ar & algid;
  };
};
class ProcessingHistory : public BasicProcessingHistory {
public:
  ErrorLogger elog;
  ProcessingHistory();
  ProcessingHistory(const std::string jobnm, const std::string jid);
  ProcessingHistory(const ProcessingHistory &parent);
  bool is_empty() const;
  bool is_raw() const;
  bool is_origin() const;
  bool is_volatile() const;
  bool is_saved() const;
  size_t number_of_stages() override;
  void set_as_origin(const std::string alg, const std::string algid,
                     const std::string uuid, const AtomicType typ,
                     bool define_as_raw = false);
  std::string
  new_ensemble_process(const std::string alg, const std::string algid,
                       const AtomicType typ,
                       const std::vector<ProcessingHistory *> parents,
                       const bool create_newid = true);
  void add_one_input(const ProcessingHistory &data_to_add);
  void add_many_inputs(const std::vector<ProcessingHistory *> &d);
 
  void merge(const ProcessingHistory &data_to_add);
  void accumulate(const std::string alg, const std::string algid,
                  const AtomicType typ, const ProcessingHistory &newinput);
  std::string clean_accumulate_uuids();
  std::string
  new_map(const std::string alg, const std::string algid, const AtomicType typ,
          const ProcessingStatus newstatus = ProcessingStatus::VOLATILE);
  std::string
  new_map(const std::string alg, const std::string algid, const AtomicType typ,
          const ProcessingHistory &data_to_clone,
          const ProcessingStatus newstatus = ProcessingStatus::VOLATILE);
 
  std::string map_as_saved(const std::string alg, const std::string algid,
                           const AtomicType typ);
  void clear();
  std::multimap<std::string, mspass::utility::NodeData> get_nodes() const;
 
  int stage() const { return current_stage; };
  ProcessingStatus status() const { return current_status; };
  std::string id() const { return current_id; };
  std::pair<std::string, std::string> created_by() const {
    std::pair<std::string, std::string> result(algorithm, algid);
    return result;
  }
  NodeData current_nodedata() const;
  std::string newid();
  int number_inputs() const;
  int number_inputs(const std::string uuidstr) const;
 
  void set_id(const std::string newid);
 
  std::list<mspass::utility::NodeData>
  inputs(const std::string id_to_find) const;
 
  ProcessingHistory &operator=(const ProcessingHistory &parent);
  /* We make this protected to simplify expected extensions.  In particular,
  the process of reconstructing history is a complicated process we don't
  want to add as baggage to regular data.  Hence, tools to reconstruct history
  (provenance) are expected to extend this class. */
protected:
  std::multimap<std::string, mspass::utility::NodeData> nodes;
 
private:
  /*  This set of private variables are the values of attributes for
  the same concepts in the NodeData struct/class.   We break them out as
  single variables because they are not always set lumped together.  Hence
  there are also separate getters and setters for each. */
  ProcessingStatus current_status;
  /* uuid of current data object */
  std::string current_id;
  int current_stage;
  AtomicType mytype;
  std::string algorithm;
  std::string algid;
 
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar &boost::serialization::base_object<BasicProcessingHistory>(*this);
    ar & nodes;
    ar & current_status;
    ar & current_id;
    ar & current_stage;
    ar & mytype;
    ar & algorithm;
    ar & algid;
    ar & elog;
  };
};
/* function prototypes of helpers */
 
template <typename Tdata>
void append_input(const Tdata &d, ProcessingHistory &his) {
  if (d.live()) {
    const ProcessingHistory *ptr = dynamic_cast<const ProcessingHistory *>(&d);
    his.add_one_input(*ptr);
  }
};
/* this pair of functions did things that were methods in an earlier
prototype.  What they do is still useful but making them functions
reduced the baggage in the ProcessingHistory class. */
 
std::list<std::tuple<int, std::string, std::string>>
algorithm_history(const ProcessingHistory &h);
std::list<std::string> algorithm_outputs(const ProcessingHistory &h,
                                         const std::string alg,
                                         const std::string algid);
} // namespace utility
} // namespace mspass
#endif