TypedArray.hpp

#ifndef __FIBER_TYPEDARRAY_HPP
#define __FIBER_TYPEDARRAY_HPP
 
#include "MemBase.hpp"
#include <memcore/Chunk.hpp>
#include <eagle/PhysicalSpace.hpp>
 
namespace Fiber
{
 
template <Dims_t N, class T>
        class   MemArray;
 
template <class T>
        class TypedArray;
 
 
template <class T>
Iterator<T> getComponentArrayIterator(const TypedArray<T>&It, int component)
{
const CreativeIterator<T>*C = It.creativeIterator();
        if (!C)
                return Iterator<T>(0,0);
 
        return *C;
}
 
 
template <class T, int Components>
Iterator<T> getComponentArrayIterator(const TypedArray<FixedArray<T, Components> >&It, int component)
{
const CreativeIterator<FixedArray<T, Components>>*C = It.creativeIterator();
        if (!C)
                return Iterator<T>(0,0);
 
const Iterator<FixedArray<T, Components>>&iter = *C;
 
        return Iterator<T>(iter, component);
}
 
 
template <class T>
        class TypedArray : virtual public MemBase
{
public:
        typedef T       value_type;
 
        TypedArray(const MemBase::Creator_t&C)
        : MemBase(FiberType<T>::getFiberType()->getFiberTypeIndex(), C)
        {}
 
        TypedArray(const TypedArray<T>&) = delete;
        void operator=(const TypedArray<T>&) = delete;
 
        virtual T first() const = 0;
 
        virtual T last()  const = 0;
 
        virtual CreativeIterator<T>* creativeIterator() = 0;
 
        virtual const CreativeIterator<T>* creativeIterator() const = 0;
 
        virtual RefPtr<MemCore::TypedChunk<T> > myChunk() const = 0;
 
 
        RefPtr<MemCore::ChunkBase> getChunk() const override
        {
                return myChunk();
        }
 
 
        const type_info&getType() const override
        {
                return typeid(T);
        }
 
 
static  MemCore::WeakPtr<FiberTypeBase> getFiberType()
        {
                return FiberType<T>::getFiberType();
        }
 
        using MemBase::create;
static  RefPtr<MemBase> create(const RefPtr<MemBase>&SourceLayout,
                               const type_info&layout = typeid(void) )
        {
                return SourceLayout->create( FiberType<T>::getFiberType(), layout);
        }
 
        template <class UnaryOperator>
        RefPtr<MemBase> applyOperator(const UnaryOperator&theOperator, const MemBase::Creator_t&theCreator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;
 
        MemCore::MemVector<T> Result( CI.count() );
                for(index_t i=0; i<It.count(); i++)
                {
                const   T&in  = It[i];
                        T&out = Result[i];
                        out   = theOperator( in );
                }
                return createEquallySizedMemArray( Result, theCreator);
        }
 
 
        template <class result_t>
        RefPtr<MemBase> applyFunction(const std::function<result_t(const T&)>&theOperator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;
 
        const RefPtr<FiberTypeBase>&FT = FiberType<result_t>::getFiberType().self();
        RefPtr<TypedArray<result_t>> NewArray = MemBase::create(FT, getSize() );
                if (!NewArray)  return nullptr;
 
        const CreativeIterator<result_t>*rC = NewArray->creativeIterator();
                if (!rC)        return nullptr;
 
        const CreativeIterator<result_t>&rCI = *rC;
        const Iterator<result_t>&rIt = rCI;
 
                for(index_t i=0; i<It.count(); i++)
                {
                const   T&in  = It[i];
                result_t&out = rIt[i];
                        out   = theOperator( in );
                }
                return NewArray;
        }
 
