FragmentIDCollection.hpp

#ifndef __FIBER_FIELD_FRAGMENTIDCOLLECTION_HPP
#define __FIBER_FIELD_FRAGMENTIDCOLLECTION_HPP
 
#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <unordered_map>
#include <vector>
#include "FragmentID.hpp"
#include "DynamicSize.hpp"
 
namespace Fiber
{
 
class   FIELD_API FragmentIDCollection : public ReferenceBase<FragmentIDCollection>
{
public:
        using FragmentNames_t = std::unordered_map< std::string, FragmentIndex_t>;
        using FragmentIDs_t = std::vector<RefPtr<FragmentID> >;
 
private:
        FragmentNames_t FragmentNames;
        RefPtr<Chunk<RefPtr<FragmentID> >> myFragmentIDs;
 
        DynamicSize     myFragmentLayout;
 
        FragmentIDs_t   &FragmentIDs() const
        {
                return myFragmentIDs->get_vector();
        }
 
        template <Dims_t DIMS>
        void    setFragmentNames(const MultiIndex<DIMS>&NumberOfFragments, const string&FragmentNamePrefix)
        {
                myFragmentIDs = new Chunk<RefPtr<FragmentID>>( NumberOfFragments.size() );
 
                for(MultiIndex<DIMS> FragNumber : NumberOfFragments)
                {
                string  FragmentName = FragmentNamePrefix + std::to_string( FragNumber );
                index_t FragmentIndex = FragNumber.linear( NumberOfFragments );
 
                        FragmentIDs()[ FragmentIndex ] = new FragmentID(FragmentName, int(FragmentIndex), self() );
                        FragmentNames[ FragmentName ] = FragmentIndex;
                }
        }
 
protected:
        virtual ~FragmentIDCollection();
 
public:
        FragmentIDCollection();
 
        FragmentIDCollection(const RefPtr<TypedArray<string>>&FragmentNameArray);
 
        RefPtr<TypedArray<RefPtr<FragmentID>>> getFragmentIDArray() const;
 
        const FragmentIDs_t     &getFragmentIDs() const
        {
                Assert( myFragmentIDs );
                return myFragmentIDs->get_vector();
        }
 
        RefPtr<FragmentID> findFragmentID(FragmentIndex_t) const;
 
        FragmentIndex_t getID(const RefPtr<FragmentID>&fID);
 
        FragmentIndex_t findID(const RefPtr<FragmentID>&fID) const;
 
        RefPtr<FragmentID>      findFragmentIDByName(const string&Name) const;
 
        size_t  NumberOfFragmentIDs() const
        {
                return getFragmentIDs().size();
        }
 
        const DynamicSize&getFragmentLayout() const
        {
                return myFragmentLayout;
        }
 
        bool    isDense() const
        {
                if (!myFragmentLayout.isValid()) return false;
 
                return myFragmentLayout.getNumberOfElements() == NumberOfFragmentIDs();
        }
 
        template <Dims_t DIMS>
        bool    setFragmentLayout(const MultiIndex<DIMS>&NumberOfFragments, const string&FragmentNamePrefix)
        {
                if (myFragmentLayout.isValid()) return false; // already have a fragment layout
                if (NumberOfFragmentIDs()>0)    return false; // not a virgin FragmentIDCollection
 
                myFragmentLayout.resize(NumberOfFragments);
 
                setFragmentNames(NumberOfFragments, FragmentNamePrefix);
 
                return true;
        }
 
        template <Dims_t DIMS>
        FragmentIDCollection(const MultiIndex<DIMS>&NumberOfFragments, const string&FragmentNamePrefix)
        : ReferenceBase<FragmentIDCollection>(this)
        , myFragmentLayout( NumberOfFragments )
        {
                setFragmentNames(NumberOfFragments, FragmentNamePrefix);
        }
 
        RefPtr<FragmentID>&     makeFragmentID(const string&Name);
        FragmentIndex_t         findNumericalIDByName(const string&Name) const;
 
        string  xml() const;
 
        unsigned iterate(const std::function<bool(const RefPtr<FragmentID>&, int, const std::string&)>&F) const;
};
 
 
class   FIELD_API FragmentIDCollectionProvider
{
public:
        ~FragmentIDCollectionProvider();
 
        virtual RefPtr<FragmentIDCollection> getFragmentIDCollection() const = 0;
};
 
 
} // namespace Fiber
 
#endif // __FIBER_FIELD_FRAGMENTIDCOLLECTION_HPP