field/DynamicSize.hpp

 
//
// $Id: DynamicSize.hpp,v 1.5 2008/03/10 20:20:50 werner Exp $
//
#ifndef __FIBER_DYNAMICSIZE_HPP
#define __FIBER_DYNAMICSIZE_HPP
 
#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <memcore/Interface.hpp>
#include <fiber/vector/MultiIndex.hpp>
 
namespace Fiber
{
 
class FIELD_API DynamicSize
{
public:
        using rank_t = int;
 
private:
 
        rank_t  rank = 0;
        index_t *dims = nullptr;
 
public:
        template <Dims_t N>
        DynamicSize(const MultiIndex<N>&MI)
        : rank(N)
        {
                dims = new index_t[ N ];
                for(Dims_t i=0; i<N; i++)
                        dims[i] = MI[i];
        }
 
        template <class T>
        DynamicSize(Dims_t N, const T values[])
        : rank(N)
        {
                dims = new index_t[ N ];
                for(Dims_t i=0; i<N; i++)
                        dims[i] = values[i];
        }
 
        DynamicSize(Dims_t N, index_t NValue)
        : rank(N)
        {
                if (N>0)
                {
                        dims = new index_t[ N ];
                        for(Dims_t i=0; i<N; i++)
                                dims[i] = NValue;
                }
                else
                        dims = 0;
        }
 
        DynamicSize() = default;
 
        DynamicSize(const DynamicSize&DS);
 
        DynamicSize(index_t SubDimension, const DynamicSize&DS);
 
        DynamicSize(int N, const DynamicSize&L, const DynamicSize&R);
 
        ~DynamicSize();
 
        DynamicSize&operator=(const DynamicSize&DS);
 
        bool operator!=(const DynamicSize&DS) const noexcept;
 
        bool operator==(const DynamicSize&DS) const noexcept
        {
                return !( (*this) != DS );
        }
 
        template <class T>
        DynamicSize&setSize(int N, const T values[])
        {
                delete [] dims;
                if (N>0)
                {
                        rank = N;
                        dims = new index_t[ N ];
                        for(int i=0; i<N; i++)
                                dims[i] = values[i];
                }
                else
                {
                        rank = 0;
                        dims = 0;
                }
                return *this;
        }
 
        template <Dims_t N>
        DynamicSize&resize(const MultiIndex<N>&MI)
        {
                delete [] dims;
                if (N>0)
                {
                        rank = N;
                        dims = new index_t[ N ];
                        for(Dims_t i=0; i<N; i++)
                                dims[i] = MI[i];
                }
                else
                {
                        rank = 0;
                        dims = 0;
                }
                return *this;
        }
 
        bool    hasIncompatibleLowerDims(const DynamicSize&DS) const noexcept;
 
        bool    hasIncompatibleHigherDims(const DynamicSize&DS) const noexcept;
 
        bool    hasCompatibleHigherDims(const DynamicSize&DS) const noexcept
        {
                return !hasIncompatibleHigherDims(DS);
        }
 
        size_t  getElementArraySize(const DynamicSize&DataFragmentDims) const noexcept
        {
                if (getNumberOfElements() == DataFragmentDims.getNumberOfElements())
                        return 1; // independent of rank!!
 
                if (DataFragmentDims.getRank() == getRank()+1 &&
                    DataFragmentDims.hasCompatibleHigherDims(*this) )
                {
                        return DataFragmentDims[ 0 ];
                }
 
                return 0; // mismatch
        }
 
 
        bool    hasCompatibleLowerDims(const DynamicSize&DS) const noexcept
        {
                return !hasIncompatibleLowerDims(DS);
        }
 
        index_t nElements() const
        {
                if (!dims) return 0;
 
        index_t N = 1;
                for(rank_t i=0; i<rank; i++)
                {
                        N *= dims[i];
                }
                return N;
        }
 
        index_t getNumberOfElements() const
        {
                return nElements();
        }
 
        rank_t  Rank() const
        {
                return rank;
        }
 
        rank_t  getRank() const
        {
                return rank;
        }
 
        rank_t  dimensionality() const
        {
                return rank;
        }
 
        index_t operator[](int i) const
        {
                if (!dims)
                        return 0;
 
                if (i>=0 && i<rank)
                        return dims[i];
                else
                        return 1;
        }
 
        const index_t *dims_ptr() const
        {
                return dims;
        }
 
        bool    isValid() const
        {
                return nullptr != dims;
        }
 
        bool    setSize(int i, index_t what)
        {
                if (!dims)
                        return false;
 
                if (i>=0 && i<rank)
                {
                        dims[i] = what;
                        return true;
                }
 
                return true;
        }
 
 
        template <Dims_t N>
        bool    changeSize(const MultiIndex<N>&MI)
        {
                if (!dims)
                        return false;
 
        int     I = rank;
                if (I>N) I = N;
 
                for(Dims_t i=0; i<I; i++)
                {
                        dims[i] = MI[i];
                }
                return true;
        }
 
 
        bool    increment_dims(int incr)
        {
                if (!dims)
                        return false;
 
                for(int i=0; i<rank; i++)
                {
                        dims[i] += incr;
                }
                return true;
        }
 
