ResourceFactory.hpp

// <ResourceFactory> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include <string>
#include <ostream>
#include <stdexcept>
#include <vector>
#include <memory>
#include <map>
 
#include "sparta/simulation/Resource.hpp"
#include "sparta/simulation/ParameterSet.hpp"
#include "sparta/utils/Utils.hpp"
 
 
namespace sparta
{
 
    class ResourceTreeNode;
 
    class ResourceFactoryBase
    {
    public:
 
        virtual ~ResourceFactoryBase() {}
 
        virtual std::string getResourceType() const = 0;
 
        virtual std::string getResourceTypeRaw() const = 0;
 
        virtual ParameterSet* createParameters(TreeNode* node) = 0;
 
        virtual void deleteParameters(ParameterSet* params) = 0;
 
        virtual void createSubtree(sparta::ResourceTreeNode* n) = 0;
 
        virtual void deleteSubtree(sparta::ResourceTreeNode* n) = 0;
 
        virtual void onBuilding(sparta::ResourceTreeNode* n) = 0;
 
        virtual void onConfiguring(sparta::ResourceTreeNode* n) = 0;
 
        virtual Resource* createResource(TreeNode* node,
                                         const ParameterSet* params) = 0;
 
        virtual void deleteResource(Resource* res) = 0;
 
        virtual void bindEarly(TreeNode* node) = 0;
 
        virtual void bindLate(TreeNode* node) = 0;
    };
 
    GENERATE_HAS_ATTR(name)
    GENERATE_HAS_ATTR(ParameterSet)
 
    
    template<typename ResourceT, typename ParamsT=typename ResourceT::ParameterSet>
    class ResourceFactory : public ResourceFactoryBase
    {
    public:
 
        typedef ResourceT resource_type;
        typedef ParamsT params_type;
 
        ResourceFactory(const ResourceFactory& rhp) = delete;
        ResourceFactory& operator=(const ResourceFactory& rhp) = delete;
 
        ResourceFactory() {
            // ParamsT must be a subclass of sparta::ParameterSet.
            // This check will fail if ParamsT is not a subclass of
            // sparta::ParameterSet.
            sparta::ParameterSet* rps = (ParamsT*)0;
            (void) rps;
        };
        ~ResourceFactory() {};
 
        virtual std::string getResourceType() const override {
            return getResourceType_<ResourceT>();
        }
 
        virtual std::string getResourceTypeRaw() const override {
            return typeid(ResourceT).name();
        }
 
        virtual ParameterSet* createParameters(TreeNode* node) override  {
            sparta_assert(node);
            return new ParamsT(node);
        }
 
        virtual void deleteParameters(ParameterSet* params) override {
            sparta_assert(params, "It is invalid to call deleteParameters with null params");
            delete params;
        }
 
        // This can easily be overridden to add a subtree
        virtual void createSubtree(sparta::ResourceTreeNode* n) override {
            (void) n;
        }
 
        virtual void deleteSubtree(sparta::ResourceTreeNode* n) override {
            (void) n;
        }
 
        // This can easily be overridden for additional building or configuring
        virtual void onBuilding(sparta::ResourceTreeNode* n) override {
            (void) n;
        }
 
        virtual void onConfiguring(sparta::ResourceTreeNode* n) override {
            (void) n;
        }
 
        Resource* createResource(TreeNode* node,
                                 const ParameterSet* params) override  {
            // Cast Parameters to expected type
            ParamsT const * sps; // specific parameter set
            sps = dynamic_cast<ParamsT const *>(params);
            if(nullptr == sps){ // Specific parameter set must have casted correctly
                throw SpartaException("Failed to cast ParameterSet ")
                    << params << " to type " << typeid(ParamsT).name()
                    << " when constructing resource for node " << node->getLocation();
            }
 
            return new ResourceT(node, sps); // Construct the new resource
        }
 
        void deleteResource(Resource* res) override final {
            sparta_assert(res, "It is invalid to call deleteResource with a null resource");
            delete res;
        }
 
        void bindEarly(TreeNode*) override {;}
 
        void bindLate(TreeNode*) override {;}
 
    private:
 
        template <typename RT>
        typename std::enable_if<has_attr_name<RT>::value, std::string>::type
        getResourceType_() const {
            return ResourceT::name;
        }
 
        template <typename RT>
        typename std::enable_if<!has_attr_name<RT>::value, std::string>::type
        getResourceType_() const {
            // Generate a friendly verbose error
            static_assert(has_attr_name<RT>::value, "When instantiating a subclass of sparta::ResourceFactory, "
                          "template argument ResourceT is not a complete sparta::Resource subclass: ResourceT type "
                          "template argument to sparta::ResourceFactory must have a public static \"name\" member "
                          "which is a std::string or const char* that contains an alphanumeric name representing "
                          "this Resource.");
            return "";
        }
 
    };
 
    class ResourceSet
    {
    public:
        // Typedef for the internal map type
        typedef std::map<std::string, std::unique_ptr<sparta::ResourceFactoryBase>> ResourceFactoryMap;
 
        template <typename ResourceFactoryT>
        void addResourceFactory() {
            std::unique_ptr<sparta::ResourceFactoryBase> fact(new ResourceFactoryT());
            sparta_assert(fact != nullptr);
            std::string name = fact->getResourceType();
            auto itr = factories_.find(name);
            if(itr != factories_.end()){
                throw sparta::SpartaException("Cannot reregister ResourceFactory named \"")
                    << name << "\" because there is already a resource registered by that name";
            }
            factories_[name] = std::move(fact);
            max_res_name_len_ = std::max<uint32_t>(max_res_name_len_, name.size());
        }
 
        sparta::ResourceFactoryBase* getResourceFactory(const std::string& name);
 
        bool hasResource(const std::string& name) const noexcept;
 
        std::string renderResources(bool one_per_line=true);
 
        ResourceFactoryMap::const_iterator begin() const {
            return factories_.begin();
        }
 
        ResourceFactoryMap::const_iterator end() const {
            return factories_.end();
        }
 
    private:
 
        std::map<std::string, std::unique_ptr<sparta::ResourceFactoryBase>> factories_;
        uint32_t max_res_name_len_ = 0; 
    };
 
} // namespace sparta
 
// __RESOURCE_FACTORY__