wmsimplearrays.h

Go to the documentation of this file.

#ifndef wmsimplearrays_h
#define wmsimplearrays_h
 
// Wx includes
#include "lib/wxrange.h"
 
// Wm includes
#include "lib/wmindexer.h"
#include "wmarraybase.h"
 
template<int MAJOR_ORDER_TYPE>
class WmTypeOpaqueArray : public WmArrayBase<MAJOR_ORDER_TYPE>
{
public:
    WmTypeOpaqueArray(const WxRange& range, void* data, int numBytesPerElement)
        : WmArrayBase<MAJOR_ORDER_TYPE>(range),
          _data(data),
          _numBytesPerElement(numBytesPerElement)
    {
    }
 
    WmTypeOpaqueArray(const WmTypeOpaqueArray<MAJOR_ORDER_TYPE>& that)
        : WmArrayBase<MAJOR_ORDER_TYPE>(that),
          _data(that._data),
          _numBytesPerElement(that._numBytesPerElement)
    {
    }
 
    /*
     * Assignment operator does not allocate new memory. The created array
     * represents the same data and geometry as the original one.
     *
     * Freeing of array memory is not the responsibility of this class.
     *
     * @param that array to copy
     * @return reference to new array
     */
    WmTypeOpaqueArray<MAJOR_ORDER_TYPE>&
    operator=(const WmTypeOpaqueArray<MAJOR_ORDER_TYPE>& that)
    {
        if (this == &that)
            return *this;
        WmArrayBase<MAJOR_ORDER_TYPE>::operator=(that);
        _data = that._data;
        _numBytesPerElement = that._numBytesPerElement;
        return *this;
    }
 
    void* data()
    {
        return _data;
    }
 
    const void* data() const
    {
        return _data;
    }
 
    void* data(const int* indices)
    {
        int element_offset = WmArrayBase<MAJOR_ORDER_TYPE>::_indexer.index(indices);
        char* byte_loc = static_cast<char*>(_data) + element_offset * _numBytesPerElement;
        return static_cast<void*>(byte_loc);
    }
 
    const void* data(const int* indices) const
    {
        int element_offset = WmArrayBase<MAJOR_ORDER_TYPE>::_indexer.index(indices);
        const char* byte_loc =
            static_cast<const char*>(_data) + element_offset * _numBytesPerElement;
        return static_cast<const void*>(byte_loc);
    }
 
    void* dataSlab(const int* indices, int indicesRank)
    {
        int slabStartIndices[max_dims];
        for (int i = 0; i < indicesRank; ++i)
            slabStartIndices[i] = indices[i];
        for (int i = indicesRank; i < rank(); ++i)
            slabStartIndices[i] = this->range().lower(i);
        int element_offset =
            WmArrayBase<MAJOR_ORDER_TYPE>::_indexer.index(slabStartIndices);
        char* byte_loc = static_cast<char*>(_data) + element_offset * _numBytesPerElement;
        return static_cast<void*>(byte_loc);
    }
 
    const void* dataSlab(const int* indices, int indicesRank) const
    {
        int slabStartIndices[max_dims];
        for (int i = 0; i < indicesRank; ++i)
            slabStartIndices[i] = indices[i];
        for (int i = indicesRank; i < rank(); ++i)
            slabStartIndices[i] = this->range().lower(i);
        int element_offset =
            WmArrayBase<MAJOR_ORDER_TYPE>::_indexer.index(slabStartIndices);
        const char* byte_loc =
            static_cast<const char*>(_data) + element_offset * _numBytesPerElement;
        return static_cast<const void*>(byte_loc);
    }
 
    int numBytesPerElement() const
    {
        return _numBytesPerElement;
    }
 
    // void put(const WxRange & selection, const void *bufin);
 
    // void get(const WxRange & selection, void *bufout) const;
 
    void put(const WxRange& selection, const WxRange& inputShape, const void* bufin);
 
    void get(const WxRange& selection, const WxRange& outputShape, void* bufout) const;
 
    using WmArrayBase<MAJOR_ORDER_TYPE>::rank;
    using WmArrayBase<MAJOR_ORDER_TYPE>::max_dims;
 
    virtual ~WmTypeOpaqueArray()
    {
    }
 
protected:
    WmTypeOpaqueArray()
        : WmArrayBase<MAJOR_ORDER_TYPE>(), _data(NULL), _numBytesPerElement(0)
    {
    }
 
    void resetArrayProperties(const WxRange& range, void* data, int numBytesPerElement)
    {
        WmArrayBase<MAJOR_ORDER_TYPE>::setRange(range);
        _data = data;
        _numBytesPerElement = numBytesPerElement;
    }
 
private:
    // hide this otherwise public base-class interface
    void setRange(const WxRange& range);
 
