ResourceContainer.h

Go to the documentation of this file.

#ifndef WPP_RESOURCE_CONTAINER_H
#define WPP_RESOURCE_CONTAINER_H
 
#include <vector>
 
#include "Resource.h"
#include "ItemOp.h"
#include "WppTypes.h"
#include "WppLogs.h"
 
namespace wpp {
 
class ResourceContainer {
public:
    ResourceContainer() = default;
    virtual ~ResourceContainer() = default;
 
    bool isSingle(ID_T resId);
 
    bool isMultiple(ID_T resId);
 
    bool isExist(ID_T resId);
 
    bool isExist(ID_T resId, ID_T resInstId);
 
    size_t instCount(ID_T resId);
 
    std::vector<ID_T> instIds(ID_T resId);
 
    ID_T newInstId(ID_T resId);
 
    template<typename T>
    bool set(ID_T resId, const T &value);
 
    template<typename T>
    bool set(ID_T resId, ID_T resInstId, const T &value);
 
    template<typename T>
    bool set(ID_T resId, T &&value);
 
    template<typename T>
    bool set(ID_T resId, ID_T resInstId, T &&value);
 
    template<typename T>
    const T& get(ID_T resId, ID_T resInstId = SINGLE_INSTANCE_ID);
 
    template<typename T>
    bool add(ID_T resId, const T &value);
 
    template<typename T>
    bool add(ID_T resId, T &&value);
 
    bool removeRes(ID_T resId, ID_T resInstId);
 
    bool clearRes(ID_T resId);
 
protected:
    void setupResources(const std::vector<Resource> &resources);
    void setupResources(std::vector<Resource> &&resources);
 
    Resource * resource(ID_T resId);
 
    std::vector<Resource> & resources();
 
    virtual void resourceOperationNotifier(ItemOp::TYPE type, ID_T resId, ID_T resInstId) = 0;
 
private:
    std::vector<Resource> _resources;
};
 
/* ---------- Implementation of template methods ----------*/
template<typename T>
bool ResourceContainer::set(ID_T resId, const T &value) {
    return set(resId, SINGLE_INSTANCE_ID, value);
}
 
template<typename T>
bool ResourceContainer::set(ID_T resId, ID_T resInstId, const T &value) {
    auto res = resource(resId);
    if (res == NULL) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] not found", resId);
        return false;
    }
    if (!res->set(value, resInstId)) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] operation failed", resId);
        return false;
    }
    resourceOperationNotifier(ItemOp::WRITE, resId, res->isSingle()? ID_T_MAX_VAL : resInstId);
    return true;
}
 
template<typename T>
bool ResourceContainer::set(ID_T resId, T &&value) {
    return set(resId, SINGLE_INSTANCE_ID, std::move(value));
}
 
template<typename T>
bool ResourceContainer::set(ID_T resId, ID_T resInstId, T &&value) {
    auto res = resource(resId);
    if (res == NULL) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] not found", resId);
        return false;
    }
    if (!res->set(std::move(value), resInstId)) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] operation failed", resId);
        return false;
    }
    resourceOperationNotifier(ItemOp::WRITE, resId, res->isSingle()? ID_T_MAX_VAL : resInstId);
    return true;
}
 
template<typename T>
const T& ResourceContainer::get(ID_T resId, ID_T resInstId) {
    auto res = resource(resId);
    if (res == NULL) {
        WPP_LOGE(TAG_WPP_RES, "Resource[%d] does not exist", resId);
        // 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;
    }
    return res->get<T>(resInstId);
}
 
template<typename T>
bool ResourceContainer::add(ID_T resId, const T &value) {
    auto res = resource(resId);
    if (res == NULL) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] not found", resId);
        return false;
    }
    if (res->isSingle()) {
        WPP_LOGE(TAG_WPP_RES_CON, "Resource[%d] is SINGLE", resId);
        return false;
    }
 
    ID_T newId = res->newInstId();
    if (newId == ID_T_MAX_VAL) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] new instance ID not found", resId);
        return false;
    }
    if (!res->set(value, newId)) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] operation failed", resId);
        return false;
    }
    resourceOperationNotifier(ItemOp::WRITE, resId, newId);
    return true;
}
 
template<typename T>
bool ResourceContainer::add(ID_T resId, T &&value) {
    auto res = resource(resId);
    if (res == NULL) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] not found", resId);
        return false;
    }
    if (res->isSingle()) {
        WPP_LOGE(TAG_WPP_RES_CON, "Resource[%d] is SINGLE", resId);
        return false;
    }
 
    ID_T newId = res->newInstId();
    if (newId == ID_T_MAX_VAL) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] new instance ID not found", resId);
        return false;
    }
    WPP_LOGD(TAG_WPP_RES_CON, "Resource[%d] new instance ID: %d", resId, newId);
    if (!res->set(std::move(value), newId)) {
        WPP_LOGW(TAG_WPP_RES_CON, "Resource[%d] operation failed", resId);
        return false;
    }
    resourceOperationNotifier(ItemOp::WRITE, resId, newId);
    return true;
}
 
} /* namespace wpp */
 
#endif // WPP_RESOURCE_CONTAINER_H