Metadata.h

#ifndef _METADATA_H_
#define _METADATA_H_
#include <typeinfo>
#include <map>
#include <set>
#include <list>
#include <iostream>
#include <fstream>
#include <sstream>
#include <boost/any.hpp>
#include <pybind11/pybind11.h>
#include "mspass/utility/MsPASSError.h"
#include "mspass/utility/BasicMetadata.h"
 
namespace mspass
{
namespace utility{
class MetadataGetError : public MsPASSError
{
public:
  std::stringstream ss;
  MetadataGetError():MsPASSError(){}; // seems necessary to not default this with gcc
  MetadataGetError(const std::string key,const char *Texpected)
  {
 
    std::string pretty_name(boost::core::demangle(Texpected));
    ss<<"Error trying to extract Metadata with key="<<key<<std::endl
      << "No value associated with this key is set in Metadata object"<<std::endl
      << "Expected an entry of type="<<pretty_name<<std::endl;
    message=ss.str();
    badness=ErrorSeverity::Suspect;
  };
  MetadataGetError(const char *boostmessage,const std::string key,
      const char *Texpected, const char *Tactual)
  {
    ss << "Error in Metadata get method.   Type mismatch in attem to get "
        << "data with key="<<key<<std::endl
      << "boost::any bad_any_cast wrote this message:  "<<std::endl
      << boostmessage<<std::endl;
    std::string name_e(boost::core::demangle(Texpected));
    ss << "Trying to convert to data of type="<<name_e<<std::endl;
    std::string name_a(boost::core::demangle(Tactual));
    ss << "Actual entry has type="<<name_a<<std::endl;
    message=ss.str();
    badness=ErrorSeverity::Suspect;
  };
  MetadataGetError(const MetadataGetError& parent)
  {
      message=parent.message;
      badness=parent.badness;
  };
  MetadataGetError operator=(const MetadataGetError& parent)
  {
      if(this!=&parent)
      {
          message=parent.message;
          badness=parent.badness;
      }
      return *this;
  };
};
 
class Metadata : public BasicMetadata
{
public:
  Metadata(){};
  Metadata(std::ifstream& ifs, const std::string form=std::string("pf"));
  Metadata(const Metadata& mdold);
  virtual ~Metadata(){};
  Metadata& operator=(const Metadata& mdold);
  Metadata& operator+=(const Metadata& rhs) noexcept;
  const Metadata operator+(const Metadata& other) const;
  /* All the getters - all but the template are wrappers with the type
  fixed */
  double get_double(const std::string key) const override{
    try{
      double val;
      val=get<double>(key);
      return val;
    }catch(MetadataGetError& merr)
    {
    /* Try a float if that failed */
      try{
        float fval;
        fval=get<float>(key);
        return fval;
      }catch(MetadataGetError& merr)
      {
    throw merr;
      }
    }
  };
  int get_int(const std::string key) const override
  {
      try{
        int val;
        val=get<int>(key);
        return val;
      }
      catch(MetadataGetError& merr)
      {
    try{
          long lval;
      lval=get<long>(key);
      return static_cast<int>(lval);
    }catch(MetadataGetError& merr)
    {
      throw merr;
    }
      }
  };
  long get_long(const std::string key) const
  {
      try{
        long val;
        val=get<long>(key);
        return val;
      }
      catch(MetadataGetError& merr)
      {
    try{
          int ival;
      ival=get<int>(key);
      return static_cast<long>(ival);
    }catch(MetadataGetError& merr)
    {
      throw merr;
    }
      }
  };
  std::string get_string(const std::string key) const override{
    try{
      std::string val;
      val=get<std::string>(key);
      return val;
    }catch(...){throw;};
  };
  bool get_bool(const std::string key) const override{
    try{
      bool val;
      val=get<bool>(key);
      return val;
    }catch(...){throw;};
  };
  template <typename T> T get(const std::string key) const;
  template <typename T> T get(const char *key) const
  {
    try{
      T val;
      val=get<T>(std::string(key));
      return val;
    }catch(...){throw;};
  }
  boost::any get_any(const std::string key) const {
    std::map<std::string,boost::any>::const_iterator iptr;
    iptr=md.find(key);
    if(iptr==md.end())
    {
      throw MetadataGetError(key,typeid(boost::any).name());
    }
    return iptr->second;
  };
  std::string type(const std::string key) const;
  template <typename T> void put(const std::string key, T val) noexcept
  {
    boost::any aval=val;
    md[key]=aval;
    changed_or_set.insert(key);
  }
  template <typename T> void put (const char *key, T val) noexcept
  {
    /* could do this as put(string(key),val) but this is so trivial duplicating
    the code for the string method is more efficient than an added function call.*/
    boost::any aval=val;
    md[std::string(key)]=aval;
    changed_or_set.insert(std::string(key));
  }
  void put(const std::string key, const double val) override
  {
      this->put<double>(key,val);
  };
  void put(const std::string key, const int val) override
  {
      this->put<int>(key,val);
  };
  void put(const std::string key, const bool val) override
  {
      this->put<bool>(key,val);
  };
  void put(const std::string key, const std::string val) override
  {
      this->put<std::string>(key,val);
  };
  void put(const char *key,const char *val)
  {
    std::string sval(val);
    this->put<std::string>(key,val);
  }
  void put(std::string key,const char *val)
  {
    this->put(key.c_str(),val);
  }
  void put_object(const std::string key, const pybind11::object val)
  {
      this->put<pybind11::object>(key,val);
  }
  void put_int(const std::string key,const int val)
  {
    this->put<int>(key,val);
  };
  void put_string(const std::string key,const std::string val)
  {
    this->put<std::string>(key,val);
  };
  void put_bool(const std::string key,const bool val)
  {
    this->put<bool>(key,val);
  };
  void put_double(const std::string key,const double val)
  {
    this->put<double>(key,val);
  };
  void put_long(const std::string key,const long val)
  {
    this->put<long>(key,val);
  };
  void append_chain(const std::string key, const std::string val,
          const std::string separator=std::string(":"));
 
