infomodel_base.h

Go to the documentation of this file.

 
#ifndef UTILITIES_INFOMODEL_BASE_H_INCLUDED
#define UTILITIES_INFOMODEL_BASE_H_INCLUDED
 
#include <a_util/preprocessor/detail/disable_warnings.h>
#include <ddl/utilities/ddl_error.h>
#include <ddl/utilities/access_observer.h>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <cstdint>
 
namespace ddl {
 
namespace dd {
 
namespace datamodel {

class IInfo {
public:
    virtual ~IInfo() = default;

    virtual uint8_t getInfoType() const = 0;
};

template <typename INFO_T>
class Info : public IInfo {
protected:
    uint8_t getInfoType() const override
    {
        return INFO_T::INFO_TYPE_ID;
    }
};

class InfoMap {
public:
    InfoMap() = default;
    InfoMap(const InfoMap&){};
    InfoMap(InfoMap&&){};
    InfoMap& operator=(const InfoMap&)
    {
        return *this;
    };

    InfoMap& operator=(InfoMap&&)
    {
        return *this;
    };

    template <typename INFO_T>
    const INFO_T* getInfo() const
    {
        return dynamic_cast<const INFO_T*>(getInfo(INFO_T::INFO_TYPE_ID));
    }

    template <typename INFO_T>
    INFO_T* getInfo()
    {
        return dynamic_cast<INFO_T*>(getInfo(INFO_T::INFO_TYPE_ID));
    }

    template <typename INFO_T>
    void setInfo(const std::shared_ptr<INFO_T>& info)
    {
        std::shared_ptr<IInfo> info_downcast = info;
        if (info_downcast->getInfoType() == INFO_T::INFO_TYPE_ID) {
            setInfo(info_downcast);
        }
        else {
            throw Error(
                "InfoMap::setInfo",
                "Registration not possible, runtime info is differnt then compiletime info");
        }
    }
 
private:
    IInfo* getInfo(uint8_t info_type)
    {
        auto found = _infos.find(info_type);
        if (found != _infos.end()) {
            return found->second.get();
        }
        else {
            return nullptr;
        }
    }
    const IInfo* getInfo(uint8_t info_type) const
    {
        auto found = _infos.find(info_type);
        if (found != _infos.cend()) {
            return found->second.get();
        }
        else {
            return nullptr;
        }
    }
    void setInfo(const std::shared_ptr<IInfo>& info)
    {
        _infos[info->getInfoType()] = info;
    }
 
#if defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#endif // defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
 
    std::unordered_map<uint8_t, std::shared_ptr<IInfo>> _infos;
 
#if defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
};
 
} // namespace datamodel
} // namespace dd
 
namespace utility {
    using ::ddl::dd::datamodel::IInfo;
    using ::ddl::dd::datamodel::Info;
    using ::ddl::dd::datamodel::InfoMap;
}
 
} // namespace ddl
 
#endif // UTILITIES_INFOMODEL_BASE_H_INCLUDED