polymorphic_object_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_POLYMORPHIC_OBJECT_VECTOR_H
#define VCL_SPACE_CORE_VECTOR_POLYMORPHIC_OBJECT_VECTOR_H
 
#include "pointer_vector.h"
 
namespace vcl {
 
template<Cloneable T, int N = -1>
class PolymorphicObjectVector : protected PointerVector<std::shared_ptr<T>, N>
{
    using Base       = PointerVector<std::shared_ptr<T>, N>;
    using BaseVector = Base::Vector;
 
public:
    // types
    using ValueType = Base::ValueType;
 
    using ConstValueType = Base::ConstValueType;
 
    // the iterator of this vector is the const iterator of the base Vector
    // because we don't want to allow to modify the shared pointers contained
    // in the vector, but allow only to modify the objects pointed by the shared
    // pointers
    using Iterator = BaseVector::ConstIterator;
 
    // the const iterator of this vector is the const iterator of the
    // PointerVector, which transforms pointers to const pointers
    using ConstIterator = Base::ConstIterator;
 
    using Base::SIZE;
 
    // constructors
    using Base::Base;
 
    // exposing members of base class, later we will redefine non-const members
    // that should return values instead of references, and functions that
    // allow to set directly shared pointers
    using Base::at;
    using Base::atMod;
    using Base::back;
    using Base::clear;
    using Base::contains;
    using Base::data;
    using Base::empty;
    using Base::erase;
    using Base::fill;
    using Base::find;
    using Base::front;
    using Base::indexOf;
    using Base::insert;
    using Base::pushBack;
    using Base::resize;
    using Base::set;
    using Base::size;
    using Base::swap;
    using Base::operator[];
    using Base::operator();
    using Base::begin;
    using Base::end;
 
    PolymorphicObjectVector(const PolymorphicObjectVector& other)
    {
        if constexpr (N < 0) {
            Base::resize(other.size());
        }
        std::transform(
            other.begin(), other.end(), Base::begin(), [](const auto& e) {
                return e->clone();
            });
    }
 
    PolymorphicObjectVector(PolymorphicObjectVector&& other) noexcept
    {
        swap(other);
    }
 
    PolymorphicObjectVector(std::size_t size, const T& value)
    {
        if constexpr (N >= 0) {
            if (size != N) {
                throw WrongSizeException(
                    "Vector must have " + std::to_string(N) + " size.");
            }
            fill(value);
        }
        else {
            resize(size, value);
        }
    }
 
    template<typename ItType>
    PolymorphicObjectVector(ItType first, ItType last)
    {
        set(View(first, last));
    }
 
    template<Range RangeType>
    PolymorphicObjectVector(RangeType&& rng)
    {
        set(rng);
    }
 
    ValueType at(uint i) { return Base::at(i); }
 
    ValueType atMod(int i) { return Base::atMod(i); }
 
    ValueType front() { return Base::front(); }
 
    ValueType back() { return Base::back(); }
 
    void set(uint i, const T& e)
    {
        assert(i < Base::size());
        Base::at(i) = e.clone();
    }
 
    void set(Base::ConstIterator it, const T& e)
    {
        assert(it < Base::end());
        Base::at(it - Base::begin()) = e.clone();
    }
 
    template<Range Rng>
    void set(Rng&& r) requires InputRange<Rng, T>
    {
        uint n = std::ranges::distance(r);
 
        if constexpr (N >= 0) {
            n = std::min((uint) N, n);
        }
        else {
            Base::resize(n);
        }
 
        // for each element in the range, clone it and store it in the
        // vector
        std::transform(
            std::ranges::begin(r),
            std::ranges::begin(r) + n,
            Base::begin(),
            [](const auto& e) {
                return e.clone();
            });
    }
 
    void fill(const T& e)
    {
        for (uint i = 0; i < size(); i++) {
            Base::at(i) = e.clone();
        }
    }
 
    /* Member functions specific for dynamic vector */
 
    void resize(uint n, const T& v) requires (N < 0)
    {
        if (n > Base::size()) {
            uint oldSize = Base::size();
            Base::resize(n);
            for (uint i = oldSize; i < n; i++) {
                Base::at(i) = v.clone();
            }
        }
        else {
            Base::resize(n);
        }
    }
 
    void pushBack(const T& v) requires (N < 0) { Base::pushBack(v.clone()); }
 
    void pushBack(T&& v) requires (N < 0)
    {
        Base::pushBack(std::move(v).clone());
    }
 
    void insert(uint i, const T& v) requires (N < 0)
    {
        assert(i < Base::size() + 1);
        Base::insert(i, v.clone());
    }
 
    void insert(uint i, T&& v) requires (N < 0)
    {
        assert(i < Base::size() + 1);
        Base::insert(i, std::move(v).clone());
    }
 
    void swap(PolymorphicObjectVector& other) { Base::swap(other); }
 
    friend void swap(PolymorphicObjectVector& a, PolymorphicObjectVector& b)
    {
        a.swap(b);
    }
 
    /* Operators */
 
    ValueType operator[](uint i) { return Base::operator[](i); }
 
    ValueType operator()(uint i) { return Base::operator()(i); }
 
    PolymorphicObjectVector& operator=(PolymorphicObjectVector other)
    {
        swap(other);
        return *this;
    }
 
    /* Iterator member functions */
 
    Iterator begin() { return Base::begin(); }
 
    Iterator end() { return Base::end(); }
};
 
} // namespace vcl
 
#endif // VCL_SPACE_CORE_VECTOR_POLYMORPHIC_OBJECT_VECTOR_H