FishField.hpp

#ifndef __FISH_BONE_FIELD_HPP
#define __FISH_BONE_FIELD_HPP
 
#include "FishGrid.hpp"
 
#include <ocean/plankton/VObject.hpp>
#include <ocean/plankton/VPipeline.hpp>
 
#include <ocean/shrimp/VStringList.hpp>
#include <ocean/shrimp/VTime.hpp>
 
#include <bundle/FieldSelector.hpp>
 
#include <meta/LIST.hpp>
#include <meta/NativeTypeList.hpp>
 
#include "FieldInputCreator.hpp"
 
 
namespace Wizt
{
        using Fiber::FieldSelector;
 
template <>
class   fishbone_API VOutput<Fiber::Field> : public VOutput<FieldSelector>
{
public:
        VOutput(const WeakPtr<VObject>&Source,
                const string&initial_name,
                const RefPtr<VCreationPreferences>&CP = NullPtr() );
 
        VOutput(const VObject::Deferred&D);
 
        template <class T>
        bool provides(const RefPtr<ValuePool>&Context = NullPtr() )
        {
        FieldSelector F;
                (*this) << Context >> F;
 
//              AcceptType<T> xxx(F.FieldTypes());
 
                F.accept<T>();
 
//              F.setType( Fiber::FiberType< T >::getFiberType() );
//              F.AcceptableFieldTypes.insert( Fiber::FiberType< T >::getFiberType().self() );
 
//      const VOutputAssignmentContext<Fiber::Field>&f = (*this) << Context;
//      const VOutputAssignmentContext<Fiber::FieldSelector>&f = (*this) << Context;
//              f << F;
 
                (*this) << Context << F;
                return true;
        }
};
 
 
 
template <>
struct fishbone_API VValueTrait<FieldSelector>
{
 
 
static  bool setValueFromText(FieldSelector&i, const string&s);
 
static  string Text(const FieldSelector&F);
 
};
 
template <>
class fishbone_API VInputValueTrait<FieldSelector>
{
public:
static  void init(FieldSelector&)
        {}
 
static  bool setValueFromText(FieldSelector&i, const string&s)
        {
                return VValueTrait<FieldSelector>::setValueFromText(i, s);
        }
};
 
template <>
class fishbone_API VInputValueTrait<Fiber::Field>
{
public:
static  void init(Fiber::Field&)
        {}
 
static  bool setValueFromText(Fiber::Field&i, const string&s)
        {
                return false;
        }
};
 
class fishbone_API FieldValueConstraint : public VParameterConnectionConstraint
{
public:
        virtual ~FieldValueConstraint();
 
        bool isConnectable(const VParameter&Output, const VParameter&Input) const override;
};
 
 
template <>
struct  fishbone_API TypedSlot<Fiber::Field> : TypedSlot<FieldSelector>
{
        TypedSlot(VSlotContainer*that, const string&slotname, int prior=0);
 
        TypedSlot<VTime>        getTimeSlot() const;
 
        template <class T>
        bool acceptType()
        {
                if (!*this) return false;
 
        RefPtr<VValue<FieldSelector> > VVF = (*this)->getGlobalValue();
                if (!VVF) return false;
 
        FieldSelector&VF = *VVF;
 
                VF.accept<T>();
 
                return true;
        }
 
        string  getFieldname(const RefPtr<ValuePool>&VP) const;
 
};
 
 
template <>
struct  fishbone_API VSlotContainer::in<Fiber::Field, VSlotContainer::InvalidExpertLevel, void> : public TypedSlot<Fiber::Field>
{
        in(VSlotContainer*that, const string&name, int expertLevel=0)
        : TypedSlot<Fiber::Field>(that, name, expertLevel)
        {}
 
        ~in();
};
 
 
template <>
struct  fishbone_API Fish<Fiber::Field> : public virtual Fish<double>
{
protected:
        TypedSlot<Fiber::Field>  MyField;
 
public:
        enum
        {
                NumberOfInputFields = 1
        };
 
        Fish(const string&field, int ExpertLevel=0);
 
        template <class ...T>
        bool    acceptType()
        {
                if (!MyField) return false;
 
        RefPtr<VValue<FieldSelector> > VVF = MyField->getGlobalValue();
                if (!VVF) return false;
 
        FieldSelector&VF = *VVF;
 
                VF.accept<T...>();
 
                return true;
        }
 
        void    setFieldExpertLevel(int EL)
        {
                this->setExpertLevel( MyField, EL);
        }
 
        ~Fish();
 
 
        void    registerFieldAsOutput()
        {
                this->registerOutput( MyField );
        }
 
        string  Fieldname(const RefPtr<ValuePool>&VP) const;
 
        string  getFieldname(const RefPtr<ValuePool>&VP) const
        {
                return Fieldname(VP);
        }
 
        RefPtr<Fiber::Field>  getField(const RefPtr<ValuePool>&VP) const;
 
        RefPtr<Fiber::Field>  getField(const RefPtr<ValuePool>&VP, const string&theFieldName) const;
 
        RefPtr<Fiber::Field>  getFieldRepresentation(const RefPtr<Fiber::Representation>&LevelRep,
                                                     const RefPtr<ValuePool>&VP,
                                                     const RefPtr<Fiber::Skeleton>&DestVertices,
                                                     Fiber::Grid&SourceGrid,
                                                     Fiber::Slice&DestGridSlice, const string&HelperDestGridName,
                                                     bool StoreResult = true);
 
        RefPtr<Fiber::Field>  getCoordinates(const RefPtr<ValuePool>&VP) const
        {
                return getField(VP, "Positions");
        }
 
        FieldSelector  getFieldSelector(const RefPtr<ValuePool>&VP) const;
 
        double getTime(const RefPtr<ValuePool>&VP, const RefPtr<Fiber::Bundle>&SpaceTime) const override;
 
        TypedSlot<VTime> getTimeSlot() const
        {
                return MyField.getTimeSlot();
        }
 
        RefPtr<VManagedObject> getSource() const
        {
                return MyField.getSource();
        }
 
        RefPtr<Fiber::Field>  getField(const RefPtr<Fiber::Representation>&LevelRep,
                                       const RefPtr<ValuePool>&VP) const;
 
 
        Fiber::Info<Fiber::Skeleton>
                getRefinementLevel(int Level,
                                   const RefPtr<ValuePool>&VP,
                                   int IndexDepth = 0,
                                   const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr(NullPtr() ) )
                const override ;
 
 
        Fiber::Bundle::GridInfo_t
                findMostRecentGrid(FieldSelector&GS, const RefPtr<ValuePool>&VP, const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr(NullPtr() )) const;
 
        Fiber::Bundle::GridInfo_t
                findMostRecentGrid(const RefPtr<ValuePool>&VP, const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr( NullPtr() ) ) const;
 
        using Fish<double>::IterateLevels;
 
        bool    IterateLevels(LevelIterator&LI, const RefPtr<ValuePool>&Context,
                              const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr( NullPtr() ) ) const;
 
 
};
 
template <class ...FieldTypes>
struct  TypedField : public Fish<Fiber::Field>
{
        using   InputTypes = META::LIST<FieldTypes...>;
 
        TypedField(const string&field, int ExpertLevel=0)
        : Fish(field, ExpertLevel)
        {
                this->acceptType<FieldTypes...>();
        }
};
 
} // namespace Wizt
 
#endif /* __FISH_BONE_FIELD_HPP */