ProcessManager.h

#ifndef _PROCESS_MANAGER_H_
#define _PROCESS_MANAGER_H_
#include <map>
#include <vector>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/uuid_serialize.hpp>
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;
  };
};
} // end utility namespace
}  // end mspass namespace encapsulation
#endif