ResourceList.h

Go to the documentation of this file.

 
#ifndef INCLUDE_HUEPLUSPLUS_RESOURCE_LIST_H
#define INCLUDE_HUEPLUSPLUS_RESOURCE_LIST_H
 
#include <functional>
#include <map>
#include <string>
#include <vector>
 
#include "APICache.h"
#include "HueException.h"
#include "NewDeviceList.h"
#include "Utils.h"
 
namespace hueplusplus
{
template <typename Resource, typename IdT>
class ResourceList
{
public:
    using ResourceType = Resource;
    using IdType = IdT;
    static_assert(std::is_integral<IdType>::value || std::is_same<std::string, IdType>::value,
        "IdType must be integral or string");
 
    ResourceList(std::shared_ptr<APICache> baseCache, const std::string& cacheEntry,
        std::chrono::steady_clock::duration refreshDuration, bool sharedState = false,
        const std::function<Resource(IdType, const nlohmann::json&, const std::shared_ptr<APICache>&)>& factory
        = nullptr)
        : stateCache(std::make_shared<APICache>(baseCache, cacheEntry, refreshDuration)),
          factory(factory),
          path(stateCache->getRequestPath() + '/'),
          sharedState(sharedState)
    { }
    ResourceList(const HueCommandAPI& commands, const std::string& path,
        std::chrono::steady_clock::duration refreshDuration,
        const std::function<Resource(IdType, const nlohmann::json&, const std::shared_ptr<APICache>&)>& factory
        = nullptr)
        : stateCache(std::make_shared<APICache>(path, commands, refreshDuration, nullptr)),
          factory(factory),
          path(path + '/'),
          sharedState(false)
    { }
 
    ResourceList(const ResourceList&) = delete;
    ResourceList& operator=(const ResourceList&) = delete;
 
    void refresh() { stateCache->refresh(); }
 
    void setRefreshDuration(std::chrono::steady_clock::duration refreshDuration)
    {
        stateCache->setRefreshDuration(refreshDuration);
    }
 
    std::vector<Resource> getAll()
    {
        nlohmann::json& state = stateCache->getValue();
        std::vector<Resource> result;
        result.reserve(state.size());
        for (auto it = state.begin(); it != state.end(); ++it)
        {
            result.emplace_back(construct(maybeStoi(it.key()), it.value()));
        }
        return result;
    }
 
    Resource get(const IdType& id)
    {
        const nlohmann::json& state = stateCache->getValue();
        std::string key = maybeToString(id);
        if (!state.count(key))
        {
            throw HueException(FileInfo {__FILE__, __LINE__, __func__}, "Resource id is not valid");
        }
        return construct(id, state[key]);
    }
 
    bool exists(const IdType& id) { return stateCache->getValue().count(maybeToString(id)) != 0; }
 
    bool exists(const IdType& id) const { return stateCache->getValue().count(maybeToString(id)) != 0; }
 
    bool remove(const IdType& id)
    {
        std::string requestPath = path + maybeToString(id);
        nlohmann::json result = stateCache->getCommandAPI().DELETERequest(
            requestPath, nlohmann::json::object(), FileInfo {__FILE__, __LINE__, __func__});
        bool success = utils::safeGetMember(result, 0, "success") == requestPath + " deleted";
        return success;
    }
 
protected:
    static IdType maybeStoi(const std::string& key) { return maybeStoi(key, std::is_integral<IdType> {}); }
 
    static std::string maybeToString(const IdType& id) { return maybeToString(id, std::is_integral<IdType> {}); }
 
    Resource construct(const IdType& id, const nlohmann::json& state)
    {
        return construct(id, state,
            std::is_constructible<Resource, IdType, HueCommandAPI, std::chrono::steady_clock::duration,
                const nlohmann::json&> {});
    }
 
