mspass::utility::Metadata Class Reference

Type-safe metadata container used throughout MsPASS. More...

#include <Metadata.h>

Inheritance diagram for mspass::utility::Metadata:

Collaboration diagram for mspass::utility::Metadata:

Public Member Functions
	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
double	get_double (const std::string key) const override
int	get_int (const std::string key) const override
long	get_long (const std::string key) const
std::string	get_string (const std::string key) const override
bool	get_bool (const std::string key) const override
template<typename T >
T	get (const std::string key) const
template<typename T >
T	get (const char *key) const
	Generic get interface for C char array.
boost::any	get_any (const std::string key) const
std::string	type (const std::string key) const
template<typename T >
void	put (const std::string key, T val) noexcept
template<typename T >
void	put (const char *key, T val) noexcept
void	put (const std::string key, const double val) override
void	put (const std::string key, const int val) override
void	put (const std::string key, const bool val) override
void	put (const std::string key, const std::string val) override
void	put (const char *key, const char *val)
void	put (std::string key, const char *val)
void	put_object (const std::string key, const pybind11::object val)
void	put_int (const std::string key, const int val)
void	put_string (const std::string key, const std::string val)
void	put_bool (const std::string key, const bool val)
void	put_double (const std::string key, const double val)
void	put_long (const std::string key, const long val)
void	append_chain (const std::string key, const std::string val, const std::string separator=std::string(":"))
std::set< std::string >	modified () const
void	clear_modified ()
	Mark all data as unmodified.
std::set< std::string >	keys () const noexcept
bool	is_defined (const std::string key) const noexcept
void	erase (const std::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)
	Change the keyword to access an attribute.
template<>
double	get (const std::string key) const
template<>
int	get (const std::string key) const
template<>
long	get (const std::string key) const
template<>
bool	get (const std::string key) const
template<>
float	get (const std::string key) const
template<>
double	get (const string key) const
template<>
int	get (const string key) const
template<>
long	get (const string key) const
template<>
bool	get (const string key) const
template<>
float	get (const string key) const
Public Member Functions inherited from mspass::utility::BasicMetadata
virtual	~BasicMetadata ()

Protected Attributes
std::map< std::string, boost::any >	md
std::set< std::string >	changed_or_set

Friends
pybind11::object	serialize_metadata_py (const Metadata &md)
Metadata	restore_serialized_metadata_py (const pybind11::object &sd)
std::ostringstream &	operator<< (std::ostringstream &, const mspass::utility::Metadata &)

Detailed Description

Type-safe metadata container used throughout MsPASS.

Metadata stores named scalar values in a boost::any map and provides typed accessors, serialization helpers, and merge/update operations for seismic data headers and processing state.

Constructor & Destructor Documentation

Metadata() [1/3]

mspass::utility::Metadata::Metadata ( )

inline

Default constructor. Does nothing.

{};

Metadata() [2/3]

mspass::utility::Metadata::Metadata	(	std::ifstream &	ifs,
		const std::string	form = std::string("pf")
	)

Construct from a file.

This simple file based constructor assumes the file contains only a set lines with this format: key value type where type must be one of: real, integer, bool, or string. Note int is actually always promoted to a long. The optional format variable is there to allow alternative formats in the future.

Parameters

ifs	ifstream from which to read data
form	optional format specification. Currently only default of "text" is accepted.

Exceptions

MsPASSError

