vector.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program 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              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_SPACE_CORE_VECTOR_VECTOR_H
#define VCL_SPACE_CORE_VECTOR_VECTOR_H
 
#include <vclib/concepts/ranges/range.h>
#include <vclib/exceptions.h>
#include <vclib/io/serialization.h>
#include <vclib/types.h>
 
#include <algorithm>
#include <array>
#include <cassert>
#include <string>
#include <utility>
#include <vector>
 
namespace vcl {
 
template<typename T, int N>
class Vector
{
    // if we use the vector, the size of the array will be 0
    // actually the array will never be used and will not use memory, it's just
    // for declaration
    static const int ARRAY_SIZE = N >= 0 ? N : 0;
 
    // the Container type will be array or vector, depending on N value
    using Container = std::conditional_t<
        (N >= 0),
        typename std::array<T, ARRAY_SIZE>,
        typename std::vector<T>>;
 
protected:
    Container mContainer;
 
public:
    using ValueType = Container::value_type;
 
    using ConstReference = Container::const_reference;
 
    using Reference = Container::reference;
 
    using ConstPointer = Container::const_pointer;
 
    using Pointer = Container::pointer;
 
    using Iterator = Container::iterator;
 
    using ConstIterator = Container::const_iterator;
 
    static const int SIZE = N;
 
    Vector() = default;
 
    Vector(std::size_t size, const T& value = T())
    {
        if constexpr (N >= 0) {
            if (size != N) {
                throw WrongSizeException(
                    "Vector must have " + std::to_string(N) + " size.");
            }
            fill(value);
        }
        else {
            mContainer.resize(size, value);
        }
    }
 
    template<typename ItType>
    Vector(ItType first, ItType last)
    {
        set(View(first, last));
    }
 
    template<Range RangeType>
    Vector(RangeType&& rng)
    {
        set(rng);
    }
 
    explicit Vector(std::initializer_list<T> list)
    {
        set(View(std::begin(list), std::end(list)));
    }
 
    std::size_t size() const
    {
        if constexpr (N >= 0) {
            return N;
        }
        else {
            return mContainer.size();
        }
    }
 
    Reference at(uint i) { return mContainer.at(i); }
 
    ConstReference at(uint i) const { return mContainer.at(i); }
 
    Reference atMod(int i)
    {
        int n = size(); // need to save n as int to avoid unwanted casts
        return mContainer[(i % n + n) % n];
    }
 
    ConstReference atMod(int i) const
    {
        int n = size(); // need to save n as int to avoid unwanted casts
        return mContainer[(i % n + n) % n];
    }
 
    Reference front() { return mContainer.front(); }
 
    ConstReference front() const { return mContainer.front(); }
 
    Reference back() { return mContainer.back(); }
 
    ConstReference back() const { return mContainer.back(); }
 
    Pointer data() { return mContainer.data(); }
 
    ConstPointer data() const { return mContainer.data(); }
 
    void set(uint i, const T& e)
    {
        assert(i < size());
        mContainer[i] = e;
    }
 
    void set(uint i, T&& e)
    {
        assert(i < size());
        mContainer[i] = std::move(e);
    }
 
    void set(ConstIterator it, const T& e)
    {
        assert(it < end());
        mContainer[it - begin()] = e;
    }
 
    void set(ConstIterator it, T&& e)
    {
        assert(it < end());
        mContainer[it - begin()] = std::move(e);
    }
 
    template<Range Rng>
    void set(Rng&& r) requires InputRange<Rng, T>
    {
        if constexpr (N >= 0) {
            uint n = std::min(
                N,
                (int) std::distance(
                    std::ranges::begin(r), std::ranges::end(r)));
            std::copy_n(std::ranges::begin(r), n, mContainer.begin());
        }
        else {
            mContainer =
                std::vector<T>(std::ranges::begin(r), std::ranges::end(r));
        }
    }
 
    void fill(const T& e)
    {
        std::fill(mContainer.begin(), mContainer.end(), e);
    }
 
    bool contains(const MakeConstPointerT<T>& e) const
    {
        return std::find(mContainer.begin(), mContainer.end(), e) !=
               mContainer.end();
    }
 
    Iterator find(const MakeConstPointerT<T>& e)
    {
        return std::find(mContainer.begin(), mContainer.end(), e);
    }
 
    ConstIterator find(const MakeConstPointerT<T>& e) const
    {
        return std::find(mContainer.begin(), mContainer.end(), e);
    }
 
    uint indexOf(const MakeConstPointerT<T>& e) const
    {
        auto it = find(e);
        if (it == end())
            return UINT_NULL;
        else
            return it - begin();
    }
 
    void swap(Vector& other) { mContainer.swap(other.mContainer); }
 
    friend void swap(Vector& a, Vector& b) { a.swap(b); }
 
    /* Member functions specific for dynamic vector */
 
    void resize(uint n, const T& v = T()) requires (N < 0)
    {
        mContainer.resize(n, v);
    }
 
    void pushBack(const T& v) requires (N < 0) { mContainer.push_back(v); }
 
    void pushBack(T&& v) requires (N < 0)
    {
        mContainer.push_back(std::move(v));
    }
 
    void insert(uint i, const T& v) requires (N < 0)
    {
        assert(i < size() + 1);
        mContainer.insert(mContainer.begin() + i, v);
    }
 
    void insert(uint i, T&& v) requires (N < 0)
    {
        assert(i < size() + 1);
        mContainer.insert(mContainer.begin() + i, std::move(v));
    }
 
    template<typename... Args>
    void emplace(uint i, Args&&... args) requires (N < 0)
    {
        assert(i < size() + 1);
        mContainer.emplace(mContainer.begin() + i, std::forward<Args>(args)...);
    }
 
    bool empty() const noexcept { return mContainer.empty(); }
 
    void erase(uint i) requires (N < 0)
    {
        assert(i < size());
        mContainer.erase(mContainer.begin() + i);
    }
 
    void clear() requires (N < 0) { mContainer.clear(); }
 
    void serialize(std::ostream& os) const { vcl::serialize(os, mContainer); }
 
    void deserialize(std::istream& is) { vcl::deserialize(is, mContainer); }
 
    /* Operators */
 
    Reference operator[](uint i) { return mContainer[i]; }
 
    ConstReference operator[](uint i) const { return mContainer[i]; }
 
    Reference operator()(uint i) { return mContainer[i]; }
 
    ConstReference operator()(uint i) const { return mContainer[i]; }
 
    /* Iterator member functions */
 
    Iterator begin() { return mContainer.begin(); }
 
    Iterator end() { return mContainer.end(); }
 
    ConstIterator begin() const { return mContainer.begin(); }
 
    ConstIterator end() const { return mContainer.end(); }
};
 
} // namespace vcl
 
#endif // VCL_SPACE_CORE_VECTOR_VECTOR_H