    void checkContained(const WxRange& selection) const;
 
    static void copyToRange(int currentDim,
                            int rangeRank,
                            const int jump_array[max_dims],
                            const int jump_buffer[max_dims],
                            const int extent_array[max_dims],
                            const char* sourceBuffer,
                            char* destinationPointer,
                            int numBytesPerElement);
    static void copyFromRange(int currentDim,
                              int rangeRank,
                              const int jump_array[max_dims],
                              const int jump_buffer[max_dims],
                              const int extent_array[max_dims],
                              const char* sourcePointer,
                              char* destBuffer,
                              int numBytesPerElement);
 
    void* _data;
    int _numBytesPerElement;
};
 
template<int MAJOR_ORDER_TYPE, typename T>
class WmTypedArray : public WmTypeOpaqueArray<MAJOR_ORDER_TYPE>
{
public:
    WmTypedArray(const WxRange& range, T* data)
        : WmTypeOpaqueArray<MAJOR_ORDER_TYPE>(range, data, sizeof(T)),
          _responsibleForFreeingElements(false)
    {
    }
 
    WmTypedArray(const WxRange& range)
        : WmTypeOpaqueArray<MAJOR_ORDER_TYPE>(range, new T[range.size()], sizeof(T)),
          _responsibleForFreeingElements(true)
    {
    }
 
    WmTypedArray(const WmTypedArray<MAJOR_ORDER_TYPE, T>& that)
        : WmTypeOpaqueArray<MAJOR_ORDER_TYPE>(that), _responsibleForFreeingElements(false)
    {
    }
 
    WmTypedArray(const WmTypeOpaqueArray<MAJOR_ORDER_TYPE>& that)
        : WmTypeOpaqueArray<MAJOR_ORDER_TYPE>(that), _responsibleForFreeingElements(false)
    {
    }
 
    /*
     * Assignment operator does not allocate new memory. The created array
     * represents the same data and geometry as the original one.
     *
     * Freeing of array memory is not the responsibility of this instance
     *
     * @param that array to copy
     * @return reference to new array
     */
    WmTypedArray<MAJOR_ORDER_TYPE, T>&
    operator=(const WmTypedArray<MAJOR_ORDER_TYPE, T>& that)
    {
        if (this == &that)
            return *this;
        WmTypeOpaqueArray<MAJOR_ORDER_TYPE>::operator=(that);
        _responsibleForFreeingElements = false;
        return *this;
    }
 
    ~WmTypedArray()
    {
        if (_responsibleForFreeingElements)
        {
            delete[] data();
        }
    }
 
    T operator()(int k0) const;
    T& operator()(int k0);
 
    T operator()(int k0, int k1) const;
    T& operator()(int k0, int k1);
 
    T operator()(int k0, int k1, int k2) const;
    T& operator()(int k0, int k1, int k2);
 
    T operator()(int k0, int k1, int k2, int k3) const;
    T& operator()(int k0, int k1, int k2, int k3);
 
    T* data()
    {
        return static_cast<T*>(WmTypeOpaqueArray<MAJOR_ORDER_TYPE>::data());
    }
 
    const T* data() const
    {
        return static_cast<const T*>(WmTypeOpaqueArray<MAJOR_ORDER_TYPE>::data());
    }
 
    T* dataSlab(const int* indices, int indicesRank)
    {
        return static_cast<T*>(
            WmTypeOpaqueArray<MAJOR_ORDER_TYPE>::dataSlab(indices, indicesRank));
    }
 
    const T* dataSlab(const int* indices, int indicesRank) const
    {
        return static_cast<const T*>(
            WmTypeOpaqueArray<MAJOR_ORDER_TYPE>::dataSlab(indices, indicesRank));
    }
 
    // void put(const WxRange & selection, const void *bufin);
 
    // void get(const WxRange & selection, void *bufout) const;
 
protected:
    void resetArrayProperties(const WxRange& range, T* newdata)
    {
        if (_responsibleForFreeingElements)
        {
            delete[] data();
            _responsibleForFreeingElements = false;
        }
        WmTypeOpaqueArray<MAJOR_ORDER_TYPE>::resetArrayProperties(
            range, newdata, sizeof(T));
    }
 
    WmTypedArray()
        : WmTypeOpaqueArray<MAJOR_ORDER_TYPE>(), _responsibleForFreeingElements(false)
    {
    }
 
private:
    bool _responsibleForFreeingElements;
};
 
#endif //  wmsimplearrays_h