  std::set<std::string> modified() const
  {
      return changed_or_set;
  };
  void clear_modified()
  {
      changed_or_set.clear();
  };
  std::set<std::string> keys() const noexcept;
  bool is_defined(const std::string key) const noexcept;
  /*
  bool is_defined(const char* key) const noexcept
  {
    return this->is_defined(string(key));
  };
  */
  void erase(const std::string key);
  /*
  void erase(const char* key)
  {
    return this->erase(string(key));
  };
  */
  std::size_t size() const noexcept;
  std::map<std::string,boost::any>::const_iterator  begin() const noexcept;
  std::map<std::string,boost::any>::const_iterator  end() const noexcept;
  void change_key(const std::string oldkey, const std::string newkey);
  friend pybind11::object serialize_metadata_py(const Metadata &md);
  friend Metadata restore_serialized_metadata_py(const pybind11::object &sd);
  friend std::ostringstream& operator<<(std::ostringstream&,
     const mspass::utility::Metadata&);
protected:
  std::map<std::string,boost::any> md;
  /* The keys of any entry changed will be contained here.   */
  std::set<std::string> changed_or_set;
};
template <typename T> T Metadata::get(const std::string key) const
{
  T result;
  std::map<std::string,boost::any>::const_iterator iptr;
  iptr=md.find(key);
  if(iptr==md.end())
  {
    throw MetadataGetError(key,typeid(T).name());
  }
  boost::any aval=iptr->second;
  try{
    result=boost::any_cast<T>(aval);
  }catch(boost::bad_any_cast& err)
  {
    const std::type_info &ti = aval.type();
    throw MetadataGetError(err.what(),key,typeid(T).name(),ti.name());
  };
  return result;
}
std::string demangled_name(const boost::any val);
/*   Start of helper procedures for Metadata. */
enum class MDtype{
    Real,
    Real32,
    Double,
    Real64,
    Integer,
    Int32,
    Long,
    Int64,
    String,
    Boolean,
    Double_Array,
    Invalid
};
typedef struct Metadata_typedef {
    std::string tag; 
    MDtype mdt; 
} Metadata_typedef;
 
typedef std::list<Metadata_typedef> MetadataList;
 
int copy_selected_metadata(const Metadata& mdin, Metadata& mdout,
        const MetadataList& mdlist);
 
std::string serialize_metadata(const Metadata &md);
Metadata restore_serialized_metadata(const std::string);
 
Metadata restore_serialized_metadata_py(const pybind11::object &sd);
} // end utility namespace
}  //End of namespace MsPASS
#endif