HEPnOS client API: Storing and loading C++ objects

DataSets, Runs, SubRuns, and Events are typed key/value stored. The provide two functions: store and load, which can be used to store and load C++ objects. These methods are template functions with the following prototype:

template<typename K, typename V>
bool store(const K& key, const V& value);

template<typename K, typename V>
bool load(const K& key, V& value);

The store function will return true if the key/value pair has successfully been stored, false if an object of the same key and type already exists in the container.

The load function will return true if the value was correctly loaded, false if the key does not exist (or does not exist for the provided value type).

The type K of the key can be any type that can be streamed into an std::stringstream (for instance all basic types, as well as the std::string types, can be used as key). The string generated when streaming the object into an std::stringstream should not contain the /, %, or # characters.

The type V of the value can be any type that can be serialized with Boost. This includes all basic types, as well as all STL containers (provided that you include <boost/serialization/X.hpp>, where X is the name of the STL container you want to serialize), and user-defined types that have a serialize template member function.

Example

The following code defines the Particle class as value and the InputTag as key.

#include <sstream>
#include <iostream>
#include <boost/serialization/vector.hpp>
#include <hepnos.hpp>

class InputTag {
    private:
        template<typename S>
        friend S& operator<<(S&, const InputTag&);
        std::string _a;
        std::string _b;
    public:
        InputTag(const std::string& a, const std::string& b)
            : _a(a), _b(b) {}
};

template<typename S>
S& operator<<(S& ss, const InputTag& t) {
    ss << t._a << "_" << t._b;
    return ss;
}

class Particle {
    private:
        friend class boost::serialization::access;
        std::vector<double> position;
        uint8_t             charge;

        /* any serializable class needs to have this function.
           Note that if your class has members that are STL containers
           (e.g. std::vector<X>) then you will need to #include
           the corresponding Boost header (e.g. boot/serialization/vector.hpp).
           For more information about the serialization mechanism,
           see here: http://www.boost.org/doc/libs/1_66_0/libs/serialization/doc/index.html
         */
		 template<typename A>
		 void serialize(A& ar, const unsigned int version) {
		     ar & position;
		     ar & charge;
		 }

	public:
		Particle() = default;

		Particle(double x, double y, double z, uint8_t c)
		: position{x,y,z}, charge(c) {}

		bool operator==(const Particle& other) {
		    if(charge != other.charge) return false;
		    if(position.size() != other.position.size()) return false;
		    for(unsigned i=0; i<position.size(); i++) {
		        if(position[i] != other.position[i]) return false;
		    }
		    return true;
		}
};

using namespace hepnos;

int main(int argc, char** argv) {
    if(argc != 2) {
        std::cerr << "Usage: " << argv[1] << " <configfile>" << std::endl;
        exit(-1);
    }

    DataStore datastore(argv[1]);

    DataSet ds = datastore.createDataSet("fermilab");

    InputTag tag("AAA","BBB");
    Particle p_in(3.4, 5.6, 7.8, 42);
    Particle p_out;

    std::cout << "p_in == p_out ? " << (p_in == p_out) << std::endl;

    ds.store(tag, p_in);
    ds.load(tag, p_out);

    std::cout << "p_in == p_out ? " << (p_in == p_out) << std::endl;

    datastore.shutdown();
    return 0;
}

The same can be done using Runs, SubRuns, and Events. You can use keys as simple as a string and as complex as any object type that can be streamed into an std::stringstream to be converted into an std::string.

Important note: key/value pairs are typed. Under the hood, HEPnOS appends the name of the type V to the provided key. Hence you can associated multiple objects with the same key, provided that they are of different types. Make sure to use the right type of object when loading back.