multiarray.h

Go to the documentation of this file.

#ifndef _MULTIARRAY_CLASS_HEADER_
#define _MULTIARRAY_CLASS_HEADER_
 
 
namespace A_UTILS_NS
{

class DOEXPORT cMultiArrayIndex
{
public:
    cMultiArrayIndex();

    explicit cMultiArrayIndex(tUInt nX);

    cMultiArrayIndex(tUInt nX, tUInt nY);

    cMultiArrayIndex(tUInt nX, tUInt nY, tUInt nZ);

    cMultiArrayIndex(tUInt nX, tUInt nY, tUInt nZ, tUInt nT);

    cMultiArrayIndex(tUInt nX, tUInt nY, tUInt nZ, tUInt nT, tUInt nR);

    tBool IsValid() const;

    tResult AddDimension(tUInt nDimensionValue);

    tResult GetDimensionValue(tUInt nDimensionIndex, tUInt& nValue) const;

    tResult SetDimensionValue(tUInt nDimensionIndex, tUInt nValue);

    tSize NumDimensions() const;
 
protected:
    std::vector<tUInt> m_oDimensionvalues;
};
class DOEXPORT cMultiArrayIndex {…};

tBool operator==(const cMultiArrayIndex& o_A, const cMultiArrayIndex& o_B);

tBool operator!=(const cMultiArrayIndex& o_A, const cMultiArrayIndex& o_B);

typedef cMultiArrayIndex cMultiArrayDimensions;

template<typename T>
class DOEXPORT cMultiArray
{
protected:
    cMultiArrayDimensions m_oDimensions;

    std::vector<T> m_oData;
 
protected:
    tResult InitializeDataStore()
    {
        if (m_oDimensions.NumDimensions() < 1)
        {
            return ERR_INVALID_STATE;
        }
 
        tUInt nTotal = 1;
        for (tUInt nIndex = 0; nIndex < m_oDimensions.NumDimensions(); ++nIndex)
        {
            tUInt nCurrent = 1;
            if (IS_FAILED(m_oDimensions.GetDimensionValue(nIndex, nCurrent)))
            {
                return ERR_INVALID_STATE;
            }
 
            if (nCurrent == 0)
            {
                return ERR_INVALID_ARG;
            }
 
            nTotal *= nCurrent;
        }
 
        m_oData = std::vector<T>(nTotal);
        RETURN_NOERROR;
    }
    tResult InitializeDataStore() {…}

    tBool ContainsIndex(const cMultiArrayIndex& oIndex) const
    {
        if (!m_oDimensions.IsValid() ||
            !oIndex.IsValid() ||
            m_oDimensions.NumDimensions() != oIndex.NumDimensions())
        {
            return false;
        }
 
        for (tUInt nIndex = 0; nIndex < oIndex.NumDimensions(); ++nIndex)
        {
            tUInt nValue = 0;
            if (IS_FAILED(oIndex.GetDimensionValue(nIndex, nValue)))
            {
                return false;
            }
 
            tUInt nThisValue = 0;
            if (IS_FAILED(m_oDimensions.GetDimensionValue(nIndex, nThisValue)))
            {
                return false;
            }
 
            if (nValue >= nThisValue)
            {
                return false;
            }
        }
 
        return true;
    }
    tBool ContainsIndex(const cMultiArrayIndex& oIndex) const {…}

