UnaryFieldOperatorObject.hpp

#ifndef __FISH_UNARYFIELDOPERATOROBJECT_HPP
#define __FISH_UNARYFIELDOPERATOROBJECT_HPP
 
#include "FieldOperatorObject.hpp"
#include <field/UnaryOperator.hpp>
 
namespace Wizt
{
 
  template <class TheUnaryOperator,
            class ResultType = typename TheUnaryOperator::InputType>
struct  UnaryFieldOperatorObject : FieldOperatorObject, TheUnaryOperator
{
        using   GridInspector = Fiber::GridInspector<Fiber::BundleProperty::Anything>;
 
        using   InputTypes    = typename TheUnaryOperator::InputType;
 
        VOutput<Fiber::Field>   ResultField;
 
        UnaryFieldOperatorObject(const string&name, int p = 0, const RefPtr<VCreationPreferences>&VP = NullPtr() )
        : FieldOperatorObject(name, "inputfield", p, VP)
        , ResultField(self(), "result")
        {}
 
        bool    postFieldOperation(VRequest&Context, int NFields) override
        {
        FieldSelector   FieldSelection;
                if (NFields>0)
                {
                string  NewFieldname = TheUnaryOperator::ResultFieldname( Fieldname(Context) );
                        MyField << Context >> FieldSelection;
 
                FieldSelector   OutputFieldSelection( FieldSelection);
                        OutputFieldSelection.selectTypedField<ResultType>( NewFieldname );
 
                        ResultField << Context << OutputFieldSelection;
                }
                else
                {
                        ResultField << Context << FieldSelection;
                }
                return true;
        }
 
        bool    FieldOperation(VRequest&Context, Fiber::Field&InputField,
                               Fiber::Representation&FieldRep//, Fiber::Representation&FieldIDSource
                ) override
        {
        Fiber::Representation&FieldIDSource = FieldRep;
        string  NewFieldname = TheUnaryOperator::ResultFieldname( Fieldname(Context) );
 
        Fiber::UnaryOperator<TheUnaryOperator,
                        typename TheUnaryOperator::InputType,
                        ResultType> MyOp;
 
        RefPtr<Fiber::FieldID> NewFieldID = FieldRep.createSharedFieldID(FieldIDSource, NewFieldname);
        auto    hasResultField = FieldRep( NewFieldID );
                // check timing and parameters, possibly
                if (!hasResultField or InputField.isNewerThan(*hasResultField) )
                {
                        if (RefPtr<Fiber::Field> ResultField = newComputationalField( MyOp, InputField) )
                        {
                                FieldRep[ NewFieldID] = ResultField;
                        }
                }
 
                return true;
        }
 
static string   createChildname(const string&parent_name)
        {
                return  TheUnaryOperator::ResultObjectname( parent_name );
        }
};
 
}
 
#endif // __FISH_UNARYFIELDOPERATOROBJECT_HPP