arrayWrapper.h

 
#ifndef ARRAY_WRAPPER_H
#define ARRAY_WRAPPER_H
 
#include <functional>
#include <map>
#include <regex>
#include <sstream>
#include <stdexcept>
#include <typeindex>
#include <typeinfo>
 
#include "data/constant.h"
#include "data/dataHandler.h"
#include "data/demangle.h"
#include "data/hash.h"
 
namespace Data {
 
    template <class T> class ArrayWrapper : public DataHandler
    {
        static_assert(std::is_fundamental<T>::value ||
                          std::is_same<T, Data::Constant>(),
                      "Template class PrimitiveTypeArray<T> can only be used "
                      "for primitive types.");
 
      private:
        mutable std::map<std::type_index, size_t> cachedAddressSpace;
 
      protected:
        const size_t nbElements;
 
        std::vector<T>* containerPtr;
 
        void checkAddressAndType(const std::type_info& type,
                                 const size_t& address) const;
 
        virtual size_t updateHash() const override;
 
      public:
        ArrayWrapper(size_t size = 8, std::vector<T>* ptr = nullptr)
            : nbElements{size}
        {
            this->setPointer(ptr);
        };
 
        virtual ~ArrayWrapper() = default;
 
        ArrayWrapper(const ArrayWrapper<T>& other) = default;
 
        ArrayWrapper(const DataHandler& other, size_t size);
 
        virtual DataHandler* clone() const override;
 
        virtual bool canHandle(const std::type_info& type) const override;
 
        virtual size_t getAddressSpace(
            const std::type_info& type) const override;
 
        virtual size_t getLargestAddressSpace(void) const override;
 
        void invalidateCachedHash();
 
        void resetData() override;
 
        void setPointer(std::vector<T>* ptr);
 
        virtual UntypedSharedPtr getDataAt(const std::type_info& type,
                                           const size_t address) const override;
 
        virtual std::vector<size_t> getAddressesAccessed(
            const std::type_info& type, const size_t address) const override;
 
#ifdef CODE_GENERATION
        virtual const std::type_info& getNativeType() const override;
 
        virtual std::vector<size_t> getDimensionsSize() const override;
#endif
    };
 
    template <class T>
    bool ArrayWrapper<T>::canHandle(const std::type_info& type) const
    {
        if (typeid(T) == type) {
            return true;
        }
 
        // Use the code in getAddressSpace to check if the type is supported.
        return (this->getAddressSpace(type) > 0);
    }
 
    template <class T>
    void ArrayWrapper<T>::checkAddressAndType(const std::type_info& type,
                                              const size_t& address) const
    {
        size_t addressSpace = this->getAddressSpace(type);
        // check type
        if (addressSpace == 0) {
            std::stringstream message;
            message << "Data type " << DEMANGLE_TYPEID_NAME(type.name())
                    << " cannot be accessed in a "
                    << DEMANGLE_TYPEID_NAME(typeid(*this).name()) << ".";
            throw std::invalid_argument(message.str());
        }
 
        // check location
        if (address >= addressSpace) {
            std::stringstream message;
            message << "Data type " << DEMANGLE_TYPEID_NAME(type.name())
                    << " cannot be accessed at address " << address
                    << ", address space size is " << addressSpace << ".";
            throw std::out_of_range(message.str());
        }
    }
 
    template <class T>
    ArrayWrapper<T>::ArrayWrapper(const DataHandler& other, size_t size)
        : DataHandler(other), containerPtr{nullptr}, nbElements(size)
    {
        this->setPointer(nullptr);
    }
 
    // Declare class for clone method
    template <class T> class PrimitiveTypeArray;
 
    template <class T> inline DataHandler* ArrayWrapper<T>::clone() const
    {
        // Create a constantCopy of the ArrayWrapper content.
        DataHandler* result = new PrimitiveTypeArray<T>(*this);
 
        return result;
    }
 
    template <class T>
    size_t ArrayWrapper<T>::getAddressSpace(const std::type_info& type) const
    {
        // Has the addresSpaceSize been cached
        auto iter = this->cachedAddressSpace.find(type);
        if (iter != this->cachedAddressSpace.end()) {
            return iter->second;
        }
 
        if (type == typeid(T)) {
            this->cachedAddressSpace.emplace(type, this->nbElements);
            return this->nbElements;
        }
 
        // If the type is an array of the primitive type
        // with a size inferior to the container.
        std::string typeName = DEMANGLE_TYPEID_NAME(type.name());
        std::string regex{DEMANGLE_TYPEID_NAME(typeid(T).name())};
        regex.append("\\s*(const\\s*)?\\[([0-9]+)\\]");
        std::regex arrayType(regex);
        std::cmatch cm;
        if (std::regex_match(typeName.c_str(), cm, arrayType)) {
            int size = std::atoi(cm[2].str().c_str());
            if (size <= this->nbElements) {
                size_t result = this->nbElements - size + 1;
                this->cachedAddressSpace.emplace(type, result);
                return result;
            }
        }
        // Default case
        return 0;
    }
 
