FieldSelector.hpp

#ifndef __FIBER_FIELDSELECTOR_HPP
#define __FIBER_FIELDSELECTOR_HPP
 
#include "BundleAPI.h"
#include <grid/Grid.hpp>
#include "GridSelector.hpp"
#include "FieldSelection.hpp"
 
namespace Fiber
{
 
class   BUNDLE_API FieldSelector : public GridSelector
{
        RefPtr<FieldSelection>  MySelectedFields;
 
public:
 
        Info<Grid>      FieldSource;
 
        SkeletonID      mySkeletonID;
 
        FieldSelection&Selection();
 
        RefPtr<FieldSelection>  getSelectedFields() const
        {
                return MySelectedFields;
        }
 
        const FieldSelection&Selection() const;
 
        FieldSelector();
 
        FieldSelector(const GridSelector&GS, const Info<Grid>&FieldSource);
 
        FieldSelector(const FieldSelector&FS);
 
        FieldSelector(const FieldSelector&FS, const string&fieldname, const TypeList_t&FT = TypeList_t() );
 
        FieldSelector(const BundlePtr&bpP, const double timeP, const string& gridNameP, const string& fieldNameP);
 
        FieldSelector(double&time, const BundlePtr&BP, const string& gridName, const string&fieldName);
 
        ~FieldSelector();
 
        bool    requiresType(const type_info&what) const
        {
                if (!MySelectedFields)
                        return true;
 
                return MySelectedFields->requiresType(what);
        }
 
        unsigned NumberOfAvailableFields() const;
 
        TypeList_t&FieldTypes()
        {
                return Selection().FieldTypes();
        }
 
        const TypeList_t&FieldTypes() const
        {
                return Selection().FieldTypes();
        }
 
        template <class ...T>
        void    accept()
        {
                AcceptType<T...>::accept( FieldTypes() );
 
//              return Selection().setFieldType( Selection().getFieldName(), FiberType<T>::getFiberType(), append );
//              SelectedFields().setType<T>(true);
//              Fiber::AcceptType<T>::accept( AcceptableFieldTypes );
        }
 
        friend BUNDLE_API bool operator==(const FieldSelector&L, const FieldSelector&R);
 
        friend bool operator!=(const FieldSelector&L, const FieldSelector&R)
        {
                return  !(L==R);
        }
 
        void    selectField(const string&fieldname, const TypeList_t&FT = TypeList_t() );
 
        template <class T>
                void    selectTypedField(const string&fieldname)
        {
                selectField( fieldname, Fiber::TypeList( FiberType<T>::getFiberType() ) );
        }
 
        void    selectField(const string&fieldname, const Field&F)
        {
                if (WeakPtr<FiberTypeBase> FTB = F.getElementFiberType() )
                        selectField( fieldname, FTB );
                else
                        selectField( fieldname );
        }
 
        FieldSelector operator()(const string&fieldname, const Field&F) const
        {
                if (WeakPtr<FiberTypeBase> FTB = F.getElementFiberType() )
                        return FieldSelector(*this, fieldname, FTB);
 
                return FieldSelector(*this, fieldname);
        }
 
        void selectField(const BundlePtr&BP, const double time, const string& gridName, const string&fieldName,
                         const RefPtr<Grid>&G, const RefPtr<Slice>&S)
        {
                selectField( fieldName );
                FieldSource = Info<Grid>( time, S, G);
                selectGrid(gridName);
                theSourceBundle = BP;
        }
 
        void clearSelection();
 
        RefPtr<Fiber::FieldID>  makeFieldID(Fiber::Representation&Rep) const
        {
                return Rep.makeFieldID( getFieldName() );
        }
 
        bool    setFieldSource(double time, const string&theFieldname);
 
        bool    findFieldSource(double time, const string&Fieldname);
 
        bool    findFieldSource(const BundlePtr&bpP, double timeP, const string& gridNameP, const string&fieldNameP);
 
        string  getFieldName() const;
 
        string  getFieldname() const
        {
                return getFieldName();
        }
 
        string  operator()() const
        {
                return getFieldName();
        }
 
        typedef std::pair<Fiber::Bundle::GridInfo_t, RefPtr<Fiber::Field> > FieldInfo_t;
 
        const RefPtr<Fiber::Grid>&GridSource() const
        {
                return FieldSource.getGrid();
        }
 
        const RefPtr<Fiber::Grid>&getGrid() const
        {
                return FieldSource.getGrid();
        }
 
        const WeakPtrSlice&getSlice() const
        {
                return FieldSource.getSlice();
        }
 
        double getTime() const
        {
                return FieldSource.getTime();
        }
 
        RefPtr<Field> getField(const string&theName, int Level=0, const string&ChartName = string()) const;
 
        RefPtr<Fiber::Field> getField(int Level=0, const string&ChartName = string()) const
        {
                return getField( getFieldName(), Level );
        }
 
        RefPtr<Field> getPositions(const RefPtr<ChartID>&theChartID) const;
 
        RefPtr<Field> getField(const RefPtr<ChartID>&theChartID, const string&fieldname) const;
 
        RefPtr<Field> getField(const RefPtr<ChartID>&theChartID) const
        {
                return getField( theChartID, getFieldName() );
        }
 
        RefPtr<Field> getCartesianPositions() const;
 
        RefPtr<Representation> getCartesianRepresentation(int Level=0) const;
 
        bool    operator!() const;
 
        operator bool() const
        {
                return !!*this;
        }
};
 
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_FIELDSELECTOR_HPP */