RegularlyFragmentedField.hpp

#ifndef __FIBER_REGULARLY_FRAGMENTED_FIELD_HPP
#define __FIBER_REGULARLY_FRAGMENTED_FIELD_HPP
 
#include <sstream>
#include "Field.hpp"
#include "DynamicSize.hpp"
 
namespace Fiber
{
 
template <Dims_t DIMS=3>
class   RegularlyFragmentedField : public Field
{
 
        const MultiIndex<DIMS>  myNumberOfFragments;
 
#if     0
        void    createFragmentIndices(const string&FragmentNamePrefix)
        {
                for(MultiIndex<DIMS> FragNumber : myNumberOfFragments)
                {
                string fragmentname = FragmentNamePrefix + std::to_string( FragNumber );
 
                        Verbose(50) << "  Creating fragment " << fragmentname
                                    << " with linear index "
                                    << int(FragNumber.linear( myNumberOfFragments ));
 
                RefPtr<FragmentID>&NewFragmentID = this->makeFragmentID( fragmentname );
                        assert( NewFragmentID );
 
                        if ( int(FragNumber.linear( myNumberOfFragments ) ) !=
                             NewFragmentID->getNumericalID() )
                        {
                                Verbose(0) << " Multidimensional fragment index "
                                           << FragNumber.linear( myNumberOfFragments )
                                           << " does not match  numerical fragment ID"
                                           << NewFragmentID->getNumericalID();
//                              MemCore::breakpoint();
                        }
                }
        }
#endif
 
public:
 
        using Field::operator();
        using Field::operator[];
 
        RegularlyFragmentedField(const MultiIndex<DIMS>&FragmentNumbers, const string&FragmentNamePrefix = "RegularFragment")
        : Field( FragmentNumbers, FragmentNamePrefix)
        , myNumberOfFragments( FragmentNumbers )
        {
                Assert( this->getFragmentIDCollection() );
//              Assert( this->getFragmentIDCollection()->getFragmentLayout().isValid() );
                if (! this->getFragmentIDCollection()->getFragmentLayout().isValid() )
                {
                        AppVerbose("FiberLib", 0) << "Newly constructed RegularlyFragmentedField("<<FragmentNumbers<<", " << FragmentNamePrefix << ") got no fragment layout!?";
                }
        }
 
protected:
        ~RegularlyFragmentedField()
        {}
 
private:
 
        RegularlyFragmentedField(const MultiIndex<DIMS>&FragmentNumbers,
                                 const WeakPtr<Field>&SimilarField,
                                 const string&FragmentNamePrefix)
        : Field( SimilarField )
        , myNumberOfFragments( FragmentNumbers )
        {
                if (!SimilarField)
                {
                        if (!setFragmentLayout( FragmentNumbers, FragmentNamePrefix))
                        {
                                Assert(false && "cannot set fragment layout of virginal field!?");
                        }
                }
        }
 
        RegularlyFragmentedField(const MultiIndex<DIMS>&FragmentNumbers,
                                 const RefPtr<FragmentIDCollection>&theFragmentIDCollection,
                                 const string&FragmentNamePrefix)
        : Field(theFragmentIDCollection)
        , myNumberOfFragments( FragmentNumbers )
        {
                if (!theFragmentIDCollection)
                        if (!setFragmentLayout( FragmentNumbers, FragmentNamePrefix))
                        {
                                Assert(false && "cannot set fragment layout of virginal field!?");
                        }
        }
 
public:
 
