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;

        FieldSelection&Selection();

        FieldSelector(); 

        FieldSelector(const GridSelector&GS, const Info<Grid>&FieldSource); 

        FieldSelector(const FieldSelector&FS);

        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    requires(const type_info&what) const
        {
                if (!MySelectedFields)
                        return true;

                return MySelectedFields->requires(what);
        } 

        unsigned NumberOfAvailableFields() const;

        TypeList_t&FieldTypes()
        {
                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() );

        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>  createFieldID(Fiber::Representation&Rep) const
        {
                return Rep.createFieldID( 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 RefPtr<Fiber::Slice>&getSlice() const
        {
                return FieldSource.getSlice();
        }

        double getTime() const
        {
                return FieldSource.getTime();
        } 

        RefPtr<Field> getField(const string&theName) const;

        RefPtr<Fiber::Field> getField() const
        {
                return getField( getFieldName() );
        } 

        RefPtr<Field> getCartesianPositions() const; 

        RefPtr<Representation> getCartesianRepresentation() const;
};



} /* namespace Fiber */ 

#endif /* __FIBER_FIELDSELECTOR_HPP */