FishField.hpp

#ifndef __FISH_BONE_FIELD_HPP
#define __FISH_BONE_FIELD_HPP

#include "FishGrid.hpp"

#include <ocean/shrimp/VStringList.hpp>
#include <ocean/plankton/VCreator.hpp>
#include <ocean/plankton/VObject.hpp>
#include <bundle/FieldSelector.hpp>

#include <meta/LIST.hpp>
#include <meta/NativeTypeList.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() );

        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() ); 

                (*this) << Context << F;
                return true;
        }
};



template <>
class fishbone_API VValueTrait<FieldSelector>
{
public:

static  bool setValueFromText(FieldSelector&i, const string&s); 

static  string Text(const FieldSelector&F);

};


template <>
struct  fishbone_API TypedSlot<Fiber::Field> : TypedSlot<FieldSelector>
{
        TypedSlot<Fiber::Field>(VObject*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;
                if (!VVF) return false; 

        FieldSelector&VF = *VVF;

                VF.accept<T>();

                return true;
        } 


        string  getFieldname(const RefPtr<ValuePool>&VP) const
        {
        FieldSelector FP; 
                (*this) << VP >> FP; 
                return FP();
        }
};

template <>
class   fishbone_API Fish<Fiber::Field> : public virtual Fish<double>
{
protected:
        TypedSlot<Fiber::Field>  MyField;

public:
        enum
        {
                NumberOfInputFields = 1 
        };

        Fish<Fiber::Field>(const string&field, int ExpertLevel=0); 

        template <class T>
        bool acceptType()
        {
                if (!MyField) return false;

        RefPtr<VValue<FieldSelector> > VVF = **MyField; 
                if (!VVF) return false; 

        FieldSelector&VF = *VVF; 

                VF.accept<T>();

                return true;
        } 

        void setFieldExpertLevel(int EL)
        {
                myself->setExpertLevel( MyField, EL);
        }

        ~Fish(); 


        void registerFieldAsOutput()
        {
                assert(myself);
                myself->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;

        FieldSelector  getFieldSelector(const RefPtr<ValuePool>&VP) const; 

        override double getTime(const RefPtr<ValuePool>&VP, const RefPtr<Fiber::Bundle>&SpaceTime) const; 

        TypedSlot<VTime> getTimeSlot() const
        {
                return MyField.getTimeSlot();
        }

        RefPtr<Fiber::Field>  getField(const RefPtr<Fiber::Representation>&LevelRep,
                                       const RefPtr<ValuePool>&VP) const; 


        override Fiber::Info<Fiber::Skeleton>
                        getRefinementLevel(int Level,
                                           const RefPtr<ValuePool>&VP,
                                           int IndexDepth = 0,
                                           const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr(NullPtr() ) ); 


        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
        {
        FieldSelector   GS;
                return findMostRecentGrid(GS, VP, SpaceTime);
        } 

        using Fish<double>::IterateLevels;

        bool    IterateLevels(LevelIterator&LI, const RefPtr<ValuePool>&Context,
                              const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr( NullPtr() ) );


};

using META::LIST;

template <class FieldVObject, class TypeList = LIST<META::NIL>, 
          int NumberOfInputFields = FieldVObject::NumberOfInputFields>
struct  FieldInputCreator : VCreator<FieldVObject, AcceptList<Fiber::Field> >  
{
        FieldInputCreator(const string&name, int quality)
        : VCreator<FieldVObject, AcceptList<Fiber::Field> > (name, quality)
        {
//              if (this->Arguments().length()<1)
//                      this->Arguments() = TypeString();
        }

        FieldInputCreator(const VCreatorProperties&CreatorProperties, int quality)
        : VCreator<FieldVObject, AcceptList<Fiber::Field> > (CreatorProperties, quality)
        {
                if (this->Arguments().length()<1)
                        this->Arguments() = TypeString();
        }

        template <unsigned ID>
        FieldInputCreator(const VCreatorProperty<ID>&CreatorProperties, int quality)
        : VCreator<FieldVObject, AcceptList<Fiber::Field> > (CreatorProperties, quality)
        {
                if (this->Arguments().length()<1)
                        this->Arguments() = TypeString();
        }


        struct  TypeInspector
        {
                const FieldSelector&FS;
                bool    Yess;

                TypeInspector(const FieldSelector&fs)
                : FS(fs)
                , Yess(false)
                {}

                template <typename T>
                struct exec
                {
                        // return true if the traversal of the list 
                        // should be stopped
                static inline bool Break(TypeInspector&TI)
                        {
#ifdef  VERBOSE
                                printf("    TypeInspector<%s>: ", typeid(T).name() ); 
                                TI.FS.FieldTypes().speak(); puts("");
#endif
                                if (TI.FS.requires( typeid(T) ) )
                                {
#ifdef  VERBOSE
                                        printf("  ...... FIELD requires %s (%d fields available)\n", typeid(T).name(), TI.FS.NumberOfAvailableFields() );
#endif
                                        TI.Yess = true;
                                        return true;
                                }
#ifdef  VERBOSE
                                printf("Field requirement %s is NOT available\n", typeid(T).name() );
#endif
                                return false; // continue traversal
                        }
                };
        };

        override RefPtr<VAcceptInfo> accept(const RefPtr<VObject>&vobj) const
        {
#ifdef  VERBOSE
                printf("override RefPtr<VAcceptInfo> %s::accept(const RefPtr<VObject>&%s) const\n", 
                       this->Name().c_str(), vobj->Name().c_str()
                        );
#endif
                if (!vobj)
                {
#ifdef  VERBOSE
                        puts("FieldInputCreator(): NO INPUT FOUND!\n");
#endif
                        return NullPtr();
                }

        RefPtr<VParameter> FieldParam = vobj->getImplementation( typeid(Fiber::FieldSelector) );
                if (!FieldParam)
                {
#ifdef  VERBOSE
                        printf("FieldInputCreator(): NO INPUT FIELD FOUND at %s\n",vobj->Name().c_str() );
#endif
                        return NullPtr();
                }
#ifdef  VERBOSE
                printf("             [%s]  GET FIELDSELECTOR\n", this->Name().c_str() );
#endif
        FieldSelector FS;
                if (!FieldParam->getValue( FS, NullPtr(), "" ) )
                {
#ifdef  VERBOSE
                        printf("FieldInputCreator(): COULD NOT RETRIEVE FIELD TYPE at %s\n",vobj->Name().c_str() );
#endif
                        return NullPtr();
                }
                if (FS.NumberOfAvailableFields()>0
                    &&
                    FS.NumberOfAvailableFields()<NumberOfInputFields)
                {
#ifdef  VERBOSE
                        printf("FieldInputCreator(): Input object provides a number of available fields, "
                               "but FS.NumberOfAvailableFields() (%d) < NumberOfInputFields (%d)\n",
                               FS.NumberOfAvailableFields(), NumberOfInputFields);
#endif
                        return NullPtr();
                }

#ifdef  VERBOSE
                printf("FieldInputCreator(): INSPECT FIELD AS EXPORTED BY %s (%u types)\n",vobj->Name().c_str(), FS.FieldTypes().size() ); 
                FS.FieldTypes().speak();puts("");
#endif
        TypeInspector TI(FS);
                META::FOREACH<TypeInspector, TypeList>::exec(TI);

                //      if (!GridObject::HasGrids(vobj) )
                //      return NullPtr();
        RefPtr<VAcceptInfo>
                VAI = VCreator<FieldVObject, AcceptList<Fiber::Field> >::accept(vobj); 

                if (!VAI)
                        return NullPtr();

                if (!TI.Yess)
                {
#ifdef  VERBOSE
                        puts("NOPE, don't want this field type");
#endif
                        return NullPtr();
                }
#ifdef  VERBOSE
                puts("YESSS, accepted this field type");
#endif
//              printf(" ACCEPTED AS: %s\n", Typename( VAI->what ).c_str() );
                return VAI;
        }

        


        struct  MakeString
        {
                string  theTypeString;

                template <typename T>
                struct exec
                {
                        // return true if the traversal of the list 
                        // should be stopped
                static  inline bool Break(MakeString&MS)
                        {
                                if (MS.theTypeString.length()<1)
                                        MS.theTypeString += "|"; 

                                MS.theTypeString += Typename( typeid(T) ); 
                                return false;
                        }
                };
        }; 

static  string  TypeString()
        {
        MakeString MS;
                META::FOREACH<MakeString, TypeList>::exec(MS); 
                return MS.theTypeString;
        }


};


template <class FieldVObject>
struct  TypedFieldInputCreator : FieldInputCreator<FieldVObject, typename FieldVObject::InputTypes>
{
        TypedFieldInputCreator(const string&name, int quality)
        : FieldInputCreator<FieldVObject, typename FieldVObject::InputTypes>(name, quality)
        {}

        TypedFieldInputCreator(const VCreatorProperties&CreatorProperties, int quality)
        : FieldInputCreator<FieldVObject, typename FieldVObject::InputTypes>(CreatorProperties, quality)
        {}

        template <unsigned ID>
        TypedFieldInputCreator(const VCreatorProperty<ID>&CreatorProperties, int quality)
        : FieldInputCreator<FieldVObject, typename FieldVObject::InputTypes>(CreatorProperties, quality)
        {}
};

} // namespace Wizt

#endif /* __FISH_BONE_FIELD_HPP */