OnDemandCreator.hpp

#ifndef __FIBER_FIELD_ONDEMAND_CREATOR_HPP
#define __FIBER_FIELD_ONDEMAND_CREATOR_HPP
 
#include "CreativeArray.hpp"
#include "MemArrayProperties.hpp"
 
#if defined(__GNUC__) && defined(_GLIBCXX_USE_NOEXCEPT)
#define USE_NOEXCEPT _GLIBCXX_USE_NOEXCEPT
#else
#define USE_NOEXCEPT throw()
#endif
namespace Fiber
{
 
template <class Computer, Dims_t Rank = Computer::ResultArray_t::Dims,
          typename result_value_type = typename Computer::ResultArray_t::value_type>
class   OnDemandCreator : public CreativeArrayBase
{
        typedef typename Computer::ResultArray_t        ResultArray_t;
        typedef typename Computer::Constructor_t        Constructor_t;
 
        Constructor_t           MyConstructor;
        RefPtr<ResultArray_t>   MyData;
 
public:
        enum Dims_t
        {
                RANK = Rank
        };
 
        typedef result_value_type value_type;
 
        struct Exception : CreativeArrayBase::Exception
        {
                ~Exception() throw()
                {}
 
                const char* what() const USE_NOEXCEPT override
                {
                        return "Unspecified Fiber::OnDemandCreator Exception";
                }
        };
 
 
static  WeakPtr<FiberTypeBase> getFiberType()
        {
                return MemArrayAllocator<value_type>::getFiberType();
        }
 
        OnDemandCreator(const Constructor_t&myConstructor, const MemCore::RefPtr<MemCore::Cache>&theCache)
        : CreativeArrayBase(theCache)
        , MyConstructor(myConstructor)
        {
                addMetaInfo( RANK, getFiberType() );
        }
 
 
        Creature::ReasonForReleasal release() override
        {
                return releasePtr( MyData );
        }
 
        bool    hasData() const override
        {
                if (MyData)
                        return true;
                else
                        return false;
        }
 
        const std::type_info& getType() override
        {
                return typeid( value_type );
        }
 
        MemCore::CacheablePtr getCacheable() const override
        {
                return MyData;
        }
 
        RefPtr<MemBase> get() const override
        {
                return MyData;
        }
 
        RefPtr<MemBase> take() override
        {
        RefPtr<MemBase> result = MyData;
                MyData = MemCore::NullPtr();
                return result;
        }
 
        RefPtr<MemBase> produce() override
        {
                if (MyData)
                        return MyData;
 
        Computer MyComputer( MyConstructor, self() );
                MyData = MyComputer.result();
 
                if (MyData)
                {
                        MyData->setCreator( this->self() );
                        touch();
                }
 
                return MyData;
        }
 
};
 
} // namespace Fiber
 
#endif  // __FIBER_FIELD_ONDEMAND_CREATOR_HPP