FieldFunctor.hpp

#ifndef __FISH_BONE_FIELDFUNCTOR_HPP
#define __FISH_BONE_FIELDFUNCTOR_HPP

#include <bone/FieldOperatorObject.hpp>

namespace Wizt
{
using namespace Fiber;
using namespace Eagle;

template <class Operation>
class   FieldFunctor : public FieldOperatorObject
{
protected:

        bool doCreateArrayIfRequired;

public:
        typedef typename Operation::input_type  input_type;
        typedef typename Operation::output_type output_type; 

        VOutput<Fiber::Field>   Result;

        FieldFunctor(const string&name, int p, const RefPtr<VCreationPreferences>&VP)
        : VObject(name, p, VP)
        , Fish<VObject>(this)
        , Fish<Field>("inputfield")
        , FieldOperatorObject(name, "inputfield", p, VP)
        , doCreateArrayIfRequired(true)
        , Result( self(), "result" )
        {
                acceptType<input_type>();
        }

        struct Op : Field::Iterator, Operation
        {
                RefPtr<Field>   ResultField;
                bool            Modified;
                bool            doCreateArrayIfRequired;
                const FieldFunctor&theFieldFunctor;
                VRequest          &theContext;

                Op(const FieldFunctor&F, VRequest&Context)
                : Modified(false)
                , theFieldFunctor(F)
                , theContext(Context)
                {}

                override bool apply(const RefPtr<FragmentID>&frag, const RefPtr<CreativeArrayBase>&CAB)
                {
                        if (ResultField)
                        {
                                if (RefPtr<CreativeArrayBase> ResultCreator = ResultField->getCreator( frag ) )
                                {
                                        if (CAB->isNewerThan(*ResultCreator) )
                                        {
//                                      puts("INPUT is NEWER");
                                        }
                                        else
                                        {
//                                      puts("INPUT is OLDER"); 
                                        return true;
                                        }
                                } 
                        } 

                        // 
                        // TODO: Move this into an OnDemandCreator 
                        //

                const RefPtr<MemBase>&Data = CAB->create();
                        if (!Data)
                        {
                                puts("FieldFunctor: DATA CREATION FAILED!"); fflush(stdout); 
                                return false;
                        }

                TypedIterator<input_type> T = Data; 
                        if (!T)
                        {
                                T = Data->makeMemArray( NullPtr() ); 
                                if (!T)
                                {

                                FieldSelector   FieldSelection; 
                                        theFieldFunctor.MyField << theContext >> FieldSelection; 
                                        puts("FieldFunctor: OUCCCH - Some data here, but no fitting data!"); fflush(stdout); 
                                        VActionNotifier::Warning("FieldFunctor \"" + theFieldFunctor.Name() + "\" :\n\n"
                                                                 "Need data of type '" + Typename(typeid(input_type)) +
                                                                 "', but input data are of type '" +
                                                                 Typename(Data->getType() ) +
                                                                 //"' (elements of type '" + Typename(Data->getFiberType().getType() ) + "'"
                                                                 ").\n\n"
                                                                 "Maybe a wrong input field was connected here. "
                                                                 "The currently connected input field is \""
                                                                 + FieldSelection() + "\" - check whether this is correct."
                                                                );
                                        return false;
                                }
                        } 

                const Iterator<input_type>&Src = *T; 

                RefPtr<TypedArray<output_type> >
                        Result = TypedArray<output_type>::create( T() ); 

                const Iterator<output_type>&Dst = *Result ->creativeIterator() ; 

                index_t end = Src.count(); 
                        for(index_t i = 0; i<end; i++)
                        {
                                Dst[i] = compute( Src[i] );
                        } 

                        Result ->CacheInfoString = "Computed field."; 
                        if (!ResultField)
                                ResultField = new Field();
                        ResultField->setDiscardableData( Result , Cache::MemCache(), frag); 
                        ResultField->touch();
                        Modified = true;
                        return true;
                }
        };


static string createChildname(const string&parent_name)
        {
                return Operation::createChildname( parent_name );
        }

        virtual bool modifyOperator(VRequest&Context, Operation&Op) const
        {
                return true;
        }

        virtual bool postOperation(VRequest&Context, Op&Result) const
        {
                return true;
        }

        override bool FieldOperation(VRequest&Context, Fiber::Field&Source,
                                     Fiber::Representation&Target, Fiber::Representation&FieldIDSource)
        {
//      puts("FieldFunctor::FieldOperation(VRequest&Context, Fiber::Field&Source)");

        Op      MyOp(*this, Context);
                MyOp.doCreateArrayIfRequired = doCreateArrayIfRequired;
                if (!modifyOperator(Context, MyOp) )
                {
                        return false;
                }

                Source.iterate( MyOp ); 

                if (!postOperation(Context, MyOp) )
                {
                        return false;
                }

                if (MyOp.ResultField)
                {
                string  ResultFieldname = createChildname( Fieldname(Context) ); 

                RefPtr<FieldID> ResultID = Target.createSharedFieldID( FieldIDSource, ResultFieldname );
                        assert( ResultID );

                        Target[ ResultID ] = MyOp.ResultField; 
                        assert( Target.getField( ResultID ) );

                FieldSelector InputField;
                        MyField << Context >> InputField; 
//                      printf("FIELDFUNCTOR got data at T=%lg\n", F.getTime() );

//                      if (MyOp.Modified) puts("ResultField.modified"); else  puts("NOT ResultField.modified"); 

                FieldSelector OutField( InputField );
                        OutField.selectField( ResultFieldname );
                        OutField.accept<output_type>();

                FieldSelector PreviousOutField;
                        Result << Context >> PreviousOutField;

                        if (MyOp.Modified || OutField != PreviousOutField)
                        {
//                              puts("SET NEW Field");
                                Result << Context << OutField;
                                setStatusInfo(Context, "Created field ["+ResultFieldname+"]");
                        }
                        else
                                setStatusInfo(Context, "Used old field ["+ResultFieldname+"]"); 
//                              puts("OLD Field is fine");
                } 
                else
                        setStatusError(Context, "Invalid input type of input field");

//              return setStatusInfo(Context, "Created field ["+ResultFieldname+"]");
                return true;
        }
};


} // namespace

#endif