FishGrid.hpp

#ifndef __FISH_BONE_GRID_HPP
#define __FISH_BONE_GRID_HPP

#include "Fish.hpp"
#include <ocean/shrimp/VStringList.hpp>
#include <bundle/GridSelector.hpp>

namespace Wizt
{
        using Fiber::GridSelector;

        typedef Fiber::Bundle::GridInfo_t GridInfo;

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

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<Fiber::Grid>(VObject*that, const string&s, const GridSelector&GS = GridSelector(), int prior=0)
        : TypedSlot<GridSelector>(that,s, GS, prior)
        {}
};


template <>
class   fishbone_API VOutput<Fiber::Grid> : public VOutput<GridSelector>
{
public:
        VOutput(const WeakPtr<VObject>&Source,
                const string&initial_name,
                const GridSelector&GridNames = GridSelector(),
                const RefPtr<VCreationPreferences>&CP = NullPtr() );
};





template <>
struct  fishbone_API Fish<Fiber::GridContainer>
{
        virtual const Fish<Fiber::Grid>&GridContainer() const = 0;
        virtual ~Fish<Fiber::GridContainer>() = 0;
};

template <>
struct  fishbone_API Fish<Fiber::Grid> : virtual Fish<double>
{
        TypedSlot<Fiber::Grid>  MyGrid;

        Fish<Fiber::Grid>(const string&s = "grid", int prior=2);

        virtual ~Fish(); 

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

        GridSelector getGridSelector(const RefPtr<ValuePool>&VP) const
        {
        GridSelector    GS;
                MyGrid << VP >> GS;
                return GS;
        }

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

        Fiber::Info<Fiber::Skeleton>
                getRefinementLevel(int Level, 
                                   const RefPtr<ValuePool>&VP,
                                   int IndexDepth = 0,
                                   const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr(NullPtr() ) )
        {
                return const_cast<const Fish<Fiber::Grid>*>(this)->getRefinementLevel(Level, VP, IndexDepth, SpaceTime);
        }

        using Fish<double>::IterateLevels; 

        bool    IterateLevels(LevelIterator&LI, const RefPtr<ValuePool>&Context,
                              const Fiber::BundlePtr&SpaceTime = Fiber::BundlePtr( NullPtr() ) )
        {
                return Fish<double>::IterateLevels(LI, findMostRecentGrid(Context, SpaceTime), Context);
        }


#if 0
/*
        override const Fish<Fiber::Grid>&GridContainer() const
        {
                return *this;
        }
*/
        string  getGridname(const RefPtr<ValuePool>&VP) const; 

        typedef Fiber::Bundle::GridInfo_t pair_t;

        typedef pair<double, RefPtr<Fiber::Grid> > gridpair_t; 

        BundleSlot findGridSpacetimeSlot() const;

        BundleSlot GridSpacetimeSlot() const;

private:
        Fiber::Bundle::GridInfo_t getGridSlice(const BundleSlot&SpaceTime, const RefPtr<ValuePool>&VP) const;

public:
#endif

#if 0
        pair_t getGridSlice(const RefPtr<ValuePool>&VP) const
        {
                return getGridSlice( GridSpacetimeSlot(), VP);
        }

        gridpair_t getGrid(const RefPtr<ValuePool>&VP) const
        {
                return getGrid( GridSpacetimeSlot(), VP);
        }
#endif
#if 0

        pair<double, RefPtr<Fiber::Skeleton> > getRefinementLevel(//const BundleSlot&SpaceTime, 
                                                                  const RefPtr<ValuePool>&VP, 
                                                                  int L, int IndexDepth = 0) const;
#endif
#if 0
private:
        bool    updateGridSelection(const BundleSlot&SpaceTime,
                                    const RefPtr<ValuePool>&VP) const;


        bool    updateFieldSelection(const TypedSlot<VStringList>&FieldSelection,
                                     const Fiber::TypeList_t*TypeList,
                                     const BundleSlot&SpaceTime,
                                     const RefPtr<ValuePool>&VP) const;
public:

        bool    updateGridSelection(const RefPtr<ValuePool>&VP) const
        {
                return updateGridSelection(GridSpacetimeSlot(), VP);
        }


        bool    updateFieldSelection(const TypedSlot<VStringList>&FieldSelection,
                                     const Fiber::TypeList_t*TypeList,
                                     const RefPtr<ValuePool>&VP) const
        {
                return updateFieldSelection(FieldSelection,
                                            TypeList,
                                            GridSpacetimeSlot(), VP);
        }

        struct  fishbone_API GridInspector
        {
                virtual bool operator()(const Fiber::GridID&id, const Fiber::Grid&G) const = 0;
                virtual ~GridInspector();
        };

        virtual bool provides(const GridInspector&GI) const;

static  RefPtr<VAcceptInfo> acceptGrid(const RefPtr<VObject>&vobj, const GridInspector&GI);
#endif

};

} // namespace Wizt

#endif /* __FISH_BONE_GRID_HPP */