FiberTypeMap.hpp

#ifndef FIBERTYPEMAP_HPP
#define FIBERTYPEMAP_HPP "Created 20.06.2020 12:20:27 by werner"
 
#include "FiberTypeBase.hpp"
 
#include <memcore/RefPtr.hpp>
#include <map>
#include <ranges>
 
#include "FieldAPI.h"
 
namespace Fiber
{
 
template <class TypeProperty>
struct  FiberTypeMap : std::map<FiberTypeIndex, MemCore::RefPtr<TypeProperty>>
{
        using base_t = std::map<FiberTypeIndex, MemCore::RefPtr<TypeProperty>>;
 
        bool    insert(const MemCore::RefPtr<FiberTypeBase>&Index,
                       const MemCore::RefPtr<TypeProperty>&Property)
        {
                if (!Index) return false;
 
                (*this)[ Index->getFiberTypeIndex() ] = Property;
                return true;
        }
 
        MemCore::RefPtr<TypeProperty>
                find(const FiberTypeIndex&FTI) const
        {
        auto    f = base_t::find(FTI);
                if (f == this->end())
                        return nullptr;
 
                return f->second;
        }
 
        MemCore::RefPtr<TypeProperty>
                find(const MemCore::RefPtr<FiberTypeBase>&FTB) const
        {
                if (!FTB)
                        return nullptr;
 
                return find(FTB->getFiberTypeIndex());
        }
 
 
static  FiberTypeMap&theMap()
        {
        static  FiberTypeMap myMap;
                return myMap;
        }
 
static  bool    remember(const MemCore::RefPtr<FiberTypeBase>&Index,
                         const MemCore::RefPtr<TypeProperty>&Property)
        {
                return theMap().insert( Index, Property );
        }
 
static  MemCore::RefPtr<TypeProperty>
                get(const MemCore::RefPtr<FiberTypeBase>&FTB)
        {
                return theMap().find(FTB);
        }
};
 
 
template <class TypeProperty>
struct  FiberTypeMultiMap : std::multimap<FiberTypeIndex, MemCore::RefPtr<TypeProperty>>
{
        using base_t = std::multimap<FiberTypeIndex, MemCore::RefPtr<TypeProperty>>;
 
        bool    insert(const MemCore::RefPtr<FiberTypeBase>&Index,
                       const MemCore::RefPtr<TypeProperty>&Property)
        {
                if (!Index) return false;
 
                (*this).emplace( Index->getFiberTypeIndex(), Property);
                return true;
        }
 
        template <typename I>
        struct iter_pair : std::pair<I, I>
        {
                using std::pair<I, I>::pair;
 
                I begin() { return this->first; }
                I end() { return this->second; }
        };
 
 
//      iter_pair<typename base_t::const_iterator>
        auto    find(const FiberTypeIndex&FTI) const
        {
                return base_t::equal_range(FTI);
        }
 
 
        auto    find(const MemCore::RefPtr<FiberTypeBase>&FTB) const
        {
                if (!FTB)
                        return nullptr;
 
                return find(FTB->getFiberTypeIndex());
        }
 
 
static  FiberTypeMultiMap&theMap()
        {
        static  FiberTypeMultiMap myMap;
                return myMap;
        }
 
static  bool    remember(const MemCore::RefPtr<FiberTypeBase>&Index,
                         const MemCore::RefPtr<TypeProperty>&Property)
        {
                return theMap().insert( Index, Property );
        }
 
static  MemCore::RefPtr<TypeProperty>
                get(const FiberTypeIndex&FTI)
        {
        auto    [a,b] = theMap().find(FTI);
#if 1
                for(auto r = a; r !=b; r++ )
#else
                for(auto r : std::ranges::iota_view(a,b) )
#endif
                {
                        if (r->second)
                                return r->second;
                }
                return nullptr;
        }
 
static  MemCore::RefPtr<TypeProperty>
                get(const MemCore::RefPtr<FiberTypeBase>&FTB)
        {
        auto    R = theMap().find(FTB);
                for(auto r : R)
                {
                        if (r.second)
                                return r.second;
                }
                return nullptr;
        }
};
 
 
} /* namespace Fiber */
 
#endif /* FIBERTYPEMAP_HPP */