GridSelector.hpp

#ifndef __FIBER_GRIDSELECTOR_HPP
#define __FIBER_GRIDSELECTOR_HPP
 
#include "BundleAPI.h"
#include "Bundle.hpp"
 
namespace Fiber
{
 
class              BundleProperty;
class   BUNDLE_API GridSelector;
 
extern  BUNDLE_API bool hasProperty(const GridSelector&, const BundleProperty&);
 
 
class   BUNDLE_API GridSelector
{
public:
        BundlePtr               theSourceBundle;
 
        string                  theGridname;
 
        const string&getGridname() const { return theGridname; }
        const string&getGridName() const { return theGridname; }
 
        GridSelector();
 
        GridSelector(const string&gridname, const Fiber::BundlePtr&Source = Fiber::BundlePtr(NullPtr() ) )
        : theSourceBundle(Source)
        , theGridname(gridname)
        {}
 
        GridSelector(const Fiber::BundlePtr&Source, const string&gridname)
        : theSourceBundle(Source)
        , theGridname(gridname)
        {}
 
        GridSelector(const GridSelector&Source, const string&gridname)
        : theSourceBundle(Source.theSourceBundle)
        , theGridname(gridname)
        {}
 
        GridSelector(const string&gridname, const GridSelector&Source)
        : theSourceBundle(Source.theSourceBundle)
        , theGridname(gridname)
        {}
 
        ~GridSelector();
 
        GridSelector operator[](const string&gridname) const
        {
                return GridSelector(*this,gridname);
        }
 
        friend bool operator==(const GridSelector&L, const GridSelector&R)
        {
                return  L.theSourceBundle == R.theSourceBundle &&
                        L.theGridname == R.theGridname;
        }
 
        friend bool operator!=(const GridSelector&L, const GridSelector&R)
        {
                return  !(L==R);
        }
 
        const string&Gridname() const
        {
                return theGridname;
        }
 
        const Fiber::BundlePtr&BundleSource() const
        {
                return theSourceBundle;
        }
 
        const Fiber::BundlePtr&getBundle() const
        {
                return theSourceBundle;
        }
 
 
        bool hasValidGrid() const
        {
                return theSourceBundle && theGridname.length()>0;
        }
 
        operator bool() const
        {
                return hasValidGrid();
        }
 
        bool selectGrid(const string&name)
        {
                theGridname = name;
                return true;
 
                /*
                if (!theSpacetime)
                        return false;
 
                theGridID = (*theSpacetime)[ name ];
                return theGridID.valid();
                */
        }
 
        Info<Grid> findMostRecentGrid(const Fiber::BundlePtr&theSpacetime, double time) const
        {
                if (!theSpacetime)
                        return Info<Grid>();
 
                return  theSpacetime->findMostRecentGrid(time, theGridname);
        }
 
        Info<Grid>      findMostRecentGrid(double time,
                                           const Fiber::BundlePtr&theSpacetime = Fiber::BundlePtr(NullPtr() ) ) const
        {
                if (!theSpacetime)
                {
                        if (!theSourceBundle)
                                return Info<Grid>();
                        else
                                return theSourceBundle->findMostRecentGrid(time, theGridname);
                }
 
                return  theSpacetime->findMostRecentGrid(time, theGridname);
        }
 
        Info<Skeleton> getRefinementLevel(double time,
                                          int Level, int IndexDepth,
                                          const BundlePtr&SpaceTime = BundlePtr(NullPtr() ) );
 
        Info<Grid> findPrev(double time, const BundlePtr&theSpacetime = BundlePtr(NullPtr()) ) const
        {
                if (!theSpacetime)
                {
                        if (!theSourceBundle)
                                return Info<Grid>();
                        else
                                theSourceBundle->findPrev(time, theGridname);
                }
 
                return theSpacetime->findPrev(time, theGridname);
        }
 
        Info<Grid> findNext(double time, const BundlePtr&theSpacetime = BundlePtr(NullPtr() ) ) const
        {
                if (!theSpacetime)
                {
                        if (!theSourceBundle)
                                return Info<Grid>();
                        else
                                theSourceBundle->findNext(time, theGridname);
                }
 
                return theSpacetime->findNext(time, theGridname);
        }
 
        Fiber::Grid&operator[](double time)
        {
                return theSourceBundle[time][ Gridname() ];
        }
 
        RefPtr<Fiber::Grid> operator()(double time,
                                       const Fiber::BundlePtr&theSpacetime = Fiber::BundlePtr(NullPtr() )) const
        {
        Fiber::Bundle::GridInfo_t G = findMostRecentGrid(time, theSpacetime);
                return G.getGrid();
        }
 
        RefPtr<Fiber::Grid> operator()(double time, const GridSelector&GS)
        {
        Fiber::Bundle::GridInfo_t G = findMostRecentGrid(time, GS.theSourceBundle);
                return G.getGrid();
        }
 
        bool    hasProperty(const BundleProperty&theProperty) const
        {
                return ::Fiber::hasProperty(*this, theProperty);
        }
 
 
        bool    providesFieldTypes(const Fiber::TypeList_t&AcceptedFields) const;
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRIDSELECTOR_HPP */