Metadata.h

#ifndef _METADATA_H_
#define _METADATA_H_
#include "mspass/utility/BasicMetadata.h"
#include "mspass/utility/MsPASSError.h"
#include <boost/any.hpp>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <pybind11/pybind11.h>
#include <set>
#include <sstream>
#include <typeinfo>
 
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);
} // namespace utility
} // namespace mspass
#endif