can be thrown for a variety of conditions.

                                                         {
  try {
    char linebuffer[256];
    while (ifs.getline(linebuffer, 128)) {
      string s1, s2, s3;
      boost::any a;
      stringstream ss(linebuffer);
      ss >> s1;
      ss >> s2;
      ss >> s3;
      if (s3 == "real") {
        double dval;
        dval = atof(s2.c_str());
        a = dval;
        md[s1] = a;
        changed_or_set.insert(s1);
      } else if (s3 == "integer") {
        long ival;
        ival = atol(s2.c_str());
        a = ival;
        md[s1] = a;
        changed_or_set.insert(s1);
      } else if (s3 == "string") {
        string sval;
        a = sval;
        md[s1] = a;
        changed_or_set.insert(s1);
      } else if (s3 == "bool") {
        bool bval;
        if ((s2 == "TRUE") || (s2 == "true") || (s2 == "1"))
          bval = true;
        else
          bval = false;
        a = bval;
        md[s1] = a;
        changed_or_set.insert(s1);
      } else {
        stringstream sserr;
        sserr
            << "Metadata file constructor:  Illegal type specification for key="
            << s1 << " with a value field of " << s2 << endl
            << "type specified as " << s3 << " is illegal.  "
            << "Must be on of the following:  real, integer, bool, or string."
            << endl;
        throw MsPASSError(sserr.str(), ErrorSeverity::Invalid);
      }
    }
  } catch (...) {
    throw;
  };
}

References changed_or_set, get(), and md.

Metadata() [3/3]

mspass::utility::Metadata::Metadata

(

const Metadata &

mdold

)

Standard copy constructor.

Parameters

mdold

parent object to be copied

    : md(parent.md), changed_or_set(parent.changed_or_set) {}

~Metadata()

virtual mspass::utility::Metadata::~Metadata ( )

inlinevirtual

Destructor - has to be explicitly implemented and declared virtual for reasons found in textbooks and various web forums. A very subtle feature of C++ inheritance.

{};

Member Function Documentation

append_chain()

void mspass::utility::Metadata::append_chain	(	const std::string	key,
		const std::string	val,
		const std::string	separator = std::string(":")
	)

Create or append to a chained string.

A chain conceptually is identical to a list of string data. We implement it in Metadata because sometimes (e.g. MongoDB interaction and some constructs like the unix shell PATH variable) handling a full scale container like list<std::string> would be awkward. If more extensive capability like that is needed it would be better to add a class that inherits Metadata and does so. AntelopePf more or less does this, for example, handling Tbl sections. In any case, this usage is more for one word strings separated by a common separator: e.g. path=/usr/local/bin:/bin uses : as the separator. /usr/local/bin and /bin are the chain.

If the key related to the chain does not yet exist it is silently created. If it already exists and we append to it.

Parameters

key	is the key that defines the string.
val	is the the new string to append to the chain
separator	is the string used for a separator (default ":")

Exceptions

MsPASSError

will be thrown if data is found in key and it is not of type string.

                                                       {
  if (this->is_defined(key)) {
    string typ = this->type(key);
    if (typ.find("string") == string::npos)
      throw MsPASSError("Metadata::append_chain:  data for key=" + key +
                            " is not string type but " + typ +
                            "\nMust be string type to define a valid chain",
                        ErrorSeverity::Invalid);
    string sval = this->get_string(key);
    sval += separator;
    sval += val;
    this->put(key, sval);
  } else {
    this->put(key, val);
  }
  changed_or_set.insert(key);
}

References changed_or_set, get(), get_string(), is_defined(), put(), and type().

begin()

std::map< string, boost::any >::const_iterator mspass::utility::Metadata::begin ( ) const

noexcept

Return iterator to beginning of internal map container.

                                                                      {
  return md.begin();
}

References md.

change_key()

void mspass::utility::Metadata::change_key	(	const std::string	oldkey,
		const std::string	newkey
	)

Change the keyword to access an attribute.

Sometimes it is useful to change the key used to access a particular piece of data. Doing so, for example, is one way to implement an alias (alternative name) for something. The entry for the old key is copied to a entry accessible by the new key. The entry for old is then deleted. This avoids downstream inconsistencies a the cost of possible failures from the translation. This method always returns and will silently do nothing if old is not defined. If the new key is already defined, its content will be replaced by the old's.

Parameters

