FieldInputCreator.hpp

#ifndef __FISH_BONE_FIELDINPUTCREATOR_HPP
#define __FISH_BONE_FIELDINPUTCREATOR_HPP
 
#include "FishGrid.hpp"
 
#include <ocean/shrimp/VStringList.hpp>
#include <ocean/plankton/VObject.hpp>
#include <ocean/plankton/VPipeline.hpp>
 
#include <bundle/FieldSelector.hpp>
 
#include <meta/LIST.hpp>
#include <meta/NativeTypeList.hpp>
 
#include <any>
 
namespace Wizt
{
        using namespace META;
        using any = std::any;
 
template <class FieldVObject, class OutputType>
        struct  FieldInputCreatorBaseTrait
{
        typedef VCreator<FieldVObject, AcceptList<Fiber::Field> > CreatorBase_t;
 
        typedef VInputCreator<OutputType, CreatorBase_t> Creator_t;
};
 
template <class FieldVObject>
struct  FieldInputCreatorBaseTrait<FieldVObject, void>
{
        typedef VCreator<FieldVObject, AcceptList<Fiber::Field> > Creator_t;
};
 
 
 
struct  TypeInspector
{
        const Fiber::FieldSelector&FS;
 
        bool    Yess;
        string  QualificationInfo;
 
        TypeInspector(const Fiber::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.requiresType( typeid(T) ) )
                        {
#ifdef  VERBOSE
                                printf("  ...... FIELD requires %s (%d fields available)\n", typeid(T).name(), TI.FS.NumberOfAvailableFields() );
#endif
                                TI.QualificationInfo = "Field qualifies to be of type " + Typename( typeid(T) );
                                TI.Yess = true;
                                        return true;
                        }
#ifdef  VERBOSE
                        printf("Field requirement %s is NOT available\n", typeid(T).name() );
#endif
                        return false; // continue traversal
                }
        };
};
 
 
template <class TypeList>
struct  FieldTypeAcception
{
static  auto allowType(const Fiber::FieldSelector&FS)
        {
        TypeInspector TI(FS);
                META::FOREACH<TypeInspector, TypeList>::exec(TI);
                return std::make_tuple(TI.Yess, TI.QualificationInfo);
        }
};
 
 
template <>
struct  FieldTypeAcception<std::any>
{
static  auto allowType(const Fiber::FieldSelector&FS)
        {
                return std::make_tuple(true, "");
        }
};
 
 
 
 
template <class FieldVObject, class TypeList = LIST<META::NIL>,
          class GridInspector = typename FieldVObject::GridInspector,
          int NumberOfInputFields = FieldVObject::NumberOfInputFields,
          class OutputType = void>
struct  FieldInputCreator : FieldInputCreatorBaseTrait<FieldVObject, OutputType>::Creator_t
{
        typedef typename FieldInputCreatorBaseTrait<FieldVObject, OutputType>::Creator_t FieldInputCreatorBase_t;
 
