primitiveTypeArray2D.h

 
#ifndef PRIMITIVE_TYPE_ARRAY_2D_H
#define PRIMITIVE_TYPE_ARRAY_2D_H
 
#include <tuple>
 
#include "data/array2DWrapper.h"
#include "data/dataHandler.h"
#include "data/primitiveTypeArray.h"
 
namespace Data {
 
    template <typename T> class PrimitiveTypeArray2D : public Array2DWrapper<T>
    {
      protected:
        std::vector<T> data;
 
      public:
        PrimitiveTypeArray2D(const size_t w = 2, const size_t h = 4);
 
        PrimitiveTypeArray2D(const PrimitiveTypeArray2D<T>& other);
 
        PrimitiveTypeArray2D(const Array2DWrapper<T>& other);
 
        virtual DataHandler* clone() const override;
 
        void resetData() override;
 
        void setDataAt(const std::type_info& type, const size_t address,
                       const T& value);
        PrimitiveTypeArray2D<T>& operator=(
            const PrimitiveTypeArray2D<T>& other);
    };
 
    template <typename T>
    inline PrimitiveTypeArray2D<T>::PrimitiveTypeArray2D(const size_t w,
                                                         const size_t h)
        : Array2DWrapper<T>(w, h, nullptr), data(h * w)
    {
        // Set the pointer to the right data
        this->setPointer(&(this->data));
    }
 
    template <typename T>
    inline PrimitiveTypeArray2D<T>::PrimitiveTypeArray2D(
        const PrimitiveTypeArray2D<T>& other)
        : Array2DWrapper<T>(other), data(other.data)
    {
        // Set the pointer to the right data
        this->setPointer(&(this->data));
    }
 
    template <class T>
    PrimitiveTypeArray2D<T>::PrimitiveTypeArray2D(
        const Array2DWrapper<T>& other)
        : Array2DWrapper<T>(other), data(this->nbElements)
    {
        if (this->containerPtr != NULL) {
            // Copy the data from the given ArrayWrapper
            for (size_t i = 0; i < this->nbElements; i++) {
                // exploit the fact that the container pointer still points to
                // data from other.
                this->data[i] = this->containerPtr->at(i);
            }
        }
        else {
            this->resetData();
        }
 
        // Set the pointer to the right data
        this->setPointer(&(this->data));
    }
 
    template <typename T>
    inline DataHandler* PrimitiveTypeArray2D<T>::clone() const
    {
        // Copy construtor should do the deep copy.
        DataHandler* result = new PrimitiveTypeArray2D<T>(*this);
 
        return result;
    }
 
    template <class T> void PrimitiveTypeArray2D<T>::resetData()
    {
        for (T& elt : this->data) {
            elt = T{0};
        }
 
        // Invalidate the cached hash
        this->invalidCachedHash = true;
    }
 
    template <class T>
    void PrimitiveTypeArray2D<T>::setDataAt(const std::type_info& type,
                                            const size_t address,
                                            const T& value)
    {
#ifndef NDEBUG
        // Throw exception in case of invalid arguments.
        this->checkAddressAndType(type, address);
#endif
 
        this->data.at(address) = value;
 
        // Invalidate the cached hash.
        this->invalidCachedHash = true;
    }
 
    template <class T>
    PrimitiveTypeArray2D<T>& PrimitiveTypeArray2D<T>::operator=(
        const PrimitiveTypeArray2D<T>& other)
    {
        // Guard self assignment
        if (this != &other) {
            if (this->nbElements != other.nbElements) {
                std::stringstream message;
                message << "Assigned PrimitiveTypeArray2D do not have the same "
                           "size : "
                        << this->nbElements << " / " << other.nbElements << ".";
                throw std::domain_error(message.str());
            }
 
            // Copy Data from right arg to this
            for (auto i = 0; i < this->nbElements; i++) {
                this->data.at(i) = other.data.at(i);
            }
        }
        return *this;
    }
}; // namespace Data
#endif