FragmentCreator.hpp

#ifndef __FIBER_FIELD_FRAGMENTCREATOR_HPP
#define __FIBER_FIELD_FRAGMENTCREATOR_HPP
 
#include "OnDemandCreator.hpp"
#include "Field.hpp"
 
 
namespace Fiber
{
 
 
template <class FragmentOperator>
struct  SingleFragmentCompute : FragmentOperator
{
        enum { DataDims = FragmentOperator::DataDims };
 
        typedef typename FragmentOperator::InputType InputType;
        typedef typename FragmentOperator::OutputType OutputType;
 
 
        typedef MemArray<DataDims, OutputType>     ResultArray_t;
 
        struct  MyConstructor : FragmentOperator
        {
                RefPtr<CreativeArrayBase>  myInputDataCreator;
 
                MyConstructor(FragmentOperator&Op,
                              const RefPtr<FragmentID>     &fid,
                              const RefPtr<CreativeArrayBase>&theInputDataCreator)
                : FragmentOperator(Op)
                , myInputDataCreator( theInputDataCreator )
                {
                        Op.setupFragment(fid);
                }
        };
 
 
        typedef MyConstructor Constructor_t;
 
        RefPtr<ResultArray_t>        result_storage;
 
        SingleFragmentCompute(Constructor_t&C, const RefPtr<CreativeArrayBase>&OutFragmentCreator)
        {
        RefPtr<MemArray<DataDims, InputType> > InputData = C.myInputDataCreator->create(); 
 
        RefPtr<ResultArray_t>        
                result = new ResultArray_t(InputData->Size() ); 
 
                if (C.compute(*result, *InputData))
                        result_storage = result;
        }
 
        RefPtr<ResultArray_t> result() const
        {
                return result_storage;
        }
};
 
 
 
template <class FragmentOperator>
void    SetupNewFragmentCreators(const RefPtr<Field>&Output, const RefPtr<Field>&Input, FragmentOperator&Op)
{
        struct  It : Field::Iterator, FragmentOperator
        {
                RefPtr<Field> Output;
 
                typedef SingleFragmentCompute<FragmentOperator> MyCompute;
 
                It(FragmentOperator&Op)
                :FragmentOperator(Op)
                {}
 
                bool    apply(const RefPtr<FragmentID>&fid, const RefPtr<CreativeArrayBase>&CAB) override
                {
                RefPtr<CreativeArrayBase>
                        NewFragment = new OnDemandCreator<MyCompute>( typename MyCompute::MyConstructor(*this,fid,CAB), MemCore::Cache::MemCache() );
 
                        Output->setCreator(NewFragment, fid);
                        return true;
                }
 
        } 
        Fit (Op);
 
        Fit.Output = Output;
        Input->iterate(Fit);
 
}
 
 
} // namespace
 
 
#endif