Resource.h

Go to the documentation of this file.

#ifndef WPP_RESOURCE_H
#define WPP_RESOURCE_H
 
#include <unordered_map>
#include <type_traits>
#include <variant>
 
#include "ObjectInfo.h"
#include "ItemOp.h"
#include "WppTypes.h"
#include "WppLogs.h"
 
namespace wpp {
 
class Resource {
public: /* ---------- Public subtypes ----------*/
    using DATA_T = std::variant<BOOL_T, INT_T, UINT_T, FLOAT_T, OPAQUE_T, OBJ_LINK_T, STRING_T, EXECUTE_T>;
 
    struct ResInst {
        ID_T id;
        DATA_T data;
    };
 
    using DATA_VERIFIER_T = std::variant<VERIFY_INT_T, VERIFY_UINT_T, VERIFY_FLOAT_T, VERIFY_OPAQUE_T, VERIFY_BOOL_T,
                                          VERIFY_OBJ_LINK_T, VERIFY_STRING_T, VERIFY_EXECUTE_T/*, VERIFY_CORE_LINK_T*/>; // VERIFY_CORE_LINK_T the same as VERIFY_STRING_T therefore we use only VERIFY_STRING_T
 
public: /* ---------- Public methods for common usage ----------*/
    Resource();
    Resource(ID_T id, const ItemOp &operation, IS_SINGLE isSingle, IS_MANDATORY isMandatory, TYPE_ID dataType);
    Resource(const Resource& resource);
    Resource(Resource&& resource);
    Resource& operator=(const Resource& other);
    Resource& operator=(Resource&& other);
 
    /* ---------- Methods for get resource metadata ----------*/
    ID_T getId() const;
    TYPE_ID getTypeId() const;
    const ItemOp& getOperation() const;
    bool isMandatory() const;
    bool isOptional() const;
    bool isSingle() const;
    bool isMultiple() const;
 
    /* ---------- Helpful methods for check resource parameters ----------*/
    template<typename T>
    bool isDataValueValid(const T &data) const;
 
    bool isExist(ID_T resInstId) const;
 
    size_t instCount() const;
 
    std::vector<ID_T> instIds() const;
 
    ID_T newInstId() const;
 
    /* ---------- Methods for manage verifier ----------*/
    bool setDataVerifier(const DATA_VERIFIER_T &verifier);
 
    /* ---------- Methods for manage resource data ----------*/
    template<typename T>
    bool set(const T &value, ID_T resInstId = SINGLE_INSTANCE_ID);
 
    template<typename T>
    bool set(T &&value, ID_T resInstId = SINGLE_INSTANCE_ID);
 
    template<typename T>
    const T& get(ID_T resInstId = SINGLE_INSTANCE_ID);
 
    template<typename T>
    bool add(const T &value);
 
    template<typename T>
    bool add(T &&value);
 
    bool remove(ID_T resInstId);
 
