proxyVector.tpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __BITPIT_PROXY_VECTOR_TPP__
#define __BITPIT_PROXY_VECTOR_TPP__
 
namespace bitpit {
 
template<typename value_t, typename container_t>
ProxyVectorIterator<value_t, container_t>::ProxyVectorIterator()
    : m_position(nullptr)
{
}
 
template<typename value_t, typename container_t>
template<typename other_value_t, typename std::enable_if<std::is_const<value_t>::value && !std::is_const<other_value_t>::value && std::is_same<other_value_t, typename std::remove_cv<value_t>::type>::value, int>::type>
ProxyVectorIterator<value_t, container_t>::ProxyVectorIterator(const ProxyVectorIterator<other_value_t, container_t> &other)
    : m_position(other.m_position)
{
}
 
template<typename value_t, typename container_t>
void ProxyVectorIterator<value_t, container_t>::swap(ProxyVectorIterator& other) noexcept
{
    std::swap(m_position, other.m_position);
}
 
template<typename value_t, typename container_t>
ProxyVectorIterator<value_t, container_t> & ProxyVectorIterator<value_t, container_t>::operator++()
{
    m_position++;
 
    return *this;
}
 
template<typename value_t, typename container_t>
ProxyVectorIterator<value_t, container_t> ProxyVectorIterator<value_t, container_t>::operator++(int)
{
    ProxyVectorIterator tmp(m_position);
 
    ++(*this);
 
    return tmp;
}
 
template<typename value_t, typename container_t>
ProxyVectorIterator<value_t, container_t> & ProxyVectorIterator<value_t, container_t>::operator--()
{
    m_position--;
 
    return *this;
}
 
template<typename value_t, typename container_t>
ProxyVectorIterator<value_t, container_t> ProxyVectorIterator<value_t, container_t>::operator--(int)
{
    ProxyVectorIterator tmp(m_position);
 
    --(*this);
 
    return tmp;
}
 
template<typename value_t, typename container_t>
ProxyVectorIterator<value_t, container_t>& ProxyVectorIterator<value_t, container_t>::operator+=(int increment)
{
    m_position += increment;
 
    return *this;
}
 
template<typename value_t, typename container_t>
__PXI_REFERENCE__ ProxyVectorIterator<value_t, container_t>::operator*() const
{
    return *m_position;
}
 
template<typename value_t, typename container_t>
__PXI_POINTER__ ProxyVectorIterator<value_t, container_t>::operator->() const
{
    return m_position;
}
 
template<typename value_t, typename container_t>
template<typename other_value_t, typename std::enable_if<std::is_const<value_t>::value && !std::is_const<other_value_t>::value && std::is_same<other_value_t, typename std::remove_cv<value_t>::type>::value, int>::type>
ProxyVectorIterator<value_t, container_t> & ProxyVectorIterator<value_t, container_t>::operator=(const ProxyVectorIterator<other_value_t, container_t> &other)
{
    m_position = other.m_position;
 
    return *this;
}
 
template<typename value_t, typename container_t>
ProxyVectorIterator<value_t, container_t>::ProxyVectorIterator(__PXI_POINTER__ position)
    : m_position(position)
{
}
 
template<typename value_t, typename container_t>
std::size_t ProxyVectorIterator<value_t, container_t>::operator-(const ProxyVectorIterator &other)
{
    return (m_position - other.m_position);
}
 
template<typename value_t, typename pointer_t, typename const_pointer_t>
ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::ProxyVectorDummyStorage(std::size_t size)
{
    BITPIT_UNUSED(size);
}
 
template<typename value_t, typename pointer_t, typename const_pointer_t>
void ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::swap(ProxyVectorDummyStorage &other) noexcept
{
    BITPIT_UNUSED(other);
}
 
template<typename value_t, typename pointer_t, typename const_pointer_t>
typename ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::pointer ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::data()
{
    return nullptr;
}
 
template<typename value_t, typename pointer_t, typename const_pointer_t>
typename ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::const_pointer ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::data() const
{
    return nullptr;
}
 
template<typename value_t, typename pointer_t, typename const_pointer_t>
bool ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::empty() const
{
    return true;
}
 
template<typename value_t, typename pointer_t, typename const_pointer_t>
std::size_t ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::size() const
{
    return 0;
}
 
template<typename value_t, typename pointer_t, typename const_pointer_t>
void ProxyVectorDummyStorage<value_t, pointer_t, const_pointer_t>::resize(std::size_t size)
{
    BITPIT_UNUSED(size);
}
 
template<typename value_t, typename container_t, bool thread_safe>
std::vector<std::unique_ptr<container_t>> ProxyVectorStorage<value_t, container_t, thread_safe>::m_containerPool = std::vector<std::unique_ptr<container_t>>();
 
template<typename value_t, typename container_t, bool thread_safe>
std::unique_ptr<container_t> ProxyVectorStorage<value_t, container_t, thread_safe>::createContainer(std::size_t size, bool allowEmpty)
{
    if (size == 0 && !allowEmpty) {
        return std::unique_ptr<container_t>(nullptr);
    }
 
    if (!thread_safe) {
        if (!m_containerPool.empty()) {
            std::unique_ptr<container_t> container = std::move(m_containerPool.back());
            if (container->size() < size) {
                container->resize(size);
            }
 
            m_containerPool.resize(m_containerPool.size() - 1);
 
            return container;
        } else {
            return std::unique_ptr<container_t>(new container_t(size));
        }
    } else {
        return std::unique_ptr<container_t>(new container_t(size));
    }
}
 
template<typename value_t, typename container_t, bool thread_safe>
std::unique_ptr<container_t> ProxyVectorStorage<value_t, container_t, thread_safe>::createContainer(const std::unique_ptr<container_t> &source, bool allowEmpty)
{
    if (!source || source->empty()) {
        if (allowEmpty) {
            return createContainer(0, true);
        } else {
            return std::unique_ptr<container_t>(nullptr);
        }
    }
 
    if (!thread_safe) {
        if (!m_containerPool.empty()) {
            std::unique_ptr<container_t> container = createContainer(source->size(), false);
            std::copy_n(source->data(), source->size(), container->data());
 
            return container;
        } else {
            return std::unique_ptr<container_t>(new container_t(*source));
        }
    } else {
        return std::unique_ptr<container_t>(new container_t(*source));
    }
}
 
template<typename value_t, typename container_t, bool thread_safe>
void ProxyVectorStorage<value_t, container_t, thread_safe>::destroyContainer(std::unique_ptr<container_t> *container)
{
    if (!(*container)) {
        return;
    }
 
    if (!thread_safe) {
        if (m_containerPool.size() < MEMORY_POOL_VECTOR_COUNT) {
            if ((*container)->size() > MEMORY_POOL_MAX_CAPACITY) {
                (*container)->resize(MEMORY_POOL_MAX_CAPACITY);
            }
 
            m_containerPool.emplace_back(std::move(*container));
            container->reset();
        }
    }
}
 
template<typename value_t, typename container_t, bool thread_safe>
ProxyVectorStorage<value_t, container_t, thread_safe>::ProxyVectorStorage(std::size_t size)
    : m_container(createContainer(size, false))
{
}
 
template<typename value_t, typename container_t, bool thread_safe>
ProxyVectorStorage<value_t, container_t, thread_safe>::ProxyVectorStorage(const ProxyVectorStorage<value_t, container_t, thread_safe> &other)
    : m_container(createContainer(other.m_container, false))
{
}
 
template<typename value_t, typename container_t, bool thread_safe>
ProxyVectorStorage<value_t, container_t, thread_safe> & ProxyVectorStorage<value_t, container_t, thread_safe>::operator=(const ProxyVectorStorage<value_t, container_t, thread_safe> &other)
{
    ProxyVectorStorage<value_t, container_t, thread_safe> temporary(other);
    this->swap(temporary);
 
    return *this;
}
 
template<typename value_t, typename container_t, bool thread_safe>
ProxyVectorStorage<value_t, container_t, thread_safe>::~ProxyVectorStorage()
{
    destroyContainer(&m_container);
}
 
template<typename value_t, typename container_t, bool thread_safe>
container_t * ProxyVectorStorage<value_t, container_t, thread_safe>::container(bool forceCreation)
{
    if (!m_container && forceCreation) {
        m_container = createContainer(0, true);
    }
 
    return m_container.get();
}
 
template<typename value_t, typename container_t, bool thread_safe>
const container_t * ProxyVectorStorage<value_t, container_t, thread_safe>::container(bool forceCreation) const
{
    if (!m_container && forceCreation) {
        m_container = createContainer(0, true);
    }
 
    return m_container.get();
}
 
template<typename value_t, typename container_t, bool thread_safe>
void ProxyVectorStorage<value_t, container_t, thread_safe>::swap(ProxyVectorStorage &other) noexcept
{
    m_container.swap(other.m_container);
}
 
template<typename value_t, typename container_t, bool thread_safe>
typename ProxyVectorStorage<value_t, container_t, thread_safe>::pointer ProxyVectorStorage<value_t, container_t, thread_safe>::data()
{
    if (empty()) {
        return nullptr;
    }
 
    return m_container->data();
}
 
template<typename value_t, typename container_t, bool thread_safe>
typename ProxyVectorStorage<value_t, container_t, thread_safe>::const_pointer ProxyVectorStorage<value_t, container_t, thread_safe>::data() const
{
    if (empty()) {
        return nullptr;
    }
 
    return m_container->data();
}
 
template<typename value_t, typename container_t, bool thread_safe>
bool ProxyVectorStorage<value_t, container_t, thread_safe>::empty() const
{
    if (!m_container) {
        return true;
    }
 
    return m_container->empty();
}
 
template<typename value_t, typename container_t, bool thread_safe>
std::size_t ProxyVectorStorage<value_t, container_t, thread_safe>::size() const
{
    if (!m_container) {
        return 0;
    }
 
    return m_container->size();
}
 
template<typename value_t, typename container_t, bool thread_safe>
void ProxyVectorStorage<value_t, container_t, thread_safe>::resize(std::size_t size)
{
    if (size == 0) {
        destroyContainer(&m_container);
        return;
 
    }
 
    if (m_container) {
        m_container->resize(size);
    } else {
        m_container = createContainer(size, false);
    }
}
 
template<typename value_t, bool thread_safe>
ProxyVector<value_t, thread_safe>::ProxyVector()
    : m_size(0), m_data(nullptr)
{
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<std::is_const<other_value_t>::value, int>::type>
ProxyVector<value_t, thread_safe>::ProxyVector(std::size_t size)
    : ProxyVector<value_t, thread_safe>(INTERNAL_STORAGE, size, size)
{
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<std::is_const<other_value_t>::value, int>::type>
ProxyVector<value_t, thread_safe>::ProxyVector(std::size_t size, std::size_t capacity)
    : ProxyVector<value_t, thread_safe>::ProxyVector(INTERNAL_STORAGE, size, capacity)
{
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<std::is_const<other_value_t>::value, int>::type>
ProxyVector<value_t, thread_safe>::ProxyVector(__PXV_POINTER__ data, std::size_t size)
    : ProxyVector<value_t, thread_safe>::ProxyVector(data, size, (data != INTERNAL_STORAGE) ? 0 : size)
{
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<std::is_const<other_value_t>::value, int>::type>
ProxyVector<value_t, thread_safe>::ProxyVector(__PXV_POINTER__ data, std::size_t size, std::size_t capacity)
    : m_storage(capacity), m_size(size), m_data((data != INTERNAL_STORAGE) ? data : m_storage.data())
{
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
ProxyVector<value_t, thread_safe>::ProxyVector(__PXV_POINTER__ data, std::size_t size)
    : m_storage(0), m_size(size), m_data(data)
{
    assert(data != INTERNAL_STORAGE);
}
 
template<typename value_t, bool thread_safe>
ProxyVector<value_t, thread_safe>::ProxyVector(const ProxyVector &other)
    : m_storage(other.m_storage), m_size(other.m_size), m_data(other.storedData() ? m_storage.data() : other.m_data)
{
}
 
template<typename value_t, bool thread_safe>
ProxyVector<value_t, thread_safe>::ProxyVector(ProxyVector &&other)
    : m_storage(std::move(other.m_storage)), m_size(std::move(other.m_size)), m_data(std::move(other.m_data))
{
}
 
template<typename value_t, bool thread_safe>
ProxyVector<value_t, thread_safe> & ProxyVector<value_t, thread_safe>::operator=(const ProxyVector &other)
{
    if (this != &other) {
        ProxyVector temporary(other);
        temporary.swap(*this);
    }
 
    return *this;
}
 
template<typename value_t, bool thread_safe>
ProxyVector<value_t, thread_safe> & ProxyVector<value_t, thread_safe>::operator=(ProxyVector &&other)
{
    if (this != &other) {
        ProxyVector temporary(std::move(other));
        temporary.swap(*this);
    }
 
    return *this;
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<std::is_const<other_value_t>::value, int>::type>
void ProxyVector<value_t, thread_safe>::set(__PXV_POINTER__ data, std::size_t size)
{
    std::size_t capacity;
    if (data != INTERNAL_STORAGE) {
        capacity = 0;
    } else {
        capacity = size;
    }
    set(data, size, capacity);
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<std::is_const<other_value_t>::value, int>::type>
void ProxyVector<value_t, thread_safe>::set(__PXV_POINTER__ data, std::size_t size, std::size_t capacity)
{
    m_storage.resize(std::max(size, capacity));
 
    m_size = size;
    if (data == INTERNAL_STORAGE) {
        if (m_size == 0) {
            m_data = nullptr;
        } else {
            m_data = m_storage.data();
        }
    } else {
        m_data = data;
    }
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
void ProxyVector<value_t, thread_safe>::set(__PXV_POINTER__ data, std::size_t size)
{
    assert(data != INTERNAL_STORAGE);
 
    m_storage.resize(0);
 
    m_size = size;
    m_data = data;
}
 
template<typename value_t, bool thread_safe>
__PXV_STORAGE_POINTER__ ProxyVector<value_t, thread_safe>::storedData() noexcept
{
    __PXV_STORAGE_POINTER__ internalData = m_storage.data();
    if (!internalData) {
        return nullptr;
    } else if (internalData != m_data) {
        return nullptr;
    }
 
    return internalData;
}
 
template<typename value_t, bool thread_safe>
__PXV_STORAGE_CONST_POINTER__ ProxyVector<value_t, thread_safe>::storedData() const noexcept
{
    __PXV_STORAGE_CONST_POINTER__ internalData = m_storage.data();
    if (!internalData) {
        return nullptr;
    } else if (internalData != m_data) {
        return nullptr;
    }
 
    return internalData;
}
 
template<typename value_t, bool thread_safe>
template<typename U, typename std::enable_if<std::is_const<U>::value, int>::type>
typename ProxyVector<value_t, thread_safe>::container_type * ProxyVector<value_t, thread_safe>::storedDataContainer(bool forceCreation)
{
    return m_storage.container(forceCreation);
}
 
template<typename value_t, bool thread_safe>
template<typename U, typename std::enable_if<std::is_const<U>::value, int>::type>
const typename ProxyVector<value_t, thread_safe>::container_type * ProxyVector<value_t, thread_safe>::storedDataContainer(bool forceCreation) const
{
    return m_storage.container(forceCreation);
}
 
template<typename value_t, bool thread_safe>
void ProxyVector<value_t, thread_safe>::swap(ProxyVector &other)
{
    std::swap(m_size, other.m_size);
    std::swap(m_data, other.m_data);
 
    m_storage.swap(other.m_storage);
}
 
template<typename value_t, bool thread_safe>
bool ProxyVector<value_t, thread_safe>::operator==(const ProxyVector& other) const
{
    if (m_size != other.m_size) {
        return false;
    }
 
    if (!storedData() && !other.storedData()) {
        if (m_data != other.m_data) {
            return false;
        }
    }
 
    for (std::size_t i = 0; i < m_size; ++i) {
        if (m_data[i] != other.m_data[i]) {
            return false;
        }
    }
 
    return true;
}
 
template<typename value_t, bool thread_safe>
bool ProxyVector<value_t, thread_safe>::empty() const
{
    return size() == 0;
}
 
template<typename value_t, bool thread_safe>
std::size_t ProxyVector<value_t, thread_safe>::size() const
{
    return m_size;
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
__PXV_POINTER__ ProxyVector<value_t, thread_safe>::data() noexcept
{
    return m_data;
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_POINTER__ ProxyVector<value_t, thread_safe>::data() const noexcept
{
    return m_data;
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
__PXV_REFERENCE__ ProxyVector<value_t, thread_safe>::operator[](std::size_t n)
{
    return m_data[n];
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_REFERENCE__ ProxyVector<value_t, thread_safe>::operator[](std::size_t n) const
{
    return m_data[n];
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
__PXV_REFERENCE__ ProxyVector<value_t, thread_safe>::at(std::size_t n)
{
    return m_data[n];
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_REFERENCE__ ProxyVector<value_t, thread_safe>::at(std::size_t n) const
{
    return m_data[n];
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
__PXV_REFERENCE__ ProxyVector<value_t, thread_safe>::front()
{
    return m_data[0];
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_REFERENCE__ ProxyVector<value_t, thread_safe>::front() const
{
    return m_data[0];
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
__PXV_REFERENCE__ ProxyVector<value_t, thread_safe>::back()
{
    return m_data[m_size - 1];
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_REFERENCE__ ProxyVector<value_t, thread_safe>::back() const
{
    return m_data[m_size - 1];
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
__PXV_ITERATOR__ ProxyVector<value_t, thread_safe>::begin()
{
    return iterator(m_data);
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_ITERATOR__ ProxyVector<value_t, thread_safe>::begin() const
{
    return const_iterator(m_data);
}
 
template<typename value_t, bool thread_safe>
template<typename other_value_t, typename std::enable_if<!std::is_const<other_value_t>::value, int>::type>
__PXV_ITERATOR__ ProxyVector<value_t, thread_safe>::end()
{
    return iterator(m_data + m_size);
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_ITERATOR__ ProxyVector<value_t, thread_safe>::end() const
{
    return const_iterator(m_data + m_size);
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_ITERATOR__ ProxyVector<value_t, thread_safe>::cbegin()
{
    return const_iterator(m_data);
}
 
template<typename value_t, bool thread_safe>
__PXV_CONST_ITERATOR__ ProxyVector<value_t, thread_safe>::cend()
{
    return const_iterator(m_data + m_size);
}
 
}
 
#endif