        RefPtr<MemBase> applyFunction(const std::function<T(const T&)>&theOperator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;
 
        const RefPtr<FiberTypeBase>&FT = FiberType<T>::getFiberType();
        RefPtr<TypedArray<T>> NewArray = MemBase::create(FT, getSize() );
                if (!NewArray)  return nullptr;
 
        const CreativeIterator<T>*rC = NewArray->creativeIterator();
                if (!rC)        return nullptr;
 
        const CreativeIterator<T>&rCI = *rC;
        const Iterator<T>&rIt = rCI;
 
                for(index_t i=0; i<It.count(); i++)
                {
                const   T&in  = It[i];
                        T&out = rIt[i];
                        out   = theOperator( in );
                }
                return NewArray;
        }
 
 
        template <class result_t>
        RefPtr<MemBase> applyFunction(const std::function<result_t(const T&, index_t I)>&theOperator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;
 
        const RefPtr<FiberTypeBase>&FT = FiberType<result_t>::getFiberType().self();
        RefPtr<TypedArray<result_t>> NewArray = MemBase::create(FT, getSize() );
                if (!NewArray)  return nullptr;
 
        const CreativeIterator<result_t>*rC = NewArray->creativeIterator();
                if (!rC)        return nullptr;
 
        const CreativeIterator<result_t>&rCI = *rC;
        const Iterator<result_t>&rIt = rCI;
 
                for(index_t i=0; i<It.count(); i++)
                {
                const   T&in  = It[i];
                result_t&out = rIt[i];
                        out   = theOperator( in, i );
                }
                return NewArray;
        }
 
        RefPtr<MemBase> applyFunction(const std::function<T(const T&, index_t I)>&theOperator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;
 
        const RefPtr<FiberTypeBase>&FT = FiberType<T>::getFiberType().self();
        RefPtr<TypedArray<T>> NewArray = MemBase::create(FT, getSize() );
                if (!NewArray)  return nullptr;
 
        const CreativeIterator<T>*rC = NewArray->creativeIterator();
                if (!rC)        return nullptr;
 
        const CreativeIterator<T>&rCI = *rC;
        const Iterator<T>&rIt = rCI;
 
                for(index_t i=0; i<It.count(); i++)
                {
                const   T&in  = It[i];
                        T&out = rIt[i];
                        out   = theOperator( in, i );
                }
                return NewArray;
        }
 
 
        template <class result_t, class SecondType>
        RefPtr<MemBase> applyFunction(const TypedArray<SecondType>&R, const std::function<result_t(const T&, const SecondType&ST, index_t I)>&theOperator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C) return nullptr;
        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;
 
        const CreativeIterator<SecondType>*C2 = R.creativeIterator();
                if (!C2)        return nullptr;
        const CreativeIterator<SecondType>&CI2 = *C2;
        const Iterator<SecondType>        &It2 = CI2;
 
        const RefPtr<FiberTypeBase>&FT = FiberType<result_t>::getFiberType().self();
        RefPtr<TypedArray<result_t>> NewArray = MemBase::create(FT, getSize() );
                if (!NewArray)  return nullptr;
 
        const CreativeIterator<result_t>*rC = NewArray->creativeIterator();
                if (!rC)        return nullptr;
 
        const CreativeIterator<result_t>&rCI = *rC;
        const Iterator<result_t>&rIt = rCI;
 
                for(index_t i=0; i<It.count(); i++)
                {
                const   T&in  = It[i];
                const   SecondType&in2 = It2[i];
                result_t&out = rIt[i];
                        out   = theOperator( in, in2, i );
                }
                return NewArray;
        }
 
 
        template <class BinaryOperator>
        RefPtr<MemBase> applyOperator(const BinaryOperator&theOperator, const RefPtr<MemBase>&rightValue, const MemBase::Creator_t&theCreator) const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();
 
        RefPtr<TypedArray> RightMemArray = rightValue;
                if (!RightMemArray)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>*CR = RightMemArray->creativeIterator();
                if (!CR)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>&CI = *C;
        const CreativeIterator<T>& R = *CR;
 
