flatVector2D.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_FLAT_VECTOR_2D_TPP__
#define __BITPIT_FLAT_VECTOR_2D_TPP__
 
#include <vector>
#include <cassert>
#include <iostream>
#include <memory>
 
#include "binary_stream.hpp"
 
namespace bitpit {
 
template<class T>
OBinaryStream& operator<<(OBinaryStream &buffer, const FlatVector2D<T> &vector)
{
    buffer << vector.m_index;
    buffer << vector.m_v;
 
    return buffer;
}
 
template<class T>
IBinaryStream& operator>>(IBinaryStream &buffer, FlatVector2D<T> &vector)
{
    buffer >> vector.m_index;
    buffer >> vector.m_v;
 
    return buffer;
}
 
template <class T>
FlatVector2D<T>::FlatVector2D(bool initialize)
    : m_index(initialize ? 1 : 0, 0L)
{
}
 
template <class T>
FlatVector2D<T>::FlatVector2D(const std::vector<std::size_t> &sizes, const T &value)
{
    initialize(sizes.size(), sizes.data(), 1, &value, 0);
}
 
template <class T>
FlatVector2D<T>::FlatVector2D(std::size_t nVectors, std::size_t size, const T &value)
{
    initialize(nVectors, &size, 0, &value, 0);
}
 
template <class T>
FlatVector2D<T>::FlatVector2D(std::size_t nVectors, const std::size_t *sizes, const T &value)
{
    initialize(nVectors, sizes, 1, &value, 0);
}
 
template <class T>
FlatVector2D<T>::FlatVector2D(std::size_t nVectors, const std::size_t *sizes, const T *values)
{
    initialize(nVectors, sizes, 1, values, 1);
}
 
template <class T>
FlatVector2D<T>::FlatVector2D(const std::vector<std::vector<T> > &vector2D)
{
    initialize(vector2D);
}
 
template <class T>
bool FlatVector2D<T>::isInitialized() const
{
    return (!m_index.empty());
}
 
template <class T>
void FlatVector2D<T>::initialize(const std::vector<std::size_t> &sizes, const T &value)
{
    initialize(sizes.size(), sizes.data(), 1, &value, 1);
}
 
template <class T>
void FlatVector2D<T>::initialize(std::size_t nVectors, std::size_t size, const T &value)
{
    initialize(nVectors, &size, 0, &value, 0);
}
 
template <class T>
void FlatVector2D<T>::initialize(std::size_t nVectors, const std::size_t *sizes, const T &value)
{
    initialize(nVectors, sizes, 1, &value, 0);
}
 
 
template <class T>
void FlatVector2D<T>::initialize(std::size_t nVectors, const std::size_t *sizes, const T *values)
{
    initialize(nVectors, sizes, 1, values, 1);
}
 
template <class T>
void FlatVector2D<T>::initialize(std::size_t nVectors,
                                 const std::size_t *sizes, std::size_t sizesStride,
                                 const T *values, std::size_t valuesStride)
{
    std::size_t nItems = 0;
    for (std::size_t i = 0; i < nVectors; ++i) {
        nItems += *(sizes + i * sizesStride);
    }
 
    // Check if the container need reallocation
    //
    // If the current number of items is different from the number of items
    // the container should contain after the initialization, a reallocation
    // is needed.
    bool reallocateIndex  = (nVectors != size());
    bool reallocateValues = (nItems != getItemCount());
 
    // Destroy current data structures
    //
    // Index and the storage data will probabily be stored in memory
    // regions contigous to each other. To reduce memory fragmentation
    // it's better to deallocate the container before updating its
    // data structures.
    if (reallocateIndex || reallocateValues) {
        destroy(reallocateIndex, reallocateValues);
    }
 
    // Initialize the indexes
    if (reallocateIndex) {
        m_index.resize(nVectors + 1);
    }
 
    m_index[0] = 0;
    for (std::size_t i = 0; i < nVectors; ++i) {
        m_index[i+1] = m_index[i] + *(sizes + i * sizesStride);
    }
 
    // Initialize the storage
    if (valuesStride == 0) {
        if (reallocateValues) {
            m_v.assign(nItems, *values);
        } else {
            for (std::size_t k = 0; k < nItems; ++k) {
                m_v[k] = *values;
            }
        }
    } else {
        if (reallocateValues) {
            m_v.resize(nItems);
        }
 
        std::size_t k = 0;
        for (std::size_t i = 0; i < nVectors; ++i) {
            std::size_t subArraySize = *(sizes + i * sizesStride);
            for (std::size_t j = 0; j < subArraySize; ++j) {
                m_v[k++] = *(values + i * valuesStride + j);
            }
        }
    }
}
 
template <class T>
void FlatVector2D<T>::initialize(const std::vector<std::vector<T> > &vector2D)
{
    std::size_t nVectors = vector2D.size();
 
    std::size_t nItems = 0;
    for (std::size_t i = 0; i < nVectors; ++i) {
        nItems += vector2D[i].size();
    }
 
    // Check if the container need reallocation
    //
    // If the current number of items is different from the number of items
    // the container should contain after the initialization, a reallocation
    // is needed.
    bool reallocateIndex  = (nVectors != size());
    bool reallocateValues = (nItems != getItemCount());
 
    // Destroy current data structures
    //
    // Index and the storage data will probabily be stored in memory
    // regions contigous to each other. To reduce memory fragmentation
    // it's better to deallocate the container before updating its
    // data structures.
    if (reallocateIndex || reallocateValues) {
        destroy(reallocateIndex, reallocateValues);
    }
 
    // Initialize the indexes
    if (reallocateIndex) {
        m_index.resize(nVectors + 1);
    }
 
    m_index[0] = 0;
    for (std::size_t i = 0; i < nVectors; ++i) {
        m_index[i+1] = m_index[i] + vector2D[i].size();
    }
 
    // Initialize the storage
    if (reallocateValues) {
        m_v.resize(nItems);
    }
 
    std::size_t k = 0;
    for (std::size_t i = 0; i < nVectors; ++i) {
        std::size_t subArraySize = vector2D[i].size();
        for (std::size_t j = 0; j < subArraySize; ++j) {
            m_v[k++] = vector2D[i][j];
        }
    }
}
 
template <class T>
void FlatVector2D<T>::initialize(const FlatVector2D<T> &other)
{
    m_v.assign(other.m_v.begin(), other.m_v.end());
    m_index.assign(other.m_index.begin(), other.m_index.end());
}
 
template <class T>
void FlatVector2D<T>::destroy()
{
    destroy(true, true);
}
 
template <class T>
void FlatVector2D<T>::destroy(bool destroyIndex, bool destroyValues)
{
    if (destroyIndex) {
        m_index.clear();
        m_index.shrink_to_fit();
    }
 
    if (destroyValues) {
        m_v.clear();
        m_v.shrink_to_fit();
    }
}
 
template <class T>
void FlatVector2D<T>::reserve(std::size_t nVectors, std::size_t nItems)
{
    m_index.reserve(nVectors + 1);
    if (nItems > 0) {
        m_v.reserve(nItems);
    }
}
 
template <class T>
void FlatVector2D<T>::swap(FlatVector2D &other) noexcept
{
    m_index.swap(other.m_index);
    m_v.swap(other.m_v);
}
 
template <class T>
void FlatVector2D<T>::fill(T &value)
{
    std::fill(m_v.begin(), m_v.end(), value);
}
 
template <class T>
bool FlatVector2D<T>::operator==(const FlatVector2D& rhs) const
{
    return m_index == rhs.m_index && m_v == rhs.m_v;
}
 
template <class T>
bool FlatVector2D<T>::empty() const
{
    return size() == 0;
}
 
template <class T>
void FlatVector2D<T>::clear(bool release)
{
    if (release) {
        std::vector<T>(0).swap(m_v);
 
        std::vector<size_t>(1, 0L).swap(m_index);
    } else {
        m_v.clear();
 
        m_index.resize(1);
        m_index[0] = 0;
    }
}
 
template <class T>
void FlatVector2D<T>::clearItems(bool release)
{
    std::size_t nVectors = size();
    if (release) {
        std::vector<T>(0).swap(m_v);
 
        std::vector<size_t>(nVectors + 1, 0L).swap(m_index);
    } else {
        m_v.clear();
 
        m_index.assign(nVectors + 1, 0L);
    }
}
 
template <class T>
void FlatVector2D<T>::shrinkToFit()
{
    m_v.shrink_to_fit();
    m_index.shrink_to_fit();
}
 
template <class T>
const std::size_t * FlatVector2D<T>::indices() const noexcept
{
    return m_index.data();
}
 
template <class T>
const std::size_t * FlatVector2D<T>::indices(std::size_t i) const noexcept
{
    return (m_index.data() + i);
}
 
template <class T>
T * FlatVector2D<T>::data() noexcept
{
    return m_v.data();
}
 
template <class T>
const T * FlatVector2D<T>::data() const noexcept
{
    return m_v.data();
}
 
template <class T>
const std::vector<T> & FlatVector2D<T>::vector() const
{
    return m_v;
}
 
template <class T>
void FlatVector2D<T>::pushBack()
{
    pushBack(0);
}
 
template <class T>
void FlatVector2D<T>::pushBack(std::size_t subArraySize, const T &value)
{
    std::size_t previousLastIndex = m_index.back();
    m_index.emplace_back(previousLastIndex + subArraySize);
 
    m_v.resize(m_v.size() + subArraySize, value);
}
 
template <class T>
void FlatVector2D<T>::pushBack(const std::vector<T> &subArray)
{
    pushBack(subArray.size(), subArray.data());
}
 
template <class T>
void FlatVector2D<T>::pushBack(std::size_t subArraySize, const T *subArray)
{
    std::size_t previousLastIndex = m_index.back();
    m_index.emplace_back(previousLastIndex + subArraySize);
 
    m_v.insert(m_v.end(), subArray, subArray + subArraySize);
}
 
template <class T>
void FlatVector2D<T>::pushBackItem(const T& value)
{
    m_index.back()++;
 
    m_v.emplace_back(value);
}
 
template <class T>
void FlatVector2D<T>::pushBackItem(T &&value)
{
    m_index.back()++;
 
    m_v.emplace_back(std::move(value));
}
 
template <class T>
void FlatVector2D<T>::pushBackItem(std::size_t i, const T &value)
{
    assert(isIndexValid(i));
 
    m_v.insert(m_v.begin() + m_index[i+1], value);
 
    std::size_t nIndexes = m_index.size();
    for (std::size_t k = i + 1; k < nIndexes; ++k) {
        m_index[k]++;
    }
}
 
 
template <class T>
void FlatVector2D<T>::pushBackItem(std::size_t i, T &&value)
{
    assert(isIndexValid(i));
 
    m_v.insert(m_v.begin() + m_index[i+1], std::move(value));
 
    std::size_t nIndexes = m_index.size();
    for (std::size_t k = i + 1; k < nIndexes; ++k) {
        m_index[k]++;
    }
}
 
template <class T>
void FlatVector2D<T>::popBack()
{
    if (size() == 0) {
        return;
    }
 
    m_index.pop_back();
    m_v.resize(m_index.back() + 1);
}
 
template <class T>
void FlatVector2D<T>::popBackItem()
{
    if (getItemCount(size() - 1) == 0) {
        return;
    }
 
    m_index.back()--;
    m_v.resize(m_index.back() + 1);
}
 
template <class T>
void FlatVector2D<T>::popBackItem(std::size_t i)
{
    assert(isIndexValid(i));
 
    if (getItemCount(i) == 0) {
        return;
    }
 
    m_v.erase(m_v.begin() + m_index[i+1] - 1);
 
    std::size_t nIndexes = m_index.size();
    for (std::size_t k = i + 1; k < nIndexes; ++k) {
        m_index[k]--;
    }
}
 
template <class T>
void FlatVector2D<T>::erase(std::size_t i)
{
    assert(isIndexValid(i));
 
    m_v.erase(m_v.begin() + m_index[i], m_v.begin() + m_index[i+1] - 1);
    m_index.erase(m_index.begin() + i + 1);
}
 
template <class T>
void FlatVector2D<T>::eraseItem(std::size_t i, std::size_t j)
{
    assert(isIndexValid(i, j));
 
    m_v.erase(m_v.begin() + m_index[i] + j);
 
    std::size_t nIndexes = m_index.size();
    for (std::size_t k = i + 1; k < nIndexes; ++k) {
        m_index[k]--;
    }
}
 
template <class T>
void FlatVector2D<T>::setItem(std::size_t i, std::size_t j, const T &value)
{
    assert(isIndexValid(i, j));
    (*this)[i][j] = value;
}
 
template <class T>
void FlatVector2D<T>::setItem(std::size_t i, std::size_t j, T &&value)
{
    assert(isIndexValid(i, j));
    (*this)[i][j] = std::move(value);
}
 
template <class T>
T & FlatVector2D<T>::getItem(std::size_t i, std::size_t j)
{
    assert(isIndexValid(i, j));
    return (*this)[i][j];
}
 
template <class T>
const T & FlatVector2D<T>::getItem(std::size_t i, std::size_t j) const
{
    assert(isIndexValid(i, j));
    return (*this)[i][j];
}
 
template <class T>
const T * FlatVector2D<T>::get(std::size_t i) const
{
    assert(!empty());
    assert(isIndexValid(i));
    return (*this)[i];
}
 
template <class T>
T * FlatVector2D<T>::get(std::size_t i)
{
    assert(!empty());
    assert(isIndexValid(i));
    return (*this)[i];
}
 
template <class T>
void FlatVector2D<T>::rawSetItem(std::size_t k, const T &value)
{
    m_v[k] = value;
}
 
template <class T>
void FlatVector2D<T>::rawSetItem(std::size_t k, T &&value)
{
    m_v[k] = std::move(value);
}
 
template <class T>
T & FlatVector2D<T>::rawGetItem(std::size_t k)
{
    return m_v[k];
}
 
template <class T>
const T & FlatVector2D<T>::rawGetItem(std::size_t k) const
{
    return m_v[k];
}
 
template <class T>
T * FlatVector2D<T>::back()
{
    return get(size() - 1);
}
 
template <class T>
T * FlatVector2D<T>::first()
{
    return get(0);
}
 
template <class T>
std::size_t FlatVector2D<T>::size() const
{
    if (!isInitialized()) {
        return 0;
    }
 
    return (m_index.size() - 1);
}
 
template <class T>
std::size_t FlatVector2D<T>::capacity() const
{
    if (!isInitialized()) {
        return 0;
    }
 
    return m_index.capacity() - 1;
}
 
template <class T>
void FlatVector2D<T>::merge()
{
    if (size() == 0) {
        return;
    }
 
    m_index[1] = m_index.back();
    m_index.resize(2);
}
 
template <class T>
std::size_t FlatVector2D<T>::getItemCount() const
{
    if (!isInitialized()) {
        return 0;
    }
 
    return m_v.size();
}
 
template <class T>
std::size_t FlatVector2D<T>::getItemCount(std::size_t i) const
{
    if (!isInitialized()) {
        return 0;
    }
 
    return m_index[i + 1] - m_index[i];
}
 
template <class T>
std::size_t FlatVector2D<T>::getItemCapacity() const
{
    return m_v.capacity();
}
 
template <class T>
size_t FlatVector2D<T>::getBinarySize() const
{
    return ((2 + m_index.size())*sizeof(size_t) + m_v.size() * sizeof(T));
}
 
template <class T>
const T* FlatVector2D<T>::operator[](std::size_t i) const
{
    assert(isIndexValid(i));
 
    if (m_v.empty()) {
        return nullptr;
    }
 
    std::size_t index = m_index[i];
    return &m_v[index];
}
 
template <class T>
T* FlatVector2D<T>::operator[](std::size_t i)
{
    assert(isIndexValid(i));
 
    if (m_v.empty()) {
        return nullptr;
    }
 
    std::size_t index = m_index[i];
    return &m_v[index];
}
 
template <class T>
bool FlatVector2D<T>::isIndexValid(std::size_t i) const
{
    return (i < size());
}
 
template <class T>
bool FlatVector2D<T>::isIndexValid(std::size_t i, std::size_t j) const
{
    if (!isIndexValid(i)) {
        return false;
    }
 
    return (j < (m_index[i+1] - m_index[i]));
}
 
}
 
#endif