        const MultiIndex<DIMS>&getNumberOfFragments() const
        {
                return myNumberOfFragments;
        }
 
 
static  RefPtr<RegularlyFragmentedField>
        newField(const MultiIndex<DIMS>&FragmentNumbers,
                 const WeakPtr<Field>&SimilarField,
                 const string&FragmentNamePrefix = "RegularFragment")
        {
                if (SimilarField)
                {
                        if (SimilarField->nFragments()
                            !=  FragmentNumbers.size() )
                        {
                                return NullPtr();
                        }
 
                const RefPtr<FragmentIDCollection>&FC = SimilarField->getFragmentIDCollection();
                        if (!FC)
                                return  nullptr;
 
                        if (FragmentNumbers.size()
                            != FC->NumberOfFragmentIDs() )
                                return  nullptr;
                }
 
                return new RegularlyFragmentedField(FragmentNumbers, SimilarField, FragmentNamePrefix);
        }
 
static  RefPtr<RegularlyFragmentedField>
        newField(const MultiIndex<DIMS>&FragmentNumbers,
                 const RefPtr<FragmentIDCollection>&theFragmentIDCollection,
                 const string&FragmentNamePrefix = "RegularFragment")
        {
                if (!theFragmentIDCollection)
                        return  nullptr;
 
                if (theFragmentIDCollection->NumberOfFragmentIDs()
                    !=  FragmentNumbers.size() )
                {
                        return  nullptr;
                }
 
                return new RegularlyFragmentedField(FragmentNumbers, theFragmentIDCollection, FragmentNamePrefix);
        }
 
 
 
        RegularlyFragmentedField(const RegularlyFragmentedField&RFF)
        : Field(RFF.getFragmentIDCollection() )
        , myNumberOfFragments( RFF.myNumberOfFragments )
        {}
 
 
        bool    validate(const MultiIndex<DIMS>&I) const
        {
        index_t FragNumber = I.linear( myNumberOfFragments );
                return Field::validate( int( FragNumber ) );
        }
 
        RefPtr<FragmentID> getFragmentID(const MultiIndex<DIMS>&I) const
        {
        const RefPtr<FragmentIDCollection>&FC = getFragmentIDCollection();
                if (!FC)
                        return NullPtr();
 
                for (Dims_t i = 0; i < DIMS; i++)
                        if (I[i] >= myNumberOfFragments[i])
                                return NullPtr();
 
 
        index_t FragNumber = I.linear( myNumberOfFragments );
 
                return FC->findFragmentID( int(FragNumber) );
        }
 
              RefPtr<CreativeArrayBase>&operator[](const MultiIndex<DIMS>&I)
        {
        index_t FragNumber = I.linear( myNumberOfFragments );
                return  getCreatorReferenceViaFragmentIndex( FragNumber );
 
/*
        std::lock_guard lock(fragment_mutex);
                return this->fragments[ FragNumber ];
*/
        }
 
        RefPtr<CreativeArrayBase> operator()(const MultiIndex<DIMS>&I) const
        {
        index_t FragNumber = I.linear( myNumberOfFragments );
                return  getCreatorByNumericalID( FragNumber );
 
//      std::lock_guard lock(fragment_mutex);
//              return this->fragments ( int( FragNumber ) );
        }
 
#if     0
        RefPtr<MemArray<DIMS, RefPtr<FragmentID> > >
                newRegularFragmentationArray() const
        {
        RefPtr<MemArray<DIMS, RefPtr<FragmentID> > >
                FragmentIDs   = new MemArray<DIMS, RefPtr<FragmentID> >(myNumberOfFragments);
        MultiArray<DIMS, RefPtr<FragmentID> >
                Fids = *FragmentIDs;
 
                for(MultiIndex<DIMS> FragmentIndex : myNumberOfFragments)
                {
                        Fids[ FragmentIndex ] = this->getFragmentID( FragmentIndex );
                }
 
                return FragmentIDs;
        }
 
 
        RefPtr<MemBase> newFragmentationArray() const override
        {
                return newRegularFragmentationArray();
        }
#endif
 
        string  xml() const
        {
                return  "<REGULARLYFRAGMENTIONDIMENSIONS>" + std::to_string(int(DIMS)) +
                        "</REGULARLYFRAGMENTIONDIMENSIONS>\n"
                        +
                        Field::xml();
        }
};
 
 
 
//extern template class RegularlyFragmentedField<3>;
 
 
extern FIELD_API RefPtr<Field> newRegularlyFragmentedField(const DynamicSize&Sz);
 
} // namespace Fiber
 
#endif // _REGULARLY_FRAGMENTED_FIELD_HPP