                if (CI.count() != R.count() )
                        return MemCore::NullPtr();
 
        MemCore::MemVector<T> Result( CI.count() );
                for(index_t i=0; i<CI.count(); i++)
                {
                const   T&in  = C[i];
                const   T&inR = R[i];
                        T&out = Result[i];
                        out   = theOperator( in, inR );
                }
                return createEquallySizedMemArray( Result, theCreator);
        }
 
 
#ifdef  HAVE_MEMARRAY_INDIRECTION
        template<class UINT>
        bool doIndirection( std::vector<UINT>& indirection_vec, const Iterator<T>&It, const Iterator<T>&Itdst, const uint64_t theNumberOfElements ) const
        {
                if( indirection_vec.size() != theNumberOfElements )
                        return false;
 
                for(index_t i = 0; i<theNumberOfElements; i++)
                {
                index_t src_index = indirection_vec[ i ];
 
                        Itdst[i] = It[ src_index ];
                }
 
                return true;
        }
#endif
 
        auto getComponent(int Component) -> decltype( getComponentArrayIterator(*this, Component))
        {
                return getComponentArrayIterator(*this, Component);
        }
 
        auto operator()(int Component) -> decltype( getComponentArrayIterator(*this, Component))
        {
                return getComponentArrayIterator(*this, Component);
        }
 
        ranged_for_iterator<T> begin()
        {
        CreativeIterator<T>*C = creativeIterator();
                if (!C)
                {
                        return  ranged_for_iterator<T>(0,*C);
                }
 
                return C->begin();
        }
 
        ranged_for_iterator<T> end()
        {
        CreativeIterator<T>*C = creativeIterator();
                if (!C)
                {
                        return  ranged_for_iterator<T>(0,*C);
                }
 
                return C->end();
        }
 
        const_ranged_for_iterator<T> begin() const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                {
                        return  const_ranged_for_iterator<T>(0,*C);
                }
 
                return C->begin();
        }
 
        const_ranged_for_iterator<T> end() const
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                {
                        return  const_ranged_for_iterator<T>(0,*C);
                }
 
                return C->end();
        }
 
#ifdef  HAVE_MEMARRAY_INDIRECTION
 
        RefPtr<MemBase> createIndirection(const DynamicSize&newSize,
                                          const RefPtr<MemCore::ChunkBase>&Indirection,
                                          const MemBase::Creator_t&theCreator) const override
        {
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                {
                        puts("TypedArray::createIndirection() C failed");
                        return MemCore::NullPtr();
                }
        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;
 
#ifdef  HAVE_OLD_MEMARRAY
        RefPtr<MemBase> newData = this->newMemArray(newSize, theCreator);
#else
        RefPtr<MemBase> newData = this->create(newSize);
#endif
                if (!newData)
                {
                        puts("TypedArray::createIndirection() newData failed");
                        return MemCore::NullPtr();
                }
        RefPtr<TypedArray> dst = newData;
                if (!dst)
                {
                        puts("TypedArray::createIndirection() dst failed");
                        return MemCore::NullPtr();
                }
        const CreativeIterator<T>*Cdst = dst->creativeIterator();
                if (!Cdst)
                {
                        puts("TypedArray::createIndirection() dst->creativeIterator() failed");
                        return MemCore::NullPtr();
                }
        const CreativeIterator<T>&CIdst = *Cdst;
        const Iterator<T>&Itdst = CIdst;
 
        index_t mynElements = newSize.nElements();
 
                // 32 bit?
                if( RefPtr<MemCore::TypedChunk<uint32_t> >indirection32_chunk = Indirection )
                {
#ifdef VERBOSE
                        puts("TypedArray::createIndirection() found uint32_t indirection chunk");
#endif
                        if( !doIndirection<uint32_t>(indirection32_chunk->get_vector(), It, Itdst, mynElements) )
                        {
                                puts("TypedArray::createIndirection() found uint32_t indirection chunk but FAILED");
                                return MemCore::NullPtr();
                        }
                }
                // 64 bit?
                else if( RefPtr<MemCore::TypedChunk<uint64_t> >indirection64_chunk = Indirection )
                {
#ifdef VERBOSE
                        puts("TypedArray::createIndirection() found uint64_t indirection chunk");
#endif
                        if( !doIndirection<uint64_t>(indirection64_chunk->get_vector(), It, Itdst, mynElements) )
                        {
                                puts("TypedArray::createIndirection() found uint64_t indirection chunk but FAILED");
                                return MemCore::NullPtr();
                        }
                }
                else
                {
                        puts("TypedArray::createIndirection() ERROR: no 32 or 64 uint found for indirection chunk");
                        return MemCore::NullPtr();
                }
//              if (Indirection32_chunk.size() != newSize.nElements() )
//                      return MemCore::NullPtr();
 
                assert( newData);
 
                return newData;
        }