    template <class T>
    std::vector<size_t> ArrayWrapper<T>::getAddressesAccessed(
        const std::type_info& type, const size_t address) const
    {
        // Initialize the result
        std::vector<size_t> result;
 
        // If the accessed address is valid fill the result.
        const size_t space = this->getAddressSpace(type);
        if (space > address) {
            // For the native type.
            if (type == typeid(T)) {
                result.push_back(address);
            }
            else {
                // Else, the type is the array type.
                for (int i = 0; i < (this->nbElements - space + 1); i++) {
                    result.push_back(address + i);
                }
            }
        }
        return result;
    }
 
    template <class T>
    inline UntypedSharedPtr ArrayWrapper<T>::getDataAt(
        const std::type_info& type, const size_t address) const
    {
        if (this->containerPtr == nullptr) {
            throw std::runtime_error("Null pointer access.");
        }
#ifndef NDEBUG
        // Throw exception in case of invalid arguments.
        checkAddressAndType(type, address);
#endif
 
        if (type == typeid(T)) {
            UntypedSharedPtr result(
                &(this->containerPtr->at(address)),
                UntypedSharedPtr::emptyDestructor<const T>());
            return result;
        }
 
        // Else, the only other supported type is cstyle array.
 
        // Allocate the array
        size_t arraySize = this->nbElements - this->getAddressSpace(type) + 1;
        T* array = new T[arraySize];
 
        // Copy its content
        for (size_t idx = 0; idx < arraySize; idx++) {
            array[idx] = this->containerPtr->at(address + idx);
        }
 
        // Create the UntypedSharedPtr
        UntypedSharedPtr result{
            std::make_shared<UntypedSharedPtr::Model<const T[]>>(array)};
        return result;
    }
 
    template <class T> size_t ArrayWrapper<T>::getLargestAddressSpace() const
    {
        // Currently, largest addres space is for the template Type T.
        return this->nbElements;
    }
 
    template <class T> void ArrayWrapper<T>::invalidateCachedHash()
    {
        this->invalidCachedHash = true;
    }
 
    template <class T> void ArrayWrapper<T>::resetData()
    {
        // Does nothing;
    }
 
    template <class T>
    inline void ArrayWrapper<T>::setPointer(std::vector<T>* ptr)
    {
        // Null ptr case
        if (ptr == nullptr) {
            this->containerPtr = ptr;
            this->invalidCachedHash = true;
            return;
        }
 
        // Else
        // Check the size of the given vector
        if (ptr->size() != nbElements) {
            std::stringstream message;
            message << "Size of pointed data (" << ptr->size()
                    << ") does not correspond to the size of the ArrayWrapper ("
                    << this->nbElements << ").";
            throw std::domain_error(message.str());
        }
 
        // Else
        this->containerPtr = ptr;
        this->invalidCachedHash = true;
    }
 
    template <class T> inline size_t ArrayWrapper<T>::updateHash() const
    {
        // Null pointer case
        if (this->containerPtr == nullptr) {
            return this->cachedHash = 0;
        }
 
        // reset
        this->cachedHash = Data::Hash<size_t>()(this->id);
 
        // hasher
        Data::Hash<T> hasher;
 
        for (T dataElement : *(this->containerPtr)) {
            // Rotate by 1 because otherwise, xor is comutative.
            this->cachedHash =
                (this->cachedHash >> 1) | (this->cachedHash << 63);
            this->cachedHash ^= hasher((T)dataElement);
        }
 
        // Validate the cached hash value
        this->invalidCachedHash = false;
 
        return this->cachedHash;
    }
 
#ifdef CODE_GENERATION
    template <class T>
    const std::type_info& ArrayWrapper<T>::getNativeType() const
    {
        const std::type_info& a = typeid(T);
        return a;
    }
 
    template <class T>
    std::vector<size_t> ArrayWrapper<T>::getDimensionsSize() const
    {
        std::vector<size_t> sizes = {nbElements};
        return sizes;
    }
#endif
 
} // namespace Data
#endif // !ARRAY_WRAPPER_H
 
// Include PrimitiveTypeArray to ensure availability of the used clone method.
#include "data/primitiveTypeArray.h"