MRVector.h

Go to the documentation of this file.

#pragma once
 
#include "MRMacros.h"
#include "MRMeshFwd.h"
#include "MRResizeNoInit.h"
#include "MRPch/MRBindingMacros.h"
#include <cassert>
 
namespace MR
{
 

template <typename T, typename I>
class Vector
{
public:
    using value_type = typename std::vector<T>::value_type;
    using reference = typename std::vector<T>::reference;
    using const_reference = typename std::vector<T>::const_reference;
    using iterator = typename std::vector<T>::iterator;
    using const_iterator = typename std::vector<T>::const_iterator;

    Vector() = default;

    explicit Vector( size_t size ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::default_initializable<T> ) : vec_( size ) { }

    explicit Vector( size_t size, const T & val ) : vec_( size, val ) { }

    Vector( std::vector<T> && vec ) : vec_( std::move( vec ) ) { }
 
    template< class InputIt >
    Vector( InputIt first, InputIt last ) : vec_( first, last ) { }
 
    Vector( std::initializer_list<T> init ) : vec_( init ) { }
 
    [[nodiscard]] bool operator == ( const Vector & b ) const MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::equality_comparable<T> ) { return vec_ == b.vec_; }
    [[nodiscard]] bool operator != ( const Vector & b ) const MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::equality_comparable<T> ) { return vec_ != b.vec_; }
 
    void clear() { vec_.clear(); }
 
    [[nodiscard]] bool empty() const { return vec_.empty(); }
 
    [[nodiscard]] std::size_t size() const { return vec_.size(); }
 
    void resize( size_t newSize ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::movable<T> && std::default_initializable<T> ) { vec_.resize( newSize ); }
    void resize( size_t newSize, const T & t ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::movable<T> ) { vec_.resize( newSize, t ); }

    void resizeNoInit( size_t targetSize ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::constructible_from<T, NoInit> ) { MR::resizeNoInit( vec_, targetSize ); }
 
    [[nodiscard]] std::size_t capacity() const { return vec_.capacity(); }
 
    void reserve( size_t capacity ) { vec_.reserve( capacity ); }
 
    [[nodiscard]] const_reference operator[]( I i ) const MR_LIFETIMEBOUND
    {
        assert( i < vec_.size() );
        return vec_[i];
    }
    [[nodiscard]] reference operator[]( I i ) MR_LIFETIMEBOUND
    {
        assert( i < vec_.size() );
        return vec_[i];
    }

    void resizeWithReserve( size_t newSize ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::default_initializable<T> )
    {
        resizeWithReserve( newSize, T{} );
    }

    void resizeWithReserve( size_t newSize, const T & value ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::movable<T> )
    {
        auto reserved = vec_.capacity();
        if ( reserved > 0 && newSize > reserved )
        {
            while ( newSize > reserved )
                reserved <<= 1;
            vec_.reserve( reserved );
        }
        vec_.resize( newSize, value );
    }

    void autoResizeSet( I pos, size_t len, T val ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::movable<T> && std::is_copy_assignable_v<T> )
    {
        assert( pos );
        const size_t p = pos;
        if ( const auto sz = size(); p + len > sz )
        {
            resizeWithReserve( p + len, val );
            if ( p >= sz )
                return;
            len = sz - p;
        }
        for ( size_t i = 0; i < len; ++i )
            vec_[ p + i ] = val;
    }

    void autoResizeSet( I i, T val ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::is_copy_assignable_v<T> )
    {
        autoResizeSet( i, 1, val );
    }

    [[nodiscard]] reference autoResizeAt( I i ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::default_initializable<T> )
    {
        if ( i + 1 > size() )
            resizeWithReserve( i + 1 );
        return vec_[i];
    }
 
    void push_back( const T & t MR_LIFETIME_CAPTURE_BY_NESTED(this) ) { vec_.push_back( t ); }
    void push_back( T && t MR_LIFETIME_CAPTURE_BY_NESTED(this) ) { vec_.push_back( std::move( t ) ); }
    void pop_back() { vec_.pop_back(); }
 
    template<typename... Args> MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::constructible_from<T, Args &&...> )
    T& emplace_back( Args&&... args ) { return vec_.emplace_back( std::forward<Args>(args)... ); }
 
    [[nodiscard]] const_reference front() const MR_LIFETIMEBOUND { return vec_.front(); }
    [[nodiscard]]       reference front()       MR_LIFETIMEBOUND { return vec_.front(); }
    [[nodiscard]] const_reference  back() const MR_LIFETIMEBOUND { return vec_.back(); }
    [[nodiscard]]       reference  back()       MR_LIFETIMEBOUND { return vec_.back(); }

    [[nodiscard]] I beginId() const { return I( size_t(0) ); }

    [[nodiscard]] I backId() const { assert( !vec_.empty() ); return I( vec_.size() - 1 ); }

    [[nodiscard]] I endId() const { return I( vec_.size() ); }
 
    [[nodiscard]] T* data() MR_LIFETIMEBOUND { return vec_.data(); }
    [[nodiscard]] const T* data() const MR_LIFETIMEBOUND { return vec_.data(); }
 
    void swap( Vector & b ) { vec_.swap( b.vec_ ); }

    [[nodiscard]] size_t heapBytes() const { return capacity() * sizeof(T); }
 
    [[nodiscard]] MR_BIND_IGNORE_PY friend auto begin( const Vector<T, I> & a ) { return a.vec_.begin(); }
    [[nodiscard]] MR_BIND_IGNORE_PY friend auto begin( Vector<T, I> & a ) { return a.vec_.begin(); }
    [[nodiscard]] MR_BIND_IGNORE_PY friend auto end( const Vector<T, I> & a ) { return a.vec_.end(); }
    [[nodiscard]] MR_BIND_IGNORE_PY friend auto end( Vector<T, I> & a ) { return a.vec_.end(); }

    std::vector<T> vec_;
 
#if defined( MR_PARSING_FOR_ANY_BINDINGS ) || defined( MR_COMPILING_ANY_BINDINGS )
    static_assert( sizeof(T) > 0 );
#endif
};

template <typename T>
[[nodiscard]] inline T getAt( const std::vector<T>& a, size_t id, T def = {} )
{
    return  id < a.size() ? a[id] : def;
}

template <typename T, typename I>
[[nodiscard]] inline T getAt( const Vector<T, I> & a, I id, T def = {} )
{
    return getAt( a.vec_, size_t( id ), def );
}
 
}