OnDemandCreator.hpp

#ifndef __FIBER_FIELD_ONDEMAND_CREATOR_HPP
#define __FIBER_FIELD_ONDEMAND_CREATOR_HPP

#include "CreativeArray.hpp"
#include "MemArrayProperties.hpp"

namespace Fiber
{

template <class Computer>
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
        {
                RANK = ResultArray_t::Dims
        };

        typedef typename ResultArray_t::value_type value_type;

static  const FiberTypeBase&getFiberType()
        {
                return MemArrayAllocator<value_type>::getFiberType();
        }

        OnDemandCreator(const Constructor_t&myConstructor, const MemCore::RefPtr<MemCore::Cache>&theCache)
        : CreativeArrayBase(theCache)
        , MyConstructor(myConstructor)
        {
                addInterface( new MemArrayProperties(RANK, getFiberType() )); 
        }

        override bool release()
        {
                MyData = ::MemCore::NullPtr();
                return true;
        }

        override bool hasData() const
        {
                if (MyData)
                        return true; 
                else
                        return false;
        }

        override const std::type_info& getType()
        {
                return typeid( typename ResultArray_t::value_type );
        }

        override RefPtr<MemBase> get() const
        {
                return MyData; 
        }

        override RefPtr<MemBase> create()
        {
                if (MyData)
                        return MyData; 

        Computer MyComputer( MyConstructor, self() ); 
                MyData = MyComputer.result(); 
                return MyData;
        }

};

} // namespace Fiber

#endif  // __FIBER_FIELD_ONDEMAND_CREATOR_HPP