FishGrid.hpp

#ifndef __FISH_BONE_GRID_HPP
#define __FISH_BONE_GRID_HPP
 
#include "Fish.hpp"
#include <ocean/shrimp/VStringList.hpp>
#include <bundle/GridSelector.hpp>
#include <bundle/FieldSelector.hpp>
 
#include "GridInspector.hpp"
 
namespace Wizt
{
        using Fiber::GridSelector;
 
        typedef Fiber::Bundle::GridInfo_t GridInfo;
 
template <>
struct  fishbone_API VValueTrait<GridSelector>
{
static  bool setValueFromText(GridSelector&i, const string&s)
        {
                return i.selectGrid( s );
        }
 
static  string Text(const GridSelector&GS)
        {
                return GS.Gridname();
        }
};
 
//extern        fishbone_API TypedSlot<Fiber::BundlePtr> getSpacetimeSlot(const TypedSlot<GridSelector>&GS);
 
template <>
struct  fishbone_API TypedSlot<Fiber::Grid> : public TypedSlot<GridSelector>
{
        TypedSlot(VSlotContainer*that, const string&s, const GridSelector&GS = GridSelector(), int prior=0)
        : TypedSlot<GridSelector>(that,s, GS, prior)
        {
                assert(that);
        }
};
 
 
template <>
struct  fishbone_API VSlotContainer::in<Fiber::Grid, VSlotContainer::InvalidExpertLevel, void> : public TypedSlot<Fiber::Grid>
{
        in(VSlotContainer*that, const string&name, const GridSelector&GS = GridSelector(), int expertLevel=0)
        : TypedSlot<Fiber::Grid>(that, name, GS, expertLevel)
        {}
 
        ~in();
};
 
 
template <>
class   fishbone_API VOutput<Fiber::Grid> : public VOutput<GridSelector>
{
public:
        VOutput(VConnectable*Source,
                const string&initial_name,
                const GridSelector&GridNames = GridSelector(),
                const RefPtr<VCreationPreferences>&CP = NullPtr() );
};
 
 
template<>
struct  fishbone_API VSlotContainer::out<Fiber::Grid,void> : public VOutput<Fiber::Grid>
{
/*      out(const VParameter::SourceObject_t&Source,
            const string&initial_name,
            const  Fiber::GridSelector&InitValue,
            const RefPtr<VCreationPreferences>&CP = NullPtr() )
        : VOutput<Fiber::Grid>(Source, initial_name, InitValue, CP)
        {}
*/
        out(VConnectable*Source,
            const string&initial_name,
            const Fiber::GridSelector&InitValue = GridSelector(),
            const RefPtr<VCreationPreferences>&CP = NullPtr() )
        : VOutput<Fiber::Grid>(Source, initial_name, InitValue, CP)
        {}
 
//      out(const VSlotContainer::Deferred&)
//      : VOutput<Fiber::Grid>(VSlotContainer::Deferred())
//      {}
 
        ~out();
};
 
 
 
template <>
struct  fishbone_API Fish<Fiber::GridContainer>
{
        virtual const Fish<Fiber::Grid>&GridContainer() const = 0;
        virtual ~Fish() = 0;
};
 
template <>
struct  fishbone_API Fish<Fiber::Grid> : public virtual Fish<double>
{
        TypedSlot<Fiber::Grid>  MyGrid;
 
        Fish(const string&s = "grid", int prior=2);
 
        virtual ~Fish();
 
        void    registerGridAsOutput()
        {
                this->registerOutput( MyGrid );
        }
 
        Fiber::Bundle::GridInfo_t
                findMostRecentGrid(GridSelector&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
        {
        GridSelector    GS;
                return findMostRecentGrid(GS, VP, SpaceTime);
        }
 
        virtual GridSelector getGridSelector(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;
 
        using   Fish<double>::IterateLevels;
 
        bool    IterateLevelsOnMostRecentGrid(LevelIterator&LI, const RefPtr<ValuePool>&Context,
                                              const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr( NullPtr() ) ) const
        {
                return Fish<double>::IterateLevels(LI, findMostRecentGrid(Context, SpaceTime), Context);
        }
 
 
        RefPtr<Fiber::Field>    getField(const Fiber::FieldSelector&FS,
                                         const RefPtr<ValuePool>&VP,
                                         const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr(NullPtr() ) );
 
};
 
} // namespace Wizt
 
#endif /* __FISH_BONE_GRID_HPP */