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 <fiber/field/Field.hpp>
#include <memcore/TypeInfo.hpp>
#include <memcore/Ageable.hpp>
#include <memcore/shared_mutex.hpp>
 
#include <functional>
#include <set>
#include <list>
 
#include <fiber/field/BaseSpace.hpp>
 
namespace Fiber
{
        using MemCore::WeakPtr;
        using MemCore::NullPtr;
        using std::set;
        using std::list;
 
template <class ID>
class   FiberMap : public BaseSpaceDependency, public MemCore::Ageable
{
        using   Fields_t = map<ID, RefPtr<Field> >;
        Fields_t Fields;
 
        mutable MemCore::shared_mutex   fields_mutex;
 
        using   LOCK_RO = std::shared_lock<MemCore::shared_mutex>;
        using   LOCK_WR = std::unique_lock<MemCore::shared_mutex>;
 
protected:
        RefPtr<Field>&create_entry(const ID&id)
        {
        LOCK_WR lk(fields_mutex);
 
        typename Fields_t::const_iterator f = Fields.find(id);
                if (f==Fields.end() )
                {
                        touch();
                }
                return Fields[ id ];
        }
 
 
        Fields_t copy_Fields_map() const
        {
        LOCK_RO lk(fields_mutex);
                return  Fields;
        }
 
public:
 
        RefPtr<FragmentIDCollection> getFragmentIDCollection() const
        {
        LOCK_RO lk(fields_mutex);
                for(typename Fields_t::const_iterator f = Fields.begin();
                    f!=Fields.end(); f++)
                {
                        if (const RefPtr<Field>&F = f->second)
                        {
                                if (const RefPtr<FragmentIDCollection>&
                                    FID = F-> getFragmentIDCollection())
                                {
                                        return FID;
                                }
                        }
                }
                return  nullptr;
        }
 
 
        FiberMap()
        {}
 
 
        size_t  getNumberOfFields() const
        {
        LOCK_RO lk(fields_mutex);
                return Fields.size();
        }
 
 
        Field&operator[](const ID&id)
        {
        LOCK_WR lk(fields_mutex);
 
        typename Fields_t::const_iterator f = Fields.find(id);
                if (f==Fields.end() )
                {
                        touch();
                }
 
        RefPtr<FragmentIDCollection> FIC = getFragmentIDCollection();
 
        RefPtr<Field>&F = Fields[ id ];
                if (!F) F = new Field(FIC);
 
                return *F;
        }
 
        void    mkFieldID(const ID&id)
        {
        LOCK_WR lk(fields_mutex);
                touch();
                Fields[ id ] = nullptr;
        }
 
        void    insertField(const ID&id, const RefPtr<Field>&F)
        {
        LOCK_WR lk(fields_mutex);
 
        typename Fields_t::const_iterator f = Fields.find(id);
                if (f!=Fields.end() )
                {
                        if (f->second == F)
                                return;
                }
 
                touch();
                Fields[ id ] = F;
        }
 
        const RefPtr<Field>&find(const ID&id) const
        {
        LOCK_RO lk(fields_mutex);
 
        typename Fields_t::const_iterator f = Fields.find(id);
                if (f==Fields.end() )
                        return  Field::NullPtrField();
 
                return f->second;
        }
 
        RefPtr<CreativeArrayBase> find(const ID&id, const RefPtr<FragmentID>&f) const
        {
        const RefPtr<Field>&F = find(id);
                if (F)
                        return F->getCreator(f);
 
                return nullptr;
        }
 
        RefPtr<CreativeArrayBase> find(const ID&id, const string&FragmentName) const
        {
        const RefPtr<Field>&F = find(id);
                if (F)
                        return F->getCreatorByName(FragmentName);
 
                return nullptr;
        }
 
        const RefPtr<Field>&operator()(const ID&id) const
        {
                return find(id);
        }
 
        void    iterate(const std::function<bool(const ID&, const RefPtr<Field>&)>&F) const
        {
        LOCK_RO lk(fields_mutex);
 
                for(const auto&[id,f] : Fields)
                {
                        if (!F(id,f))
                                return;
                }
        }
 
 
        bool    remove(const ID&id)
        {
        LOCK_WR lk(fields_mutex);
 
        typename Fields_t::const_iterator f = Fields.find(id);
                if (f==Fields.end() )
                        return false;
 
                Fields.erase(f);
                touch();
                return true;
        }
 
        void    getMinMaxAge(Ageable&Youngest, Ageable&Oldest) const
        {
                Youngest = *this;
                Oldest   = *this;
 
        LOCK_RO lk(fields_mutex);
                for(typename Fields_t::const_iterator f = Fields.begin();
                    f!=Fields.end(); f++)
                {
                        if (f->second->isYoungerThan( Youngest) ) Youngest = *f->second;
                        if (f->second->isOlderThan  ( Oldest  ) ) Oldest   = *f->second;
                }
        }
 
 
        RefPtr<Field>   findMostFragmentedField() const
        {
                if (Fields.size()<1)
                        return  nullptr;
 
                LOCK_RO lk(fields_mutex);
        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
        {
        LOCK_RO lk(fields_mutex);
        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;
        }
 
 
        int     providesFieldType(const Fiber::TypeList_t&AcceptedFields) const
        {
        LOCK_RO lk(fields_mutex);
        int     n = 0;
                for(typename Fields_t::const_iterator it = Fields.begin(); it != Fields.end(); it++)
                {
                RefPtr<Field> F = it->second;
                        if (!F)
                                continue;
 
                        if (F->isType( AcceptedFields ) )
                                n++;
                }
                return n;
        }
 
        string  xml() const
        {
        string  retval;
 
                retval = "       <FIBERSPACE>\n";
 
        LOCK_RO lk(fields_mutex);
                for(typename Fields_t::const_iterator
                            it = Fields.begin(); it != Fields.end(); it++)
                {
                        retval += "        <FIELD>\n";
                        if (it->first)
                        {
                                retval += it->first->xml();
                                if (const RefPtr<Field>&F = it->second)
                                {
                                        retval += F->xml();
                                }
                        }
                        else
                                retval += "          <?INVALID>\n";
                        retval += "        </FIELD>\n";
                }
                retval += "       </FIBERSPACE>\n";
                return retval;
        }
 
 
        void    clear_fields()
        {
        LOCK_WR lk(fields_mutex);
 
                for(auto Fit : Fields)
                {
                        if (const RefPtr<Field>&F = Fit.second)
                                F->clear();
                }
 
                //
                // it's important to clear and destruct the fields first
                // because they might require the myFieldCreator while destructing.
                // without explicit clearance this myFieldCreator would be destructed
                // first and the fields were missing this creator.
                //
                Fields.clear();
        }
 
 
        const RefPtr<Field>&getFirstField() const
        {
        LOCK_RO lk(fields_mutex);
 
                if( Fields.empty() )
                        return  Field::NullPtrField();
 
                return  Fields.begin()->second;
        }
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRID_FIBER_HPP */