oldkey	is the key to search for to be changed
newkey	is the new key to use for the replacement.

                                                                  {
  map<string, boost::any>::iterator mdptr;
  mdptr = md.find(oldkey);
  /* We silently do nothing if old is not found */
  if (mdptr != md.end()) {
    md.insert_or_assign(newkey, mdptr->second);
    md.erase(mdptr);
  }
}

References erase(), get(), and md.

clear_modified()

void mspass::utility::Metadata::clear_modified ( )

inline

Mark all data as unmodified.

There are situations where it is necessary to clear the data structure used to mark changed metadata. The best example know is when data objects interact with a database and try to do updates. Effort can be wasted in unnecessary updates if metadata are improperly marked as modified. This method clears the entire container that defines changed data.

{ changed_or_set.clear(); };

References changed_or_set.

end()

std::map< string, boost::any >::const_iterator mspass::utility::Metadata::end ( ) const

noexcept

Return iterator to end of internal map container.

                                                                    {
  return md.end();
}

References md.

erase()

void mspass::utility::Metadata::erase

(

const std::string

key

)

Overload for C string

Clear data associated with a particular key.

                                        {
  map<string, boost::any>::iterator iptr;
  iptr = md.find(key);
  if (iptr != md.end())
    md.erase(iptr);
  /* Also need to modify this set if the key is found there */
  set<std::string>::iterator sptr;
  sptr = changed_or_set.find(key);
  if (sptr != changed_or_set.end())
    changed_or_set.erase(sptr);
}

References changed_or_set, get(), and md.

get() [1/12]

template<typename T >

T mspass::utility::Metadata::get ( const char *  key ) const

inline

Generic get interface for C char array.

This is a generic interface most useful for template procedures
that need to get a Metadata component.   Since this object only
can contain simple types the type requested must be simple.
Currently supports only int, long, short, double, float, and string.
C char* is intentionally not supported. This is largely a wrapper
on the string key version of this same generic function.

\param key is the name tag of desired component.

\exception - will throw a MetadataGetError (child of MsPASSError) for
   type mismatch or in an overflow or underflow condition.

                                                     {
    try {
      T val;
      val = get<T>(std::string(key));
      return val;
    } catch (...) {
      throw;
    };
  }

References get().

get() [2/12]

template<typename T >

T mspass::utility::Metadata::get

(

const std::string

key

)

const

Generic get interface.

This is a generic interface most useful for template procedures that need to get a Metadata component. Since this object only can contain simple types the type requested must be simple. Currently supports only int, long, short, double, float, and string. C char* is intentionally not supported. Calls to anything but the supported types will throw an exception.

Parameters

key	is the name tag of desired component.

Exceptions

-	will throw a MetadataGetError (child of MsPASSError) for type mismatch or in an overflow or underflow condition.

                                                               {
  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;
}

References get(), and md.

get() [3/12]

template<>

double mspass::utility::Metadata::get

(

const std::string

key

)

const

Specialization of Metadata::get for double values.

get() [4/12]

template<>

int mspass::utility::Metadata::get

(

const std::string

key

)

const

Specialization of Metadata::get for int values.

get() [5/12]

template<>

long mspass::utility::Metadata::get

(

const std::string

key

)

const

Specialization of Metadata::get for long values.

get() [6/12]

template<>

bool mspass::utility::Metadata::get

(

const std::string

key

)

const

Specialization of Metadata::get for bool values.

get() [7/12]

template<>

float mspass::utility::Metadata::get

(

const std::string

key

)

const

Specialization of Metadata::get for float values.

get() [8/12]

template<>

double mspass::utility::Metadata::get

(

const string

key

)

const

Specialization returning numeric metadata as a double.

                                                               {
  return this->get_double(key);
}

References get_double().

get() [9/12]

template<>

int mspass::utility::Metadata::get

(

const string

key

)

const

Specialization returning integer-valued metadata as an int.

                                                         {
  return this->get_int(key);
}

References get_int().

get() [10/12]

template<>

