GridActor.hpp

#ifndef __FISH_BONE_GRIDACTOR_HPP
#define __FISH_BONE_GRIDACTOR_HPP
 
#include <ocean/plankton/VPipeline.hpp>
 
#include <bundle/GridSelector.hpp>
#include <bundle/BundleProperty.hpp>
 
#include "Fish.hpp"
 
namespace Wizt
{
 
 
template <class GridInspector, class CreativeObject = void>
struct  GridActor : VCreator<CreativeObject, AcceptList<Fiber::Grid> >
{
        typedef VCreator<CreativeObject, AcceptList<Fiber::Grid> > Base_t;
 
        GridActor(const std::string&name, int quality,
                  const RefPtr<VCreationPreferences>&VP=nullptr,
                  const char*const CreatorReleaseIdentifier = VISH_INPUT_CREATOR_RELEASE_IDENTIFIER)
        : Base_t(name, quality, VP, CreatorReleaseIdentifier)
        {}
 
        template <unsigned ID>
        GridActor(const VCreatorProperty<ID>&CreatorProperties,
                  int quality, const RefPtr<VCreationPreferences>&VP=nullptr,
                  const char*const CreatorReleaseIdentifier = VISH_INPUT_CREATOR_RELEASE_IDENTIFIER)
        : Base_t(CreatorProperties, quality, VP, CreatorReleaseIdentifier)
        {}
 
 
        VAcceptInfoList_t accept(const RefPtr<VObject>&vobj) const override
        {
#ifdef  VERBOSE_GRIDACTOR
                printf("----> GridActor::accept() %s looking at %s\n",
                       Typename(typeid(CreativeObject)).c_str(), vobj->Name().c_str() override;
#endif
                MemCoreSetLastKnownSourceCodeLineEntry
 
                /*POSSIBLE PROBLEM:
                  Could have multiple grid selectors in vobj, thus
                  should rather iterate over them than getting the first one here.
                 */
        RefPtr<VParameter> GPar = vobj -> getImplementation( typeid(Fiber::GridSelector) );
                if (!GPar)
                        return VAcceptInfoList_t();
 
        Fiber::GridSelector GS;
                if (!GPar->getValue( GS, nullptr, "") )
                        return VAcceptInfoList_t();
 
                MemCoreSetLastKnownSourceCodeLineEntry
 
                if (!GS.BundleSource() )
                {
                        //
                        // source object exports a GridSelector,
                        // but has no bundle object yet.
                        // Probably this means that it wants to export
                        // a Grid, but its creation has not yet been triggered.
                        // Thus, allow accepting this object, such that
                        // this rendering object may trigger the creation of
                        // an appropriate Grid.
                        //
#ifdef  VERBOSE_GRIDACTOR
                        printf("GRIDACTOR: NO BUNDLE YET in [%s] -> [%s] - allowing all output objects. "
                               "If that is not desirable, object should output an empty bundle.\n",
                               vobj->Name().c_str(), GPar->Name().c_str()
                                );
#endif
                        return Base_t::accept(vobj)*0.5 & "There is no Bundle yet on the given Grid, this output "
                                                          "might be possible, but not necessarily suitable.";
                }
 
//              if (hasProperty(GS, GridInspector::InspectionProperty() ) )
 
                MemCoreSetLastKnownSourceCodeLineEntry
 
                if (GS.hasProperty(GridInspector::InspectionProperty() ) )
                {
#ifdef  VERBOSE_GRIDACTOR
                        puts("OUTPUT BUNDLE HAS REQUESTED PROPERTY - output object permitted");
#endif
                        MemCoreSetLastKnownSourceCodeLineEntry
                        return Base_t::accept(vobj)*2.0 &
                                "The suggested output is suitable to the properties of the given Grid.";
                }
                MemCoreSetLastKnownSourceCodeLineEntry
 
                return VAcceptInfoList_t();
        }
};
 
template <class CreativeObject>
struct  GridActor<CreativeObject, void> : GridActor<typename CreativeObject::GridInspector, CreativeObject>
{
        GridActor(const std::string&name, int quality,
                  const RefPtr<VCreationPreferences>&Prep = nullptr,
                  const char*const CreatorReleaseIdentifier = VISH_INPUT_CREATOR_RELEASE_IDENTIFIER)
        : GridActor<typename CreativeObject::GridInspector, CreativeObject>(name, quality, Prep, CreatorReleaseIdentifier)
        {}
 
        template <unsigned ID>
        GridActor(const VCreatorProperty<ID>&VP,
                  int p = ObjectQuality::EXPERIMENTAL,
                  const RefPtr<VCreationPreferences>&Prep = nullptr,
                  const char*const CreatorReleaseIdentifier = VISH_INPUT_CREATOR_RELEASE_IDENTIFIER)
        : GridActor<typename CreativeObject::GridInspector, CreativeObject>(VP, p, Prep, CreatorReleaseIdentifier)
        {}
};
 
 
template <class GridFunctionObject>
struct  VSink<Fiber::Grid, GridFunctionObject> : OmegaRef<GridActor<GridFunctionObject> >
{
        VSink(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = nullptr )
        : OmegaRef<GridActor<GridFunctionObject> >(name, p, Prep)
        {}
 
        template <unsigned ID>
        VSink(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = nullptr )
        : OmegaRef<GridActor<GridFunctionObject> >(VP, p, Prep)
        {}
};
 
 
template <class GridFunctionObject, class OutputObject>
struct  VFilter<Fiber::Grid, GridFunctionObject, OutputObject> : OmegaRef<VInputCreator<OutputObject, GridActor<GridFunctionObject> > >
{
        VFilter(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = nullptr )
        : OmegaRef<VInputCreator<OutputObject, GridActor<GridFunctionObject> > >(name, p, Prep)
        {}
 
        template <unsigned ID>
        VFilter(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = nullptr )
        : OmegaRef<VInputCreator<OutputObject, GridActor<GridFunctionObject> > >(VP, p, Prep)
        {}
};
 
 
 
template <class GridFunctionObject, class OutputObject>
struct  VPipeline<Fiber::Grid, GridFunctionObject, OutputObject> : VFilter<Fiber::Grid, GridFunctionObject, OutputObject>
{
        VPipeline(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = nullptr )
        : VFilter<Fiber::Grid, GridFunctionObject, OutputObject>(name, p, Prep)
        {}
 
        template <unsigned ID>
        VPipeline(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = nullptr )
        : VFilter<Fiber::Grid, GridFunctionObject, OutputObject>(VP, p, Prep)
        {}
};
 
template <class GridFunctionObject>
struct  VPipeline<Fiber::Grid, GridFunctionObject, void> : VFilter<Fiber::Grid, GridFunctionObject, void>
{
        VPipeline(const string&name, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = nullptr )
        : VFilter<Fiber::Grid, GridFunctionObject, void>(name, p, Prep)
        {}
 
        template <unsigned ID>
        VPipeline(const VCreatorProperty<ID>&VP, int p = ObjectQuality::EXPERIMENTAL, const RefPtr<VCreationPreferences>&Prep = nullptr )
        : VFilter<Fiber::Grid, GridFunctionObject, void>(VP, p, Prep)
        {}
};
 
 
} // namespace Wizt
 
#endif /* __FISH_BONE_GRIDACTOR_HPP */