        bool    multiply_dims(int incr)
        {
                if (!dims)
                        return false;
 
                for(int i=0; i<rank; i++)
                {
                        dims[i] *= incr;
                }
                return true;
        }
 
        DynamicSize&increment(const DynamicSize&D)
        {
                if (!dims)
                {
                        dims = new index_t[D.rank];
                        rank = D.rank;
                        for(rank_t i=0; i<rank; i++)
                                dims[i] = D.dims[i];
                        return *this;
                }
 
                if (rank<D.rank)
                {
                index_t *new_dims = new index_t[D.rank];
                        for(rank_t i=0; i<D.rank; i++)
                                new_dims[i] = D.dims[i];
 
                        for(rank_t i=0; i<rank; i++)
                                new_dims[i] += dims[i];
 
                        delete [] dims;
                        dims = new_dims;
                        rank = D.rank;
                        return *this;
                }
 
                for(rank_t i=0; i<D.rank; i++)
                {
                        dims[i] += D.dims[i];
                }
 
                return *this;
        }
 
        DynamicSize&operator+=(const DynamicSize&D)
        {
                return increment(D);
        }
 
        bool    setSize(const DynamicSize&D, int FillUp = 1) const
        {
                if (!dims)
                        return false;
 
                if (!D.dims)
                        return false;
 
                for(rank_t i=0; i<rank; i++)
                {
                        if (i<D.rank)
                        {
                                dims[i] = D.dims[i];
                        }
                        else
                                dims[i] = FillUp;
                }
 
                return true;
        }
 
 
        template <typename T>
        rank_t  getDims(T*Dims, int MaxEntries) const
        {
                if (!dims)
                        return 0;
 
        rank_t  i = 0;
                for(; i<rank; i++)
                {
                        if (i>=MaxEntries)
                                break;
 
                        Dims[i] = dims[i];
                }
 
                for(; i<MaxEntries; i++)
                        Dims[i] = 0;
 
                return rank;
        }
 
        template <typename T, int N>
                rank_t  getDims(T(&Dims)[N]) const
        {
                return getDims(Dims, N);
        }
 
        template <Dims_t N>
        bool    get(MultiIndex<N>&MI) const
        {
                if (rank != N)
                        return false;
 
                for(Dims_t i=0; i<N; i++)
                        MI[i] = dims[i];
 
                return true;
        }
 
        template <Dims_t N>
        MultiIndex<N> getSize() const
        {
                if (rank != N)
                        return  MultiIndex<N>(0);
 
        MultiIndex<N> MI(1);
                for(Dims_t i=0; i<N; i++)
                        MI[i] = dims[i];
 
                return MI;
        }
 
        std::string     str() const;
};
 
inline  size_t  ElementArraySize(const DynamicSize&FragmentBaseSpaceDims, const DynamicSize&DataFragmentDims) noexcept
{
        if (FragmentBaseSpaceDims.getNumberOfElements() == DataFragmentDims.getNumberOfElements())
                return 1; // independent of rank!!
 
        if (DataFragmentDims.getRank() == FragmentBaseSpaceDims.getRank()+1 &&
            DataFragmentDims.hasCompatibleHigherDims(FragmentBaseSpaceDims) )
        {
                return DataFragmentDims[ 0 ];
        }
 
        return 0; // mismatch
}
 
 
class FIELD_API SizeInterface : public MemCore::Interface<SizeInterface>, public DynamicSize
{
public:
        SizeInterface(int rank, const SizeInterface&L, const SizeInterface&R);
 
public:
        template <int N>
        SizeInterface(const MultiIndex<N>&MI)
        : DynamicSize(MI)
        {}
 
        SizeInterface(const DynamicSize&DS)
        : DynamicSize(DS)
        {}
 
        template <class T>
        SizeInterface(int N, const T values[])
        : DynamicSize(N, values)
        {}
 
        SizeInterface(int N)
        : DynamicSize(N, 0)
        {}
 
        SizeInterface()
        {}
 
        SizeInterface(const SizeInterface&DS);
 
protected:
        ~SizeInterface();
public:
 
        using DynamicSize::operator[];
        using DynamicSize::operator!=;
        using DynamicSize::operator=;
 
        friend  MemCore::RefPtr<SizeInterface> operator+(const MemCore::RefPtr<SizeInterface>&L,
                                                         const MemCore::RefPtr<SizeInterface>&R);
 
        friend  MemCore::RefPtr<SizeInterface> operator+=(const MemCore::RefPtr<SizeInterface>&L,
                                                          const MemCore::RefPtr<SizeInterface>&R)
        {
                if (L && R)
                        L->increment(*R);
 
                return L;
        }
};
 
} /* namespace Fiber */
 
namespace std
{
 
inline  string to_string(const Fiber::DynamicSize&Sz)
{
        return Sz.str();
}
 
inline  string to_string(const Fiber::SizeInterface&SI)
{
        return SI.str();
}
 
}
 
 
#endif /* __FIBER_DYNAMICSIZE_HPP */