long mspass::utility::Metadata::get

(

const string

key

)

const

Specialization returning integer-valued metadata as a long.

                                                           {
  return this->get_long(key);
}

References get_long().

get() [11/12]

template<>

bool mspass::utility::Metadata::get

(

const string

key

)

const

Specialization returning boolean metadata as a bool.

                                                           {
  return this->get_bool(key);
}

References get_bool().

get() [12/12]

template<>

float mspass::utility::Metadata::get

(

const string

key

)

const

Specialization returning numeric metadata as a float when in range.

                                                             {
  map<string, boost::any>::const_iterator iptr;
  iptr = md.find(key);
  if (iptr == md.end())
    throw MetadataGetError(key, typeid(float).name());
  if (iptr->second.type() == typeid(float))
    return boost::any_cast<float>(iptr->second);
  double val(0.0);
  if (any_to_double(iptr->second, val) && isfinite(val) &&
      val >= -static_cast<double>(numeric_limits<float>::max()) &&
      val <= static_cast<double>(numeric_limits<float>::max()))
    return static_cast<float>(val);
  throw MetadataGetError(
      key, typeid(float).name(), iptr->second.type().name(),
      "Metadata value is not numeric or is outside float range");
}

References get(), and md.

get_any()

boost::any mspass::utility::Metadata::get_any ( const std::string  key ) const

inline

Get the boost::any container from the Metadata object.

This method is mostly for Python bindings so that a generic get method can work in Python.

Parameters

key	is the name tag of desired component.

Exceptions

-	MetadataGetError if requested parameter is not found.

                                              {
    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;
  };

References get(), and md.

get_bool()

bool mspass::utility::Metadata::get_bool ( const std::string  key ) const

overridevirtual

Get a boolean parameter from the Metadata object.

Exceptions

MetadataGetError

if requested parameter is not found or there is a type mismatch.

Parameters

key	keyword associated with requested metadata member.

Implements mspass::utility::BasicMetadata.

                                              {
  map<string, boost::any>::const_iterator iptr;
  iptr = md.find(key);
  if (iptr == md.end())
    throw MetadataGetError(key, typeid(bool).name());
  bool val(false);
  if (any_to_bool(iptr->second, val))
    return val;
  throw MetadataGetError(key, typeid(bool).name(), iptr->second.type().name(),
                         "Metadata value is not boolean");
}

References get(), and md.

get_double()

double mspass::utility::Metadata::get_double ( const std::string  key ) const

overridevirtual

Get a real number from the Metadata object.

Exceptions

MetadataGetError

if requested parameter is not found or there is a type mismatch.

Parameters

key	keyword associated with requested metadata member.

Implements mspass::utility::BasicMetadata.

                                                  {
  map<string, boost::any>::const_iterator iptr;
  iptr = md.find(key);
  if (iptr == md.end())
    throw MetadataGetError(key, typeid(double).name());
  double val(0.0);
  if (any_to_double(iptr->second, val))
    return val;
  throw MetadataGetError(key, typeid(double).name(), iptr->second.type().name(),
                         "Metadata value is not numeric");
}

References get(), and md.

get_int()

int mspass::utility::Metadata::get_int ( const std::string  key ) const

overridevirtual

Get an integer from the Metadata object.

Exceptions

MetadataGetError

if requested parameter is not found or there is a type mismatch.

Parameters

key	keyword associated with requested metadata member.

Implements mspass::utility::BasicMetadata.

                                            {
  map<string, boost::any>::const_iterator iptr;
  iptr = md.find(key);
  if (iptr == md.end())
    throw MetadataGetError(key, typeid(int).name());
  long val(0);
  if (any_to_long(iptr->second, val) &&
      val >= static_cast<long>(numeric_limits<int>::min()) &&
      val <= static_cast<long>(numeric_limits<int>::max()))
    return static_cast<int>(val);
  throw MetadataGetError(
      key, typeid(int).name(), iptr->second.type().name(),
      "Metadata value is not integer-valued or is outside int range");
}

