ProcessingHistory.h

#ifndef _PROCESSING_HISTORY_H_
#define _PROCESSING_HISTORY_H_
#include <string>
#include <list>
#include <vector>
#include <map>
#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 <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include "mspass/utility/ErrorLogger.h"
//#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:
  /* This map defines connections of each data object to others.  Key is the
  uuid of a given object and the values (second) associated with
  that key are the inputs used to create the data defined by the key uuid */
  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);
} // end utility namespace
} // End mspass namespace
#endif