ResourceContainer.hpp

Go to the documentation of this file.

// <ResourceContainer> -*- C++ -*-
 
#pragma once
 
#include "sparta/kernel/PhasedObject.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
namespace sparta
{
    class Resource;
    class PostRunValidationInfo;
    class Clock;
 
    class ResourceContainer : public PhasedObject
    {
    public:
 
        friend class Resource;
 
        ResourceContainer() :
            resource_(nullptr),
            resource_locked_(false),
            num_resource_gets_(0)
        { }
 
        ResourceContainer(const ResourceContainer&) = delete;
 
        ResourceContainer(ResourceContainer&&) = default;
 
        virtual ~ResourceContainer()
        { }
 
        Resource* getResource() {
            if(isFinalized() == false
               && isFinalizing() == false
               && isTearingDown() == false){
                throw SpartaException("Cannot call getResource on TreeNode ")
                    << getLocation() << " because it is not finalizing, finalized, or tearing down";
            }
            if(nullptr == resource_){
                SpartaException ex("Cannot call getResource on TreeNode: ");
                ex << getLocation() << " which does not have a resource.";
                if(isFinalized()){
                    ex << " TreeNode is finalized, so it cannot possibly have a resource";
                }else if(isFinalizing()){
                    ex << " TreeNode is finalizing, and might not have created its' resource yet."
                       << " If this TreeNode is expected to have a resource, it just hasn't been finalized yet."
                       << " If this is a DynamicResourceTreeNode, explicitly invoke finalize() on it to"
                       << " immediately create the resource";
                }
                throw ex;
            }
            return getResource_();
        }
 
        const Resource* getResource() const {
            if(isFinalized() == false
               && isFinalizing() == false
               && isTearingDown() == false){
                throw SpartaException("Cannot call getResource on TreeNode ")
                    << getLocation() << " because it is not finalizing, finalized, or tearing down";
            }
            if(nullptr == resource_){
                throw SpartaException("Cannot call getResource on TreeNode: ")
                    << getLocation() << " which does not have a resource";
            }
            return getResource_();
        }
 
        bool hasResource() const {
            if(isFinalized() == false
               && isFinalizing() == false
               && isTearingDown() == false){
                throw SpartaException("Cannot call hasResource on TreeNode ")
                    << getLocation() << " because it is not finalizing, finalized, or tearing down";
            }
            return getResource_() != nullptr;
        }
 
        template <class T, typename = typename std::enable_if<std::is_pointer<T>::value>::type>
        const T getResourceAs() const {
            if(isFinalized() == false
               && isFinalizing() == false
               && isTearingDown() == false){
                throw SpartaException("Cannot call getResource on TreeNode ")
                    << getLocation() << " because it is not finalizing, finalized, or tearing down";
            }
            if(nullptr == resource_){
                throw SpartaException("Could not get Resource from TreeNode ")
                    << getLocation() << " because it was null. Exepcted type: " << demangle(typeid(T).name());
            }
            const T r = dynamic_cast<T>(resource_);
            if(nullptr == r){
                throw SpartaException("Could not get Resource from TreeNode ")
                    << getLocation() << " because it (" << getResourceTypeName_() << ") could not be cast to type: " << demangle(typeid(T).name());
            }
            return r;
        }
 
        template <class T, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
        const T* getResourceAs() const {
            return getResourceAs<T*>();
        }
 
        template <class T, typename = typename std::enable_if<std::is_pointer<T>::value>::type>
        T getResourceAs() {
            if(isFinalized() == false
               && isFinalizing() == false
               && isTearingDown() == false){
                throw SpartaException("Cannot call getResource on TreeNode ")
                    << getLocation() << " because it is not finalizing, finalized, or tearing down";
            }
            if(nullptr == resource_){
                throw SpartaException("Could not get Resource from ResourceTreeNode \"")
                    << getLocation() << "\" because it was null. Exepcted type: " << demangle(typeid(T).name());
            }
            T r = dynamic_cast<T>(resource_);
            if(nullptr == r){
                throw SpartaException("Could not get Resource from ResourceTreeNode \"")
                    << getLocation() << "\" because it (" << getResourceTypeName_() << ") could not be cast to type: " << demangle(typeid(T).name());
            }
            return r;
        }
 
        template <class T, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
        T* getResourceAs() {
            return getResourceAs<T*>();
        }
 
        virtual std::string getResourceType() const;
 
        virtual std::string getResourceTypeRaw() const;
 
        virtual const Clock* getClock() = 0;
 
    protected:
 
        std::string getResourceTypeName_() const;
 
        void setResource_(Resource* r) {
            if(resource_locked_){
                THROW_IF_NOT_UNWINDING(SpartaException,
                                       "Resource pointer on " << getLocation()
                                        << " has been locked. It cannot be set");
            }
            if(resource_ != nullptr){
                THROW_IF_NOT_UNWINDING(SpartaException,
                                       "Resource pointer on " << getLocation()
                                       << " has already been set. It cannot be replaced. ");
            }
            if(r == nullptr){
                THROW_IF_NOT_UNWINDING(SpartaException,
                                       "Resource pointer on " << getLocation()
                                       << " cannot be assigned to nullptr. ");
            }
 
            resource_ = r;
        }
 
        void unsetResource_() {
            if(resource_locked_ && false == isTearingDown()){
                THROW_IF_NOT_UNWINDING(SpartaException,
                                       "Resource pointer on " << getLocation()
                                       << " has been locked. It cannot be unset until teardown");
            }
            resource_ = nullptr;
        }
 
        void lockResource_() {
            resource_locked_ = true;
        }
 
        Resource* getResource_() noexcept {
            ++num_resource_gets_;
            return resource_;
        }
 
        const Resource* getResource_() const noexcept {
            ++num_resource_gets_;
            return resource_;
        }
 
    private:
 
        Resource* resource_;
 
        bool resource_locked_;
 
 
 
        mutable uint32_t num_resource_gets_;
 
    };
 
} // namespace sparta