    tResult CalculateInternIndex(const cMultiArrayIndex& oIndex, tUInt& nInternIndex) const
    {
        if (!oIndex.IsValid() ||
            !m_oDimensions.IsValid() ||
            oIndex.NumDimensions() != m_oDimensions.NumDimensions())
        {
            return ERR_INVALID_INDEX;
        }
 
        // we assume that the index is contained in the array
 
        // see http://en.wikipedia.org/wiki/Row-major_order
        tUInt nIndex = 0;
        for (tUInt k = 1; k <= oIndex.NumDimensions(); ++k)
        {
            tUInt nProduct = 1;
            for (tUInt nL = k; nL < m_oDimensions.NumDimensions(); ++nL)
            {
                tUInt nN = 0;
                if (IS_FAILED(m_oDimensions.GetDimensionValue(nL, nN)))
                {
                    return ERR_INVALID_INDEX;
                }
 
                nProduct *= nN;
            }
 
            tUInt nK = 0;
            if (IS_FAILED(oIndex.GetDimensionValue(k - 1, nK)))
            {
                return ERR_INVALID_INDEX;
            }
 
            nIndex += (nProduct * nK);
        }
 
        nInternIndex = nIndex;
        return ERR_NOERROR;
    }
    tResult CalculateInternIndex(const cMultiArrayIndex& oIndex, tUInt& nInternIndex) const {…}
 
public:
    cMultiArray() : m_oDimensions(), m_oData()
    {
    }
    cMultiArray() : m_oDimensions(), m_oData() {…}

    explicit cMultiArray(const cMultiArrayDimensions& oDimensions) :
        m_oDimensions(oDimensions), m_oData()
    {
        if (IS_FAILED(InitializeDataStore()))
        {
            // invalidate the dimensions
            m_oDimensions = cMultiArrayDimensions();
        }
    }
    explicit cMultiArray(const cMultiArrayDimensions& oDimensions) : {…}

    virtual ~cMultiArray()
    {
    }
    virtual ~cMultiArray() {…}

    tBool IsValid() const
    {
        return m_oDimensions.IsValid() && !m_oData.empty();
    }
    tBool IsValid() const {…}

    tSize NumElements() const
    {
        return m_oData.size();
    }
    tSize NumElements() const {…}

    const cMultiArrayDimensions& Dimensions() const
    {
        return m_oDimensions;
    }
    const cMultiArrayDimensions& Dimensions() const {…}

    tResult Set(const cMultiArrayIndex& oIndex, T value)
    {
        if (!oIndex.IsValid() || !ContainsIndex(oIndex))
        {
            return ERR_INVALID_INDEX;
        }
 
        tUInt nInternIndex = 0;
        if (IS_FAILED(CalculateInternIndex(oIndex, nInternIndex)))
        {
            return ERR_INVALID_INDEX;
        }
 
        m_oData[nInternIndex] = value;
 
        RETURN_NOERROR;
    }
    tResult Set(const cMultiArrayIndex& oIndex, T value) {…}

    tResult Get(const cMultiArrayIndex& oIndex, T& value) const
    {
        if (!oIndex.IsValid() || !ContainsIndex(oIndex))
        {
            return ERR_INVALID_INDEX;
        }
 
        tUInt nInternIndex = 0;
        if (IS_FAILED(CalculateInternIndex(oIndex, nInternIndex)))
        {
            return ERR_INVALID_INDEX;
        }
 
        value = m_oData[nInternIndex];
 
        RETURN_NOERROR;
    }
    tResult Get(const cMultiArrayIndex& oIndex, T& value) const {…}
};
class DOEXPORT cMultiArray {…};

template <typename T>
cString MultiArrayToString(const cMultiArray<T>& oArray);

template <>
cString MultiArrayToString<tInt>(const cMultiArray<tInt>& oArray);

template <>
cString MultiArrayToString<tFloat32>(const cMultiArray<tFloat32>& oArray);

template <>
cString MultiArrayToString<tFloat64>(const cMultiArray<tFloat64>& oArray);

template <typename T>
tResult ParseMultiArrayFromString(const cString& strRepr, cMultiArray<T>& arrDest);

template <>
tResult ParseMultiArrayFromString<tInt>(const cString& strRepr, cMultiArray<tInt>& arrDest);

template <>
tResult ParseMultiArrayFromString<tFloat32>(const cString& strRepr, cMultiArray<tFloat32>& arrDest);

template <>
tResult ParseMultiArrayFromString<tFloat64>(const cString& strRepr, cMultiArray<tFloat64>& arrDest);
 
} // namespace A_UTILS_NS
 
#endif // _MULTIARRAY_CLASS_HEADER_