pointer_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_POINTER_VECTOR_H
#define VCL_SPACE_CORE_VECTOR_POINTER_VECTOR_H
 
#include "vector.h"
 
#include <vclib/concepts/pointers.h>
#include <vclib/misc/iterators/const_pointer_iterator.h>
 
namespace vcl {
 
template<IsAnyPointer T, int N = -1>
class PointerVector : protected Vector<T, N>
{
    using Base = Vector<T, N>;
 
public:
    // types
    using ValueType = Base::ValueType;
 
    using ConstValueType = MakeConstPointerT<ValueType>;
 
    using Reference = Base::Reference;
 
    using ConstPointer = const ConstValueType*;
 
    using Pointer = Base::Pointer;
 
    using Iterator = Base::Iterator;
 
    using ConstIterator = ConstPointerIterator<typename Base::ConstIterator>;
 
    using Base::SIZE;
 
    // constructors
    using Base::Vector;
 
    // exposing members of base class, later we will redefine const member
    // functions
    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;
 
    // const member function redefinitions: return types change to const
 
    ConstValueType at(uint i) const { return Base::at(i); }
 
    ConstValueType atMod(uint i) const { return Base::atMod(i); }
 
    ConstValueType front() const { return Base::front(); }
 
    ConstValueType back() const { return Base::back(); }
 
    ConstPointer data() const { return Base::data(); }
 
    ConstIterator find(const MakeConstPointer<T>& e) const
    {
        return Base::find(e);
    }
 
    ConstValueType operator[](uint i) const { return Base::operator[](i); }
 
    ConstValueType operator()(uint i) const { return Base::operator()(i); }
 
    ConstIterator begin() const { return Base::begin(); }
 
    ConstIterator end() const { return Base::end(); }
};
 
} // namespace vcl
 
#endif // VCL_SPACE_CORE_VECTOR_POINTER_VECTOR_H