References get(), and md.

get_long()

long mspass::utility::Metadata::get_long

(

const std::string

key

)

const

Get a long integer from the Metadata object.

Exceptions

MetadataGetError

if requested parameter is not found or there is a type mismatch.

Parameters

key	keyword associated with requested metadata member.

                                              {
  map<string, boost::any>::const_iterator iptr;
  iptr = md.find(key);
  if (iptr == md.end())
    throw MetadataGetError(key, typeid(long).name());
  long val(0);
  if (any_to_long(iptr->second, val))
    return val;
  throw MetadataGetError(
      key, typeid(long).name(), iptr->second.type().name(),
      "Metadata value is not integer-valued or is outside long range");
}

References get(), and md.

get_string()

std::string mspass::utility::Metadata::get_string ( const std::string  key ) const

inlineoverridevirtual

Get a string from the Metadata object.

Note the string in this case can be quite large. If the string was parsed from an Antelope Pf nested Tbl and Arrs can be extracted this way and parsed with pf routines.

Exceptions

MetadataGetError

if requested parameter is not found or there is a type mismatch.

Parameters

key	keyword associated with requested metadata member.

Implements mspass::utility::BasicMetadata.

                                                           {
    try {
      std::string val;
      val = get<std::string>(key);
      return val;
    } catch (...) {
      throw;
    };
  };

References get().

is_defined()

bool mspass::utility::Metadata::is_defined ( const std::string  key ) const

noexcept

Test if a key has an associated value. Returns true if a value is defined.

                                                         {
  map<string, boost::any>::const_iterator mptr;
  mptr = md.find(key);
  if (mptr != md.end()) {
    return true;
  } else {
    return false;
  }
}

keys()

set< string > mspass::utility::Metadata::keys ( ) const

noexcept

Return all keys without any type information.

                                          {
  set<string> result;
  map<string, boost::any>::const_iterator mptr;
  for (mptr = md.begin(); mptr != md.end(); ++mptr) {
    string key(mptr->first);
    result.insert(key);
  }
  return result;
}

References get(), and md.

modified()

std::set< std::string > mspass::utility::Metadata::modified ( ) const

inline

Return the keys of all altered Metadata values.

{ return changed_or_set; };

References changed_or_set.

operator+()

const Metadata mspass::utility::Metadata::operator+

(

const Metadata &

other

)

const

Add two Metadata objects. Uses operator+=

                                                              {
  Metadata result(*this);
  result += other;
  return result;
}

References get().

operator+=()

Metadata & mspass::utility::Metadata::operator+= ( const Metadata &  rhs )

noexcept

Append additional metadata with replacement.

A plus operator implies addition, but this overloading does something very different. A simple way to describe the effect is that on completion the left hand side Metadata object will contain a duplicate of the right hand side plus any attributes in the rhs that were not present on the lhs. Another way to clarify this is to describe the algorithm. We take each attribute on the right and search for it in the lhs. If it is not in the lhs it will be added. If it is there already, the rhs value will replace the old value on the lhs. This is most useful when an algorithm creates a new set of attributes that we want to use in downstream processing but retain all the other attributes.

Parameters

rhs	is the new metadata to be insert/replace on the lhs.

                                                           {
  if (this != (&rhs)) {
    /* We depend here upon the map container replacing values associated with
    existing keys.  We mark all entries changes anyway.  This is a vastly
    simpler algorithm than the old SEISPP::Metadata.  */
    map<string, boost::any>::const_iterator rhsptr;
    for (rhsptr = rhs.md.begin(); rhsptr != rhs.md.end(); ++rhsptr) {
      md[rhsptr->first] = rhsptr->second;
      changed_or_set.insert(rhsptr->first);
    }
  }
  return *this;
}

operator=()

Metadata & mspass::utility::Metadata::operator=

(

const Metadata &

mdold

)