    bool clear();
 
private:
    template<typename T>
    bool isDataTypeValid() const;
    bool isDataVerifierValid(const DATA_VERIFIER_T &verifier) const;
    bool isInstanceIdPossible(ID_T resInstId) const;
    bool isTypeIdCompatible(TYPE_ID type) const;
    std::vector<ResInst>::iterator getInstIter(ID_T resInstId) const;
 
private: /* ---------- Private properties ----------*/
    ID_T _id;
    ItemOp _operation;
    IS_SINGLE _isSingle;
    IS_MANDATORY _isMandatory;
    TYPE_ID _typeID;
    mutable std::vector<ResInst> _instances;
    DATA_VERIFIER_T _dataVerifier;
};
 
 
/* ---------- Implementation of template methods ----------*/
template<typename T>
bool Resource::isDataTypeValid() const {
    TYPE_ID typeID = dataTypeToID<T>();
    return typeID != TYPE_ID::UNDEFINED && isTypeIdCompatible(typeID);
}
 
template<typename T>
bool Resource::set(const T &value, ID_T resInstId) {
    if(isSingle()) resInstId = SINGLE_INSTANCE_ID;
    if (!isInstanceIdPossible(resInstId) || !isDataValueValid(value)) {
        WPP_LOGW(TAG_WPP_RES, "Resource[%d], invalid data value or instance id is not possible", _id);
        return false;
    }
 
    if (isExist(resInstId)) {
        auto instIter = getInstIter(resInstId);
        instIter->data = value;
    } else {
        _instances.push_back({resInstId, value});
    }
 
    return true;
}
 
template<typename T>
bool Resource::set(T &&value, ID_T resInstId) {
    if(isSingle()) resInstId = SINGLE_INSTANCE_ID;
    if (!isInstanceIdPossible(resInstId) || !isDataValueValid(value)) {
        WPP_LOGW(TAG_WPP_RES, "Resource[%d], invalid data value or instance id is not possible", _id);
        return false;
    }
 
    if (isExist(resInstId)) {
        auto instIter = getInstIter(resInstId);
        instIter->data = std::move(value);
    } else {
        ResInst newInst = {resInstId, std::move(value)};
        _instances.push_back(std::move(newInst));
    }
 
    return true;
}
 
template<typename T>
const T& Resource::get(ID_T resInstId) {
    if(isSingle()) resInstId = SINGLE_INSTANCE_ID;
    if (!isDataTypeValid<T>() || !isExist(resInstId)) {
        WPP_LOGE(TAG_WPP_RES, "Resource[%d], invalid data type or instance does not exist", _id);
        // TODO: It is workaround for the case when resource is not found
        // This behavior is better than returning NULL, but it is not the best solution
        // Return empty value if the data type is not valid or the instance does not exist
        static T empty;
        return empty;
    }
 
    auto instIter = getInstIter(resInstId);
    return std::get<T>(instIter->data);
}
 
template<typename T>
bool Resource::add(const T &value) {
    if (isSingle()) {
        WPP_LOGW(TAG_WPP_RES, "Resource[%d] is SINGLE", _id);
        return false;
    }
    if (!isDataValueValid(value)) {
        WPP_LOGW(TAG_WPP_RES, "Resource[%d] invalid data value", _id);
        return false;
    }
 
    ID_T resInstId = newInstId();
    if (resInstId == ID_T_MAX_VAL) {
        WPP_LOGE(TAG_WPP_RES, "Resource[%d], no available instance ID", _id);
        return false;
    }
    _instances.push_back({resInstId, value});
    
    return true;
}
 
template<typename T>
bool Resource::add(T &&value) {
    if (isSingle()) {
        WPP_LOGW(TAG_WPP_RES, "Resource[%d] is SINGLE", _id);
        return false;
    }
    if (!isDataValueValid(value)) {
        WPP_LOGW(TAG_WPP_RES, "Resource[%d] invalid data value", _id);
        return false;
    }
 
    ID_T resInstId = newInstId();
    if (resInstId == ID_T_MAX_VAL) {
        WPP_LOGE(TAG_WPP_RES, "Resource[%d], no available instance ID", _id);
        return false;
    }
    ResInst newInst = {resInstId, std::move(value)};
    _instances.push_back(std::move(newInst));
    
    return true;
}
 
template<typename T>
bool Resource::isDataValueValid(const T &data) const {
    if (!isDataTypeValid<T>()) return false;
    if (!isDataVerifierValid(_dataVerifier)) return true;
 
    if constexpr (std::is_same<T, BOOL_T>::value) {
        return std::get<VERIFY_BOOL_T>(_dataVerifier)(data);
    } else if constexpr (std::is_same<T, INT_T>::value) {
        return std::get<VERIFY_INT_T>(_dataVerifier)(data);
    } else if constexpr (std::is_same<T, UINT_T>::value) {
        return std::get<VERIFY_UINT_T>(_dataVerifier)(data);
    } else if constexpr (std::is_same<T, FLOAT_T>::value) {
        return std::get<VERIFY_FLOAT_T>(_dataVerifier)(data);
    } else if constexpr (std::is_same<T, OPAQUE_T>::value) {
        return std::get<VERIFY_OPAQUE_T>(_dataVerifier)(data);
    } else if constexpr (std::is_same<T, OBJ_LINK_T>::value) {
        return std::get<VERIFY_OBJ_LINK_T>(_dataVerifier)(data);
    } else if constexpr (std::is_same<T, STRING_T>::value) {
        return std::get<VERIFY_STRING_T>(_dataVerifier)(data);
    } else if constexpr (std::is_same<T, EXECUTE_T>::value) {
        return std::get<VERIFY_EXECUTE_T>(_dataVerifier)(data);
    } else {
        return false;
    }
}
 
} // namespace wpp
 
#endif //WPP_RESOURCE_H