MHO_IndexLabelInterface.hh

Go to the documentation of this file.

#ifndef MHO_IndexLabelInterface_HH__
#define MHO_IndexLabelInterface_HH__
 
#include "MHO_JSONHeaderWrapper.hh"
 
namespace hops
{
 
class MHO_IndexLabelInterface
{
 
    protected:
        MHO_IndexLabelInterface(): fIndexLabelObjectPtr(nullptr)
        {
            fDummy["index"] = -1; //dummy object for invalid returns, always has an invalid index
        };
 
        MHO_IndexLabelInterface(const MHO_IndexLabelInterface& copy) { fIndexLabelObjectPtr = copy.fIndexLabelObjectPtr; };
 
        void SetIndexLabelObject(mho_json* obj) { fIndexLabelObjectPtr = obj; }
 
    public:
        virtual ~MHO_IndexLabelInterface(){};
 
        std::size_t GetIndexLabelSize() const { return fIndexLabelObjectPtr->size(); }
 
        void ClearIndexLabels()
        {
            //(*fIndexLabelObjectPtr) = mho_json();
            fIndexLabelObjectPtr->clear();
        }
 
        template< typename XValueType >
        void InsertIndexLabelKeyValue(std::size_t index, const std::string& key, const XValueType& value)
        {
            if(fIndexLabelObjectPtr != nullptr)
            {
                std::string ikey = index2key(index);
                if(!(fIndexLabelObjectPtr->contains(ikey)))
                {
                    //no such object, so insert one, make sure it gets an 'index' value
                    (*fIndexLabelObjectPtr).emplace(ikey, fDummy);
                    (*fIndexLabelObjectPtr)[ikey]["index"] = index;
                }
                //now update
                mho_json obj;
                obj[key] = value;
                (*fIndexLabelObjectPtr)[ikey].update(obj);
            }
            else
            {
                msg_error("utilities", "cannot insert key:value pair, index label interface is missing object!" << eom);
            }
        }
 
        template< typename XValueType >
        bool RetrieveIndexLabelKeyValue(std::size_t index, const std::string& key, XValueType& value) const
        {
            if(fIndexLabelObjectPtr != nullptr)
            {
                std::string ikey = index2key(index);
                if((*fIndexLabelObjectPtr)[ikey].contains(key))
                {
                    value = (*fIndexLabelObjectPtr)[ikey][key].get< XValueType >();
                    return true;
                }
            }
            else
            {
                msg_error("utilities", "cannot retrieve key:value pair, index label interface is missing object!" << eom);
            }
            return false;
        }
 
        void SetLabelObject(mho_json& obj, std::size_t index)
        {
            if(fIndexLabelObjectPtr != nullptr)
            {
                if(obj.is_null())
                {
                    return;
                }
                if(!(fIndexLabelObjectPtr->is_object()))
                {
                    (*fIndexLabelObjectPtr) = mho_json();
                } //something blew away our object, reset
                std::string ikey = index2key(index);
                if(!(fIndexLabelObjectPtr->contains(ikey)))
                {
                    //no such object, so insert one, make sure it gets an 'index' value
                    // (*fIndexLabelObjectPtr).emplace(ikey, fDummy);
                    (*fIndexLabelObjectPtr)[ikey] = fDummy;
                    (*fIndexLabelObjectPtr)[ikey]["index"] = index;
                }
 
                //make sure the object also contains the index value:
                obj["index"] = index;
                (*fIndexLabelObjectPtr)[ikey].update(obj);
            }
            else
            {
                msg_error("utilities", "cannot insert label object, index label interface is missing object!" << eom);
            }
        }
 
        mho_json& GetLabelObject(std::size_t index)
        {
            if(fIndexLabelObjectPtr != nullptr)
            {
                std::string ikey = index2key(index);
                return (*fIndexLabelObjectPtr)[ikey];
            }
            else
            {
                msg_error("utilities", "cannot retrieve label object, index label interface is missing object!" << eom);
                return fDummy;
            }
        }
 
        mho_json GetLabelObject(std::size_t index) const
        {
            if(fIndexLabelObjectPtr != nullptr)
            {
                std::string ikey = index2key(index);
                return (*fIndexLabelObjectPtr)[ikey];
            }
            else
            {
                msg_error("utilities", "cannot retrieve label object, index label interface is missing object!" << eom);
                return fDummy;
            }
        }
 
        std::vector< std::size_t > GetMatchingIndexes(std::string& key) const
        {
            std::vector< std::size_t > idx;
            if(fIndexLabelObjectPtr != nullptr)
            {
                for(std::size_t i = 0; i < fIndexLabelObjectPtr->size(); i++)
                {
                    std::string ikey = index2key(i);
                    if((*fIndexLabelObjectPtr)[ikey].contains(key))
                    {
                        idx.push_back(i);
                    }
                }
            }
            else
            {
                msg_error("utilities", "cannot determine matching indexes, index label interface is missing object!" << eom);
            }
            return idx;
        }
 
        template< typename XValueType >
        std::vector< std::size_t > GetMatchingIndexes(std::string& key, const XValueType& value) const
        {
            std::vector< std::size_t > idx;
            if(fIndexLabelObjectPtr != nullptr)
            {
                for(std::size_t i = 0; i < fIndexLabelObjectPtr->size(); i++)
                {
                    std::string ikey = index2key(i);
                    if((*fIndexLabelObjectPtr)[ikey].contains(key))
                    {
                        XValueType v = (*fIndexLabelObjectPtr)[ikey][key].get< XValueType >();
                        if(v == value)
                        {
                            idx.push_back(i);
                        }
                    }
                }
            }
            else
            {
                msg_error("utilities", "cannot determine matching indexes, index label interface is missing object!" << eom);
            }
            return idx;
        }
 
    private:
 
        static std::string index2key(const std::size_t& idx) { return std::to_string(idx); }
 
        mho_json* fIndexLabelObjectPtr; //array of mho_json objects holding key:value pairs
        mho_json fDummy;
};
 
} // namespace hops
 
#endif