Standard assignment operator.

Parameters

mdold

parent object to copy

                                                    {
  if (this != (&parent)) {
    md = parent.md;
    changed_or_set = parent.changed_or_set;
  }
  return *this;
}

References changed_or_set, get(), and md.

put() [1/8]

void mspass::utility::Metadata::put ( const char *  key, const char *  val  )

inline

Put a C string literal. Requires special handling because it is not copy constructable (see warning in boost docs: https://theboostcpplibraries.com/boost.any

                                             {
    std::string sval(val);
    this->put<std::string>(key, val);
  }

References get().

put() [2/8]

template<typename T >

void mspass::utility::Metadata::put ( const char *  key, T  val  )

inlinenoexcept

Store a value using a C string key.

Parameters

key	null-terminated metadata key to create or replace.
val	value copied into the internal boost::any map.

                                                                  {
    /* 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));
  }

References changed_or_set, get(), and md.

put() [3/8]

void mspass::utility::Metadata::put ( const std::string  key, const bool  val  )

inlineoverridevirtual

Store a boolean attribute.

Parameters

key	metadata key to create or replace.
val	value to store.

Implements mspass::utility::BasicMetadata.

                                                         {
    this->put<bool>(key, val);
  };

References get().

put() [4/8]

void mspass::utility::Metadata::put ( const std::string  key, const double  val  )

inlineoverridevirtual

Store a double-valued attribute.

Parameters

key	metadata key to create or replace.
val	value to store.

Implements mspass::utility::BasicMetadata.

                                                           {
    this->put<double>(key, val);
  };

References get().

put() [5/8]

void mspass::utility::Metadata::put ( const std::string  key, const int  val  )

inlineoverridevirtual

Store an integer-valued attribute.

Parameters

key	metadata key to create or replace.
val	value to store.

Implements mspass::utility::BasicMetadata.

                                                        {
    this->put<int>(key, val);
  };

References get().

put() [6/8]

void mspass::utility::Metadata::put ( const std::string  key, const std::string  val  )

inlineoverridevirtual

Store a string-valued attribute.

Parameters

key	metadata key to create or replace.
val	value to store.

Implements mspass::utility::BasicMetadata.

                                                              {
    this->put<std::string>(key, val);
  };

References get().

put() [7/8]

template<typename T >

void mspass::utility::Metadata::put ( const std::string  key, T  val  )

inlinenoexcept

Store a value of any boost::any-compatible C++ type.

The key is marked as changed so database update logic can detect it.

Parameters

key	metadata key to create or replace.
val	value copied into the internal boost::any map.

                                                                      {
    boost::any aval = val;
    md[key] = aval;
    changed_or_set.insert(key);
  }

References changed_or_set, get(), and md.

put() [8/8]

void mspass::utility::Metadata::put ( std::string  key, const char *  val  )

inline

Store a C string value using a std::string key.

Parameters

key	metadata key to create or replace.
val	null-terminated string value to store.

{ this->put(key.c_str(), val); }

References get(), and put().

put_bool()

void mspass::utility::Metadata::put_bool ( const std::string  key, const bool  val  )

inline

Store a bool through the Python-friendly typed wrapper.

                                                     {
    this->put<bool>(key, val);
  };

References get().

put_double()

void mspass::utility::Metadata::put_double ( const std::string  key, const double  val  )

inline

Store a double through the Python-friendly typed wrapper.

                                                         {
    this->put<double>(key, val);
  };

References get().

put_int()

void mspass::utility::Metadata::put_int ( const std::string  key, const int  val  )

inline

Store an int through the Python-friendly typed wrapper.

                                                   {
    this->put<int>(key, val);
  };

References get().

put_long()

void mspass::utility::Metadata::put_long ( const std::string  key, const long  val  )

inline

Store a long through the Python-friendly typed wrapper.

                                                     {
    this->put<long>(key, val);
  };

References get().

put_object()

void mspass::utility::Metadata::put_object ( const std::string  key, const pybind11::object  val  )

inline

Store a pybind11 object for Python-facing metadata.

Parameters

key	metadata key to create or replace.
val	Python object to store in the metadata map.

                                                                 {
    this->put<pybind11::object>(key, val);
  }

References get().

put_string()

void mspass::utility::Metadata::put_string ( const std::string  key, const std::string  val  )

inline

Store a string through the Python-friendly typed wrapper.

                                                            {
    this->put<std::string>(key, val);
  };

References get().

size()

std::size_t mspass::utility::Metadata::size ( ) const

noexcept

Overload for C string

Return the size of the internal map container.

{ return md.size(); }

References md.

type()

std::string mspass::utility::Metadata::type

(

const std::string

key

)

const

Return the stored C++ type name for a metadata value.

Parameters

key	metadata key to inspect.

Returns

demangled type name of the value stored for key.

Exceptions

MetadataGetError

if key is undefined.

                                               {
  try {
    boost::any a = this->get_any(key);
    return demangled_name(a);
  } catch (...) {
    throw;
  };
}

References get(), and get_any().

Friends And Related Symbol Documentation

operator<<

std::ostringstream & operator<< ( std::ostringstream &  , const mspass::utility::Metadata &    )

friend

Standard operator for overloading output to a stringstream

restore_serialized_metadata_py

Metadata restore_serialized_metadata_py ( const pybind11::object &  sd )

friend

Unpack serialized Metadata.

This function is the inverse of the serialize function. It recreates a Metadata object serialized previously with the serialize function.

Parameters

sd	is the serialized data to be unpacked

Returns

Metadata derived from sd

                                                                 {
  pybind11::gil_scoped_acquire acquire;
  try {
    pybind11::module pickle = pybind11::module::import("pickle");
    pybind11::object loads = pickle.attr("loads");
    pybind11::tuple md_dump = loads(s);
    pybind11::dict md_dict = md_dump[0];
    pybind11::object md_py = pybind11::module_::import("mspasspy.ccore.utility")
                                 .attr("Metadata")(md_dict);
    Metadata md = md_py.cast<Metadata>();
    md.changed_or_set = md_dump[1].cast<std::set<std::string>>();
    pybind11::gil_scoped_release release;
    return md;
  } catch (...) {
    pybind11::gil_scoped_release release;
    throw;
  };
}

serialize_metadata_py

pybind11::object serialize_metadata_py ( const Metadata &  md )

friend

Serialize Metadata to a python bytes object. This function is needed to support pickle in the python interface. It cast the C++ object to a Python dict and calls pickle against that dict directly to generate a Python bytes object. This may not be the most elegant approach, but it should be bombproof.

Parameters

md	is the Metadata object to be serialized

Returns

pickle serialized data object.

                                                         {
  pybind11::gil_scoped_acquire acquire;
  try {
    pybind11::dict md_dict = pybind11::cast(md);
    pybind11::set changed_or_set = pybind11::cast(md.changed_or_set);
    pybind11::module pickle = pybind11::module::import("pickle");
    pybind11::object dumps = pickle.attr("dumps");
    pybind11::object md_dump =
        dumps(pybind11::make_tuple(md_dict, changed_or_set));
    pybind11::gil_scoped_release release;
    return md_dump;
  } catch (...) {
    pybind11::gil_scoped_release release;
    throw;
  };
}

Member Data Documentation

changed_or_set

std::set<std::string> mspass::utility::Metadata::changed_or_set

protected

Keys that have been created or changed since the last clear_modified.

md

std::map<std::string, boost::any> mspass::utility::Metadata::md

protected

Map from metadata key to value stored in a boost::any container.

---

The documentation for this class was generated from the following files:

• /home/runner/work/mspass/mspass/cxx/include/mspass/utility/Metadata.h
• /home/runner/work/mspass/mspass/cxx/src/lib/utility/Metadata.cc