FieldSelection.hpp

#ifndef __FIBER_FIELDSELECTION_HPP
#define __FIBER_FIELDSELECTION_HPP

#include "BundleAPI.h"
#include <field/FiberType.hpp>
#include <grid/Grid.hpp>

namespace Fiber
{

class   BUNDLE_API FieldSelection : public ReferenceBase<FieldSelection>
{
        typedef std::map<string, TypeList_t> FieldSelection_t; 

        FieldSelection_t Selection;

        TypeList_t      MyFieldTypes; 

public:
        FieldSelection();

        bool    requires(const type_info&what); 

        TypeList_t&FieldTypes()
        {
                return MyFieldTypes;
        } 

        const TypeList_t&FieldTypes() const
        {
                return MyFieldTypes;
        }

        ~FieldSelection();

        friend bool operator==(const FieldSelection&L, const FieldSelection&R);

        friend bool operator!=(const FieldSelection&L, const FieldSelection&R)
        {
                return  !(L==R);
        } 

        void    setUniqueField(const string&fieldname, const  TypeList_t&FT);

        string  getFieldName() const;

        unsigned getNumberOfFields() const;

        bool setFieldType(const string&Fieldname, const FiberTypeBase&, bool append); 

        bool setFieldType(const string&Fieldname, const TypeList_t&FieldSelection);

        TypeList_t getFieldType(const string&Fieldname) const;
        TypeList_t getFieldType() const;

        template <class T>
        bool    setType(bool append=true)
        {
                return setFieldType(getFieldName(), FiberType<T>::getFiberType(), append );
        }


        template <class T>
        void setType(const string&name, bool append=true)
        {
                setFieldType(name, FiberType<T>::getFiberType(), append );
        }

        RefPtr<Representation> getFields(const Representation&R) const;

        RefPtr<Representation> getCartesianVertexFields(const Grid&G) const;
};



} /* namespace Fiber */ 

#endif /* __FIBER_FIELDSELECTION_HPP */