    ResourceList(ResourceList&&) = default;
    ResourceList& operator=(ResourceList&&) = default;
 
private:
    // Resource is constructible
    Resource construct(const IdType& id, const nlohmann::json& state, std::true_type)
    {
        if (factory)
        {
            return factory(id, state, sharedState ? stateCache : std::shared_ptr<APICache>());
        }
        else
        {
            if (sharedState)
            {
                return Resource(id, stateCache);
            }
            else
            {
                return Resource(id, stateCache->getCommandAPI(), stateCache->getRefreshDuration(), state);
            }
        }
    }
    // Resource is not constructible
    Resource construct(const IdType& id, const nlohmann::json& state, std::false_type)
    {
        if (!factory)
        {
            throw HueException(FileInfo {__FILE__, __LINE__, __func__},
                "Resource is not constructable with default parameters, but no factory given");
        }
        return factory(id, state, sharedState ? stateCache : std::shared_ptr<APICache>());
    }
 
private:
    static IdType maybeStoi(const std::string& key, std::true_type) { return std::stoi(key); }
    static IdType maybeStoi(const std::string& key, std::false_type) { return key; }
    static std::string maybeToString(IdType id, std::true_type) { return std::to_string(id); }
    static std::string maybeToString(const IdType& id, std::false_type) { return id; }
 
protected:
    std::shared_ptr<APICache> stateCache;
    std::function<Resource(IdType, const nlohmann::json&, const std::shared_ptr<APICache>&)> factory;
    std::string path;
    bool sharedState;
};
 
template <typename Resource>
class SearchableResourceList : public ResourceList<Resource, int>
{
public:
    using ResourceList<Resource, int>::ResourceList;
 
    void search(const std::vector<std::string>& deviceIds = {})
    {
        std::string requestPath = this->path;
        // Remove trailing slash
        requestPath.pop_back();
        if (deviceIds.empty())
        {
            this->stateCache->getCommandAPI().POSTRequest(
                requestPath, nlohmann::json::object(), FileInfo {__FILE__, __LINE__, __func__});
        }
        else
        {
            this->stateCache->getCommandAPI().POSTRequest(
                requestPath, nlohmann::json {{"deviceid", deviceIds}}, FileInfo {__FILE__, __LINE__, __func__});
        }
    }
 
    NewDeviceList getNewDevices() const
    {
        nlohmann::json response = this->stateCache->getCommandAPI().GETRequest(
            this->path + "new", nlohmann::json::object(), FileInfo {__FILE__, __LINE__, __func__});
        return NewDeviceList::parse(response);
    }
 
protected:
    SearchableResourceList(SearchableResourceList&&) = default;
    SearchableResourceList& operator=(SearchableResourceList&&) = default;
};
 
template <typename BaseResourceList, typename CreateType>
class CreateableResourceList : public BaseResourceList
{
public:
    using BaseResourceList::BaseResourceList;
 
    typename BaseResourceList::IdType create(const CreateType& params)
    {
        std::string requestPath = this->path;
        // Remove slash
        requestPath.pop_back();
        nlohmann::json response = this->stateCache->getCommandAPI().POSTRequest(
            requestPath, params.getRequest(), FileInfo {__FILE__, __LINE__, __func__});
        nlohmann::json id = utils::safeGetMember(response, 0, "success", "id");
        if (id.is_string())
        {
            std::string idStr = id.get<std::string>();
            if (idStr.find(this->path) == 0)
            {
                idStr.erase(0, this->path.size());
            }
            this->stateCache->refresh();
            return this->maybeStoi(idStr);
        }
        return typename BaseResourceList::IdType {};
    }
 
protected:
    CreateableResourceList(CreateableResourceList&&) = default;
    CreateableResourceList& operator=(CreateableResourceList&&) = default;
};
 
template <typename Resource, typename CreateType>
class GroupResourceList : public CreateableResourceList<ResourceList<Resource, int>, CreateType>
{
    using Base = CreateableResourceList<ResourceList<Resource, int>, CreateType>;
 
public:
    using Base::Base;
    Resource get(const int& id)
    {
        const nlohmann::json& state = this->stateCache->getValue();
        std::string key = this->maybeToString(id);
        if (!state.count(key) && id != 0)
        {
            throw HueException(FileInfo {__FILE__, __LINE__, __func__}, "Resource id is not valid");
        }
        return this->construct(id, id == 0 ? nlohmann::json {nullptr} : state[key]);
    }
    bool exists(int id) const { return id == 0 || Base::exists(id); }
 
protected:
    GroupResourceList(GroupResourceList&&) = default;
    GroupResourceList& operator=(GroupResourceList&&) = default;
};
} // namespace hueplusplus
 
#endif