MHO_ParameterStore.hh

Go to the documentation of this file.

#ifndef MHO_ParameterStore_HH__
#define MHO_ParameterStore_HH__
 
#include <string>
 
#include "MHO_JSONHeaderWrapper.hh"
#include "MHO_Message.hh"
#include "MHO_Tokenizer.hh"
 
namespace hops
{
 
class MHO_ParameterStore
{
    public:
        MHO_ParameterStore()
        {
            fTokenizer.SetDelimiter("/");
            fTokenizer.SetRemoveLeadingTrailingWhitespaceTrue();
            fTokenizer.SetIncludeEmptyTokensFalse();
        };
 
        ~MHO_ParameterStore(){};
 
        void Dump() { std::cout << fStore.dump(2) << std::endl; }
 
        void CopyFrom(const MHO_ParameterStore& copy) { fStore = copy.fStore; }
 
        void DumpData(mho_json& data) { data = fStore; }
 
        void FillData(const mho_json& data) { fStore = data; }
 
        void ClearData() { fStore.clear(); }
 
        //returns true if no error adding value
        template< typename XValueType > bool Set(const std::string& value_path, const XValueType& value);
 
        bool Set(const std::string& value_path, const mho_json& value)
        {
            try
            {
                fStore[mho_json::json_pointer(SanitizePath(value_path))] = value;
                return true;
            }
            catch(...)
            {
                return false;
            }
        }
 
        template< typename XValueType > bool Get(const std::string& value_path, XValueType& value) const;
 
        template< typename XValueType > XValueType GetAs(const std::string& value_path) const;
 
        template< typename XValueType > XValueType GetRequiredAs(const std::string& value_path) const;
 
        bool IsPresent(const std::string& value_path) const
        {
            std::string path = SanitizePath(value_path);
            fPath.clear();
            fTokenizer.SetString(&path);
            fTokenizer.GetTokens(&fPath);
 
            auto* p = &fStore;
            for(auto it = fPath.begin(); it != fPath.end(); it++)
            {
                auto jit = p->find(*it);
                if(jit == p->end())
                {
                    return false;
                }
                else if(*it == *(fPath.rbegin()))
                {
                    return true;
                }
                else
                {
                    p = &(jit.value());
                }
            }
            return false;
        }
 
    private:
        std::string SanitizePath(const std::string& value_path) const
        {
            std::string vpath = MHO_Tokenizer::TrimLeadingAndTrailingWhitespace(value_path);
            if(vpath.size() > 0 && vpath.back() == '/') //trim any trailing '/'
            {
                vpath.pop_back();
            }
            return vpath;
        }
 
        //helpers
        mutable MHO_Tokenizer fTokenizer;
        mutable std::vector< std::string > fPath;
 
        //stash data in a json object
        mho_json fStore;
};
 
template< typename XValueType > bool MHO_ParameterStore::Set(const std::string& value_path, const XValueType& value)
{
    //first we tokenize the value path into a sequence of names
    std::string path = SanitizePath(value_path);
    fPath.clear();
    fTokenizer.SetString(&path);
    fTokenizer.GetTokens(&fPath);
 
    bool ok = false;
    if(fPath.size() > 0)
    {
        //insert and/or replace an object
        auto* p = &fStore;
        for(auto it = fPath.begin(); it != fPath.end(); it++)
        {
            if(*it != *(fPath.rbegin()))
            {
                if(p->contains(*it)) //item with path exists
                {
                    p = &(p->at(*it)); //point to this item
                }
                else
                {
                    //item doesn't exist yet, so create an entry with this key (*it)
                    p = &(*p)[*it];
                }
            }
            else //we've arrived at the terminal point, so set this item to the value
            {
                p = &(*p)[*it];
                *p = value;
                ok = true;
            }
        }
    }
    return ok;
}
 
template< typename XValueType > bool MHO_ParameterStore::Get(const std::string& value_path, XValueType& value) const
{
    //NOTE: we do not use json_pointer to access values specified by path
    //because it will throw an exception if used when the path is not present/complete
    std::string path = SanitizePath(value_path);
    fPath.clear();
    fTokenizer.SetString(&path);
    fTokenizer.GetTokens(&fPath);
 
    bool present = false;
    auto* p = &fStore;
    for(auto it = fPath.begin(); it != fPath.end(); it++)
    {
        auto jit = p->find(*it);
        if(jit == p->end())
        {
            return false;
        }
        else if(*it == *(fPath.rbegin()))
        {
            value = jit->get< XValueType >();
            return true;
        }
        else
        {
            p = &(jit.value());
        }
    }
    return false;
}
 
template< typename XValueType > XValueType MHO_ParameterStore::GetAs(const std::string& value_path) const
{
    XValueType v = XValueType(); //default constructor (zero for int, double, etc)
    bool ok = Get(value_path, v);
    if(!ok)
    {
        msg_error("utility", "failed to retrieve value for: " << value_path << " returning a default value" << eom);
    }
    return v;
}
 
template< typename XValueType > XValueType MHO_ParameterStore::GetRequiredAs(const std::string& value_path) const
{
    XValueType v = XValueType(); //default constructor (zero for int, double, etc)
    bool ok = Get(value_path, v);
    if(!ok)
    {
        msg_fatal("utility", "failed to retrieve value: " << value_path << ", aborting" << eom);
        HOPS_THROW;
    }
    return v;
}
 
} // namespace hops
 
#endif