BinaryFieldOperatorObject.hpp

#ifndef __FISH_BINARYOPERATOROBJECT_HPP
#define __FISH_BINARYOPERATOROBJECT_HPP
 
#include "FieldOperatorObject.hpp"
#include <baseop/EvalGrid.hpp>
 
#include <fish/fiber/field/BinaryOperator.hpp>
 
namespace Wizt
{
 
        using Fiber::Field;
 
 
template <class TheBinaryOperator,
          class NamingOperator,
          class PrimaryValueType,
          class SecondaryValueType = PrimaryValueType,
          class ResultValueType    = PrimaryValueType>
 
struct  BinaryFieldOperatorObject : FieldOperatorObject
{
        typedef PrimaryValueType        value_type;
        typedef ResultValueType         result_t;
 
        typedef META::LIST<value_type>                  InputTypes;
 
        typedef Fiber::GridInspector<Fiber::BundleProperty::Anything> GridInspector;
 
        TypedSlot<Field>        SecondaryField;
 
        VOutput<Field>          ResultField;
 
        BinaryFieldOperatorObject(const string&name, int p = 0, const RefPtr<VCreationPreferences>&VP = NullPtr() )
        : FieldOperatorObject(name, "leftField", p, VP)
        , SecondaryField(this, "right")
        , ResultField(self(), "result")
        {}
 
        ~BinaryFieldOperatorObject() noexcept
        {}
 
        bool FieldOperation(VRequest&Context, Fiber::Field&InputField,
                            Fiber::Representation&FieldRep//, Fiber::Representation&FieldIDSource
                        ) override
        {
        using   namespace Fiber;
        Fiber::Representation&FieldIDSource = FieldRep;
 
        FieldSelector PrimaryFS;
                MyField << Context >> PrimaryFS;
 
        RefPtr<Grid> PrimaryGrid = PrimaryFS.getGrid();
                if (!PrimaryGrid)
                        return false;
 
        RefPtr<Slice> mySlice = PrimaryFS.getSlice();
                if (!mySlice)
                        return false;
 
        FieldSelector SecondaryFS;
                SecondaryField << Context >> SecondaryFS;
 
        RefPtr<Grid> SecondaryGrid = SecondaryFS.getGrid();
                if (!SecondaryGrid)
                        return false;
 
        string  SelectedFieldName = SecondaryFS();
        bool    StoreResultInGrid = true;
 
        Grid&SourceGrid = *SecondaryGrid;
        Slice&DestSlice = *mySlice;
        RefPtr<Skeleton> DestVertices = PrimaryGrid->findVertices();
 
        string  HelperDestGridName = "alpha";
 
        RefPtr<Fiber::Field> LeftField = PrimaryFS.getField();
 
        RefPtr<Fiber::Field> RightField =
                EvalFieldOnRepresentation( FieldRep, DestVertices,
                                           SourceGrid, SelectedFieldName,
                                           DestSlice, HelperDestGridName, StoreResultInGrid);
 
 
        BinaryOperator<TheBinaryOperator,
                        PrimaryValueType, SecondaryValueType,
                        ResultValueType>
 
                BinaryOperatorInstance(RightField);
 
                if (RefPtr<Field> ResultField = newComputationalField(BinaryOperatorInstance, LeftField) )
                {
                string  NewFieldname = NamingOperator::ResultName(PrimaryFS(), SecondaryFS() );
                RefPtr<FieldID> NewFieldID = FieldRep.createSharedFieldID(FieldIDSource, NewFieldname);
 
                        FieldRep[ NewFieldID ] = ResultField;
                }
 
                return true;
        }
 
 
        bool postFieldOperation(VRequest&Context, int newlyCreatedFields) override
        {
                if (newlyCreatedFields>0)
                {
                FieldSelector PrimaryFS;
                        MyField << Context >> PrimaryFS;
 
                FieldSelector SecondaryFS;
                        SecondaryField << Context >> SecondaryFS;
 
                string  NewFieldname = NamingOperator::ResultName(PrimaryFS(), SecondaryFS() );
 
                FieldSelector   FieldSelection;
                        MyField << Context >> FieldSelection;
 
                FieldSelector   OutputFieldSelection( FieldSelection);
                        OutputFieldSelection.selectTypedField<ResultValueType>( NewFieldname );
 
                        ResultField << Context << OutputFieldSelection;
 
                        return setStatusInfo(Context, "Created new field " + NewFieldname);
                }
                else
                        return setStatusError(Context, "No computation performed on " + Fieldname(Context), false );
        }
 
static string createChildname(const string&parent_name)
        {
                return NamingOperator::createChildname(parent_name);
        }
};
 
 
} // namespace Wizt
 
 
#endif //  __FISH_BINARYOPERATOROBJECT_HPP