#endif
 
/*
        //  ugly copy paste code from function above (mr)
        //  Maybe a encapsulated container instead of the vector should be used?
        RefPtr<MemBase> createIndirection(const DynamicSize&newSize, const std::vector<unsigned int>&Indirection, const MemBase::Creator_t&theCreator) const override
        {
                if (Indirection.size() != newSize.nElements() )
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>*C = creativeIterator();
                if (!C)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>&CI = *C;
        const Iterator<T>&It = CI;
 
        RefPtr<MemBase> newData = this->newMemArray(newSize, theCreator);
                if (!newData)
                        return MemCore::NullPtr();
 
        RefPtr<TypedArray> dst = newData;
                if (!dst)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>*Cdst = dst->creativeIterator();
                if (!Cdst)
                        return MemCore::NullPtr();
 
        const CreativeIterator<T>&CIdst = *Cdst;
        const Iterator<T>&Itdst = CIdst;
 
        unsigned nElements = Indirection.size();
                for(unsigned i=0; i<nElements; i++)
                {
                unsigned  src_index = Indirection[ i ];
 
                        Itdst[i] = It[ src_index ];
                }
 
                return newData;
        }
*/
};
 
//extern template class TypedArray<Eagle::PhysicalSpace::point>;
 
/* @ingroup field
   A convenience class that behaves like a (strong) reference to a TypedArray,
   but is more critical, in that it appears to be valid only if this TypedArray
   may provide a CreativeIterator.
 
   @author Werner Benger
 */
template <class T>
        class TypedIterator
{
        RefPtr<TypedArray<T> > SRC;
public:
 
        TypedIterator()
        {}
 
        TypedIterator(const RefPtr<MemBase>&src)
        : SRC(src)
        {}
 
        TypedIterator(const RefPtr<TypedArray<T> >&src)
        : SRC(src)
        {}
 
        bool operator=(const RefPtr<MemBase>&src)
        {
                SRC = src;
                if (SRC) return true;
                else     return false;
        }
 
        bool operator=(const RefPtr<TypedArray<T> >&src)
        {
                SRC = src;
                if (SRC) return true;
                else     return false;
        }
 
        template <int N>
        bool operator=(const RefPtr<MemArray<N, T> >&src)
        {
                SRC = src;
                if (SRC) return true;
                else     return false;
        }
 
        operator bool() const
        {
                if (!SRC)
                        return false;
 
        CreativeIterator<T>*C = SRC ->creativeIterator();
                if (!C)
                        return false;
 
                return true;
        }
 
        const RefPtr<TypedArray<T> >&operator()() const
        {
                return SRC;
        }
 
        CreativeIterator<T>&operator*() const
        {
                assert(SRC);
 
        CreativeIterator<T>*C = SRC ->creativeIterator();
                assert( C );
                return *C;
        }
};
 
} // namespace Fiber
 
#endif /* __FIBER_TYPEDARRAY_HPP */