Representation.hpp

#ifndef __FIBER_GRID_REPRESENTATION_HPP
#define __FIBER_GRID_REPRESENTATION_HPP "Created 27.02.2001 21:42:27 by werner"

#include "GridAPI.h"
#include <field/Field.hpp>
#include "FieldID.hpp"
#include <memcore/TypeInfo.hpp>
#include <set>
#include <list>
#include "FiberSpace.hpp"
#include "BaseSpace.hpp"
#include "RepresentationMap.hpp"

namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
        using std::set;
        using std::list;

#define FIBER_POSITIONS "Positions"

class   GRID_API Representation : public FiberSpace<RefPtr<FieldID> >, public RepresentationMap
{
public: typedef FiberSpace<RefPtr<FieldID> > Base_t;
        using FiberSpace<RefPtr<FieldID> >::operator[];
        using FiberSpace<RefPtr<FieldID> >::operator();

        using RepresentationMap::operator[]; 
        using RepresentationMap::makeRepresentation; 
        using RepresentationMap::operator(); 

        RefPtr<FieldID> createFieldID(const string&name);

        RefPtr<FieldID> findFieldID(const string&name) const;


        RefPtr<FieldID> insertSharedFieldID(const Representation&R, const string&name); 

        RefPtr<FieldID> createSharedFieldID(Representation&Carrier, const string&name);


        RefPtr<Field>   &getField(const RefPtr<FieldID>&f); 

        RefPtr<Field>   findField(const RefPtr<FieldID>&f) const;

        RefPtr<Field>  &makeField(const WeakPtr<FieldID>&f);
        Field          &makeField(const FieldID&f); 

        Field        &operator[](const FieldID&f)
        {
                return makeField(f);
        } 

        RefPtr<Field>&operator[](const RefPtr<FieldID>&f)
        {
                return makeField(f);
        }

        RefPtr<Field>&operator[](const string&name)
        {
                return makeField( createFieldID(name) );
        }

        Representation&operator[](const BaseSpace&D);

        RefPtr<Field>   findField(const string&name) const
        {
        RefPtr<FieldID> fid = findFieldID(name);
                if (!fid)
                        return NullPtr();

                return (*this)( fid );  
        }

        RefPtr<Field> operator()(const string&name) const
        {
                assert(this);
                return findField( name );
        }

        RefPtr<Field>   operator()(const RefPtr<FieldID>&f) const;

        RefPtr<MemBase> operator()(const string&name, const RefPtr<FragmentID>&f)
        {
        RefPtr<Field>   F = findField(name);
                if (!F)
                        return NullPtr();

                return F->getData(f);   
        }

        RefPtr<Field>   Positions() const
        {
        RefPtr<FieldID> PositionsName = findFieldID( FIBER_POSITIONS ); 
                if (!PositionsName)
                        return NullPtr();

                return findField( PositionsName );
        }

        RefPtr<Field>   getPositions() const
        {
                return Positions();
        }


        RefPtr<SizeInterface> getSize() const
        {
        RefPtr<Field> Pos = getPositions(); 
                if (!Pos)
                        return MemCore::NullPtr(); 

                return Pos->getSize();
        }

        RefPtr<Field>&setPositions(const RefPtr<Field>&P);

        int iterate(FieldIterator&FI) const;

        int rank() const;

        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const; 


        void    Speak(int indent=0, int maxindent=-1) const;
};

} /* namespace Fiber */

#endif /* __FIBER_GRID_REPRESENTATION_HPP */