ProcessManager.h

#ifndef _PROCESS_MANAGER_H_
#define _PROCESS_MANAGER_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/serialization/vector.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 <map>
#include <vector>
namespace mspass {
namespace utility {
class AlgorithmDefinition {
public:
  AlgorithmDefinition() : nm(), myid(), input_type(), output_type() {};
  AlgorithmDefinition(const std::string name, const std::string typin,
                      const std::string typout, const std::string id) {
    nm = name;
    myid = id;
    input_type = typin;
    output_type = typout;
  };
  AlgorithmDefinition(const AlgorithmDefinition &parent) {
    nm = parent.nm;
    myid = parent.myid;
    input_type = parent.input_type;
    output_type = parent.output_type;
  };
  std::string name() const { return nm; };
  std::string id() const { return myid; };
  void set_id(const std::string id) { myid = id; };
  // void set_name(const string name){nm=name;};
  AlgorithmDefinition &operator=(const AlgorithmDefinition &parent) {
    if (this == &parent) {
      nm = parent.nm;
      myid = parent.myid;
      input_type = parent.input_type;
      output_type = parent.output_type;
    }
    return *this;
  };
 
private:
  std::string nm;
  std::string myid;
  std::string input_type;
  std::string output_type;
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & nm;
    ar & myid;
  };
};
class ProcessManager {
public:
  ProcessManager();
  ProcessManager(std::string fname);
  AlgorithmDefinition algorithm(const std::string name,
                                const size_t instance = 0) const;
  std::string jobname() const { return jobnm; };
  std::string jobid() const { return boost::uuids::to_string(job_uuid); };
  std::string new_newid() {
    boost::uuids::uuid id;
    id = gen();
    return boost::uuids::to_string(id);
  }
 
private:
  std::string jobnm;
  boost::uuids::uuid job_uuid;
  boost::uuids::random_generator gen;
  std::map<std::string, std::vector<AlgorithmDefinition>> algs;
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & jobnm;
    ar & job_uuid;
    ar & algs;
  };
};
} // namespace utility
} // namespace mspass
#endif