FiberSpace.hpp

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

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

#include "BaseSpace.hpp"

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

template <class ID>
class   GRID_API FiberSpace : public BaseSpaceDependency
{
protected:
        typedef map<ID, RefPtr<Field> > Fields_t;
        Fields_t Fields;

        RefPtr<Field>&create_entry(const ID&id)
        {
                return Fields[ id ];
        }

public: 
        FiberSpace()
        {} 

        Field&operator[](const ID&id)
        {
        RefPtr<Field>&F = Fields[ id ];
                if (!F)
                        F = new Field();
                return *F;
        } 

        RefPtr<Field> find(const ID&id) const
        {
        typename Fields_t::const_iterator f = Fields.find(id);
                if (f==Fields.end() )
                        return NullPtr();
                return f->second;
        } 

        RefPtr<Field> operator()(const ID&id) const
        {
                return find(id);
        } 

        RefPtr<Field>   findMostFragmentedField() const
        {
                if (Fields.size()<1)
                        return NullPtr();

        typename Fields_t::const_iterator it = Fields.begin();
        RefPtr<Field>   result = it->second;

                if (!result) // no field stored? bad. we are screwed.
                        return NullPtr(); 

        size_t  MaxFragmentsSoFar = result -> nFragments();
                for(; it != Fields.end(); it++)
                {
                RefPtr<Field> candidate = it->second; 
                        if (!candidate)
                                continue; 

                size_t  fragments =  candidate->nFragments(); 
                        if (fragments > MaxFragmentsSoFar)
                        {
                                MaxFragmentsSoFar = fragments; 
                                result = candidate;
                        }
                } 
                return result;
        } 

        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const
        {
        int     n = 0;  
                for(typename Fields_t::const_iterator it = Fields.begin(); it != Fields.end(); it++)
                {
                RefPtr<Field> F = it->second; 
                        if (!F)
                                continue; 

                        n += F->getMemoryUsage(UsedMemory, WantedMemory);
                } 
                return n;
        }

};


} /* namespace Fiber */ 

#endif /* __FIBER_GRID_FIBER_HPP */