        FieldInputCreator(const string&name, int quality, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : FieldInputCreatorBase_t(name, quality, Prep)
        {
//              if (this->Arguments().length()<1)
//                      this->Arguments() = TypeString();
        }
 
        FieldInputCreator(const VCreatorProperties&CreatorProperties, int quality, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : FieldInputCreatorBase_t(CreatorProperties, quality, Prep)
        {
                if (this->Arguments().length()<1)
                        this->Arguments() = TypeString();
        }
 
        template <unsigned ID>
        FieldInputCreator(const VCreatorProperty<ID>&CreatorProperties, int quality, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : FieldInputCreatorBase_t(CreatorProperties, quality, Prep)
        {
                if (this->Arguments().length()<1)
                        this->Arguments() = TypeString();
        }
 
// allow to override verbosity domain in application code
#ifndef FieldInputCreatorVerbose
#define FieldInputCreatorVerbose(X) AppVerbose("FieldInput", X)
#endif
 
        VAcceptInfoList_t accept(const RefPtr<VObject>&vobj) const override
        {
                if (!vobj)
                {
                        FieldInputCreatorVerbose(20) << "FieldInputCreator(): NO INPUT FOUND!";
                        return  {};
                }
 
                FieldInputCreatorVerbose(30) <<
                        "RefPtr<VAcceptInfo> " << this->Name() << "::accept(const RefPtr<VObject>&"<< vobj->Name()<<" ) const override";
 
// Should iterate over all exported FieldSelectors, not only one
//      VAcceptInfoList_t FieldAcceptions = getAcceptInfoList( typeid(Fiber::FieldSelector) );
 
// getting just one for now
        RefPtr<VParameter> FieldParam = vobj->getImplementation( typeid(Fiber::FieldSelector) );
// TODO: Make this a function...
                if (!FieldParam)
                {
                        FieldInputCreatorVerbose(30) << "FieldInputCreator(): NO INPUT FIELD FOUND at " << vobj->Name();
                        return  {};
                }
 
                FieldInputCreatorVerbose(30) << "Getting Fieldselector for " << this->Name()
                                             << " from " << vobj->Name()
                                             << " found " << FieldParam->Name();
 
        Fiber::FieldSelector FS;
                if (!FieldParam->getValue( FS, NullPtr(), "" ) )
                {
                        FieldInputCreatorVerbose(30) << "FieldInputCreator(): Could not get fieldselector for " << vobj->Name();
                        return  {};
                }
 
                // No bundle here
                if (!FS.getBundle() )
                {
                        FieldInputCreatorVerbose(30) << "FieldInputCreator(): No BUNDLE available at " << vobj->Name();
 
                        //
                        // Thus allow any field connection since the providing object
                        // could yet create a bundle with possibly fitting fields once
                        // it is requested later.
                        //
                VAcceptInfoList_t VAIL = VCreator<FieldVObject, AcceptList<Fiber::Field> >::accept(vobj);
 
                        return ( VAIL & "Unitialized generic Field provider, "
                                 "might be suitable to provide the requested type, we don't know yet.") * 0.5;
/*
                        if (RefPtr<VAcceptInfo> VAI = VCreator<FieldVObject, AcceptList<Fiber::Field> >::accept(vobj) )
                        {
                                return ( VAI & "Unitialized generic Field provider, "
                                         "might be suitable to provide the requested type, we don't know yet.") * 0.5;
                        }
 
                        return NullPtr();
*/
                }
 
                //
                // Fields are available on input, but not enough. FAIL.
                //
                if (FS.NumberOfAvailableFields()>0
                    &&
                    FS.NumberOfAvailableFields()<NumberOfInputFields)
                {
                        FieldInputCreatorVerbose(30) <<
                                "FieldInputCreator(): Input object provides a number of available fields, "
                                "but FS.NumberOfAvailableFields() ("
                                                     <<FS.NumberOfAvailableFields()
                                                     <<") < NumberOfInputFields ("<<NumberOfInputFields<<")\n";
 
                        return  {};
                }
 
                //
                // Check the type of the grid on which the input field resides.
                //
        GridSelector&GS = FS;
                if (!GS.hasProperty(GridInspector::InspectionProperty() ) )
                {
                        FieldInputCreatorVerbose(30) << "The Grid as exported by " << vobj->Name() << " does not qualify as input.";
 
                        return  {};
                }
 
                FieldInputCreatorVerbose(30) << "FieldInputCreator(): INSPECT FIELD AS EXPORTED BY "
                                             << vobj->Name() <<" (" << FS.FieldTypes().size() << " types) "
                                             << FS.FieldTypes().str();
 
 
                //
                // Investigate if the given Field Selector,
                // as exported by a given object, provides the
                // correct type as requested by the current creator.
                //
        TypeInspector TI(FS);
                META::FOREACH<TypeInspector, TypeList>::exec(TI);
 
        auto[allowType, Info] = FieldTypeAcception<TypeList>::allowType(FS);
                if (!allowType)
                {
                        FieldInputCreatorVerbose(30) << "NOPE, don't want this field type";
                        // no such match, return empty list.
                        return  {};
                }
 
        VAcceptInfoList_t VAIL = VCreator<FieldVObject, AcceptList<Fiber::Field> >::accept(vobj);
                FieldInputCreatorVerbose(30) << "YESSS, accepted this field type";
 
                return VAIL & Info;
        }
 
 
 
 
        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, class GridInspector = typename FieldVObject::GridInspector, class OutputType = void>
struct  TypedFieldInputCreator : FieldInputCreator<FieldVObject, typename FieldVObject::InputTypes, GridInspector, FieldVObject::NumberOfInputFields, OutputType>
{
        typedef FieldInputCreator<FieldVObject, typename FieldVObject::InputTypes, GridInspector, FieldVObject::NumberOfInputFields, OutputType>
                        TypedFieldInputCreatorBase_t;
 
        TypedFieldInputCreator(const string&name, int quality, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : TypedFieldInputCreatorBase_t(name, quality, Prep)
        {}
 
        TypedFieldInputCreator(const VCreatorProperties&CreatorProperties, int quality, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : TypedFieldInputCreatorBase_t(CreatorProperties, quality, Prep)
        {}
 
        template <unsigned ID>
        TypedFieldInputCreator(const VCreatorProperty<ID>&CreatorProperties, int quality, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : TypedFieldInputCreatorBase_t(CreatorProperties, quality, Prep)
        {}
};
 
 
 
 
 
 
template <class FunctionObject>
struct  VSource<FunctionObject, Fiber::Field> : Ref<VInputCreator<Fiber::Field, VCreator<FunctionObject> > >
{
        typedef Ref<VInputCreator<Fiber::Field, VCreator<FunctionObject> > > Base_t;
 
        VSource(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : Base_t(name, p, Prep)
        {}
 
        template <unsigned ID>
        VSource(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : Base_t(VP, p, Prep)
        {}
};
 
 
template <class FunctionObject, class OutputType>
struct  VFilter<Fiber::Field,FunctionObject, OutputType> : Ref<TypedFieldInputCreator<FunctionObject, typename FunctionObject::GridInspector, OutputType> >
{
        typedef Ref<TypedFieldInputCreator<FunctionObject, typename FunctionObject::GridInspector, OutputType> > VFilterFieldBase_t;
 
        VFilter(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : VFilterFieldBase_t(name, p, Prep)
        {}
 
        template <unsigned ID>
        VFilter(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : VFilterFieldBase_t(VP, p, Prep)
        {}
};
 
 
template <class FunctionObject>
struct  VSink<Fiber::Field,FunctionObject> : Ref<TypedFieldInputCreator<FunctionObject> >
{
        VSink(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : Ref<TypedFieldInputCreator<FunctionObject> >(name, p, Prep)
        {}
 
        template <unsigned ID>
        VSink(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : Ref<TypedFieldInputCreator<FunctionObject> >(VP, p, Prep)
        {}
};
 
 
 
template <class FunctionObject>
struct  VPipeline<void, FunctionObject, Fiber::Field> : VSource<FunctionObject, Fiber::Field>
{
        VPipeline(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : VSource<FunctionObject, Fiber::Field>(name, p, Prep)
        {}
 
        template <unsigned ID>
        VPipeline(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : VSource<FunctionObject, Fiber::Field>(VP, p, Prep)
        {}
};
 
 
 
 
template <class FunctionObject, class OutputType>
struct  VPipeline<Fiber::Field, FunctionObject, OutputType> : VFilter<Fiber::Field,FunctionObject,OutputType>
{
        VPipeline(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : VFilter<Fiber::Field, FunctionObject, OutputType> (name, p, Prep)
        {}
 
        template <unsigned ID>
        VPipeline(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : VFilter<Fiber::Field, FunctionObject, OutputType> (VP, p, Prep)
        {}
};
 
template <class FunctionObject>
struct  VPipeline<Fiber::Field, FunctionObject, void> : VSink<Fiber::Field,FunctionObject>
{
        VPipeline(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : VSink<Fiber::Field, FunctionObject> (name, p, Prep)
        {}
 
        template <unsigned ID>
        VPipeline(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = NullPtr() )
        : VSink<Fiber::Field, FunctionObject> (VP, p, Prep)
        {}
};
 
 
} // namespace Wizt
 
#endif /* __FISH_BONE_FIELDINPUTCREATOR_HPP */