primitiveTypeArray.h

 
#ifndef PRIMITIVE_TYPE_ARRAY_H
#define PRIMITIVE_TYPE_ARRAY_H
 
#include "data/arrayWrapper.h"
#include "data/dataHandler.h"
#include "data/pointerWrapper.h"
 
namespace Data {
    template <class T> class PrimitiveTypeArray : public ArrayWrapper<T>
    {
      protected:
        std::vector<T> data;
 
      public:
        PrimitiveTypeArray(size_t size = 8);
 
        PrimitiveTypeArray(const PrimitiveTypeArray<T>& other);
 
        PrimitiveTypeArray(const ArrayWrapper<T>& other);
 
        PrimitiveTypeArray(const PointerWrapper<T>& other);
 
        virtual ~PrimitiveTypeArray() = default;
 
        virtual DataHandler* clone() const override;
 
        void resetData() override;
 
        void setDataAt(const std::type_info& type, const size_t address,
                       const T& value);
        PrimitiveTypeArray<T>& operator=(const PrimitiveTypeArray<T>& other);
    };
 
    template <class T>
    PrimitiveTypeArray<T>::PrimitiveTypeArray(size_t size)
        : ArrayWrapper<T>(size, nullptr), data(size)
    {
        this->setPointer(&(this->data));
    }
 
    template <class T>
    PrimitiveTypeArray<T>::PrimitiveTypeArray(
        const PrimitiveTypeArray<T>& other)
        : ArrayWrapper<T>(other), data(other.data)
    {
        // Set the pointer to the right data
        this->setPointer(&(this->data));
    }
 
    template <class T>
    PrimitiveTypeArray<T>::PrimitiveTypeArray(const ArrayWrapper<T>& other)
        : ArrayWrapper<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 <class T>
    PrimitiveTypeArray<T>::PrimitiveTypeArray(const PointerWrapper<T>& other)
        : ArrayWrapper<T>(other, 1), data(1)
    {
        if (other.containerPtr != NULL) {
            // Copy the data from the given PointerWrapper
            this->data[0] = *other.containerPtr;
        }
        else {
            this->resetData();
        }
 
        // Set the pointer to the right data
        this->setPointer(&(this->data));
    }
 
    template <class T> inline DataHandler* PrimitiveTypeArray<T>::clone() const
    {
        // Default copy construtor does the deep copy.
        PrimitiveTypeArray<T>* result = new PrimitiveTypeArray<T>(*this);
 
        return result;
    }
 
    template <class T> void PrimitiveTypeArray<T>::resetData()
    {
        for (T& elt : this->data) {
            elt = T{0};
        }
 
        // Invalidate the cached hash
        this->invalidCachedHash = true;
    }
 
    template <class T>
    void PrimitiveTypeArray<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>
    PrimitiveTypeArray<T>& PrimitiveTypeArray<T>::operator=(
        const PrimitiveTypeArray<T>& other)
    {
        // Guard self assignment
        if (this != &other) {
            if (this->nbElements != other.nbElements) {
                std::stringstream message;
                message << "Assigned PrimitiveTypeArray 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