MeshLib C++ Docs
Loading...
Searching...
No Matches
MRMesh/MRVector.h
Go to the documentation of this file.
1#pragma once
2
3#include "MRMeshFwd.h"
4#include "MRResizeNoInit.h"
5#include "MRPch/MRBindingMacros.h"
6#include <cassert>
7
8namespace MR
9{
10
17template <typename T, typename I>
18class Vector
19{
20public:
21 using value_type = typename std::vector<T>::value_type;
22 using reference = typename std::vector<T>::reference;
23 using const_reference = typename std::vector<T>::const_reference;
24 using iterator = typename std::vector<T>::iterator;
25 using const_iterator = typename std::vector<T>::const_iterator;
26
27 Vector() = default;
28 explicit Vector( size_t size ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::default_initializable<T> ) : vec_( size ) { }
29 explicit Vector( size_t size, const T & val ) : vec_( size, val ) { }
30 Vector( std::vector<T> && vec ) : vec_( std::move( vec ) ) { }
31 template< class InputIt >
32 Vector( InputIt first, InputIt last ) : vec_( first, last ) { }
33 Vector( std::initializer_list<T> init ) : vec_( init ) { }
34
35 [[nodiscard]] bool operator == ( const Vector & b ) const MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::equality_comparable<T> ) { return vec_ == b.vec_; }
36 [[nodiscard]] bool operator != ( const Vector & b ) const MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::equality_comparable<T> ) { return vec_ != b.vec_; }
37
38 void clear() { vec_.clear(); }
39 [[nodiscard]] bool empty() const { return vec_.empty(); }
40
41 [[nodiscard]] std::size_t size() const { return vec_.size(); }
42
43 void resize( size_t newSize ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::movable<T> && std::default_initializable<T> ) { vec_.resize( newSize ); }
44 void resize( size_t newSize, const T & t ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::movable<T> ) { vec_.resize( newSize, t ); }
45
46 // resizes the vector skipping initialization of its elements (more precisely initializing them using ( noInit ) constructor )
47 void resizeNoInit( size_t targetSize ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::constructible_from<T, NoInit> ) { MR::resizeNoInit( vec_, targetSize ); }
48
49 [[nodiscard]] std::size_t capacity() const { return vec_.capacity(); }
50 void reserve( size_t capacity ) { vec_.reserve( capacity ); }
51
52 [[nodiscard]] const_reference operator[]( I i ) const
53 {
54 assert( i < vec_.size() );
55 return vec_[i];
56 }
57 [[nodiscard]] reference operator[]( I i )
58 {
59 assert( i < vec_.size() );
60 return vec_[i];
61 }
62
64 void resizeWithReserve( size_t newSize ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::default_initializable<T> )
65 {
66 // This separate overload is needed as opposed to a `value = T{}` default argument, because if T isn't default-constructible, the parsed chokes on that.
67 resizeWithReserve( newSize, T{} );
68 }
69
71 void resizeWithReserve( size_t newSize, const T & value )
72 {
73 auto reserved = vec_.capacity();
74 if ( reserved > 0 && newSize > reserved )
75 {
76 while ( newSize > reserved )
77 reserved <<= 1;
78 vec_.reserve( reserved );
79 }
80 vec_.resize( newSize, value );
81 }
82
84 void autoResizeSet( I pos, size_t len, T val )
85 {
86 assert( pos );
87 const size_t p = pos;
88 if ( const auto sz = size(); p + len > sz )
89 {
90 resizeWithReserve( p + len, val );
91 if ( p >= sz )
92 return;
93 len = sz - p;
94 }
95 for ( size_t i = 0; i < len; ++i )
96 vec_[ p + i ] = val;
97 }
98 void autoResizeSet( I i, T val ) { autoResizeSet( i, 1, val ); }
99
101 [[nodiscard]] reference autoResizeAt( I i ) MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::default_initializable<T> )
102 {
103 if ( i + 1 > size() )
104 resizeWithReserve( i + 1 );
105 return vec_[i];
106 }
107
108 void push_back( const T & t ) { vec_.push_back( t ); }
109 void push_back( T && t ) { vec_.push_back( std::move( t ) ); }
110 void pop_back() { vec_.pop_back(); }
111
112 template<typename... Args> MR_REQUIRES_IF_SUPPORTED( sizeof(T)>0 && std::constructible_from<T, Args &&...> )
113 T& emplace_back( Args&&... args ) { return vec_.emplace_back( std::forward<Args>(args)... ); }
114
115 [[nodiscard]] const_reference front() const { return vec_.front(); }
116 [[nodiscard]] reference front() { return vec_.front(); }
117 [[nodiscard]] const_reference back() const { return vec_.back(); }
118 [[nodiscard]] reference back() { return vec_.back(); }
119
121 [[nodiscard]] I beginId() const { return I( size_t(0) ); }
122
124 [[nodiscard]] I backId() const { assert( !vec_.empty() ); return I( vec_.size() - 1 ); }
125
127 [[nodiscard]] I endId() const { return I( vec_.size() ); }
128
129 [[nodiscard]] T* data() { return vec_.data(); }
130 [[nodiscard]] const T* data() const { return vec_.data(); }
131
132 void swap( Vector & b ) { vec_.swap( b.vec_ ); }
133
135 [[nodiscard]] size_t heapBytes() const { return capacity() * sizeof(T); }
136
138 std::vector<T> vec_;
139
140#if defined( MR_PARSING_FOR_PB11_BINDINGS ) || defined( MR_COMPILING_PB11_BINDINGS )
141 static_assert( sizeof(T) > 0 );
142#endif
143};
144
145template <typename T, typename I>
146[[nodiscard]] MR_BIND_IGNORE inline auto begin( const Vector<T, I> & a )
147 { return a.vec_.begin(); }
148
149template <typename T, typename I>
150[[nodiscard]] MR_BIND_IGNORE inline auto begin( Vector<T, I> & a )
151 { return a.vec_.begin(); }
152
153template <typename T, typename I>
154[[nodiscard]] MR_BIND_IGNORE inline auto end( const Vector<T, I> & a )
155 { return a.vec_.end(); }
156
157template <typename T, typename I>
158[[nodiscard]] MR_BIND_IGNORE inline auto end( Vector<T, I> & a )
159 { return a.vec_.end(); }
160
162template <typename T, typename I>
163[[nodiscard]] inline T getAt( const Vector<T, I> & a, I id, T def = {} )
164{
165 return ( id && id < a.size() ) ? a[id] : def;
166}
167
168} // namespace MR
#define MR_REQUIRES_IF_SUPPORTED(...)
Definition MRMacros.h:31
std::vector<T>-like container that requires specific indexing type,
Definition MRMesh/MRVector.h:19
void pop_back()
Definition MRMesh/MRVector.h:110
Vector()=default
void clear()
Definition MRMesh/MRVector.h:38
reference front()
Definition MRMesh/MRVector.h:116
typename std::vector< T >::iterator iterator
Definition MRMesh/MRVector.h:24
void autoResizeSet(I i, T val)
Definition MRMesh/MRVector.h:98
std::size_t size() const
Definition MRMesh/MRVector.h:41
std::size_t capacity() const
Definition MRMesh/MRVector.h:49
bool operator==(const Vector &b) const
Definition MRMesh/MRVector.h:35
void resizeWithReserve(size_t newSize)
doubles reserved memory until resize(newSize) can be done without reallocation
Definition MRMesh/MRVector.h:64
reference operator[](I i)
Definition MRMesh/MRVector.h:57
typename std::vector< T >::reference reference
Definition MRMesh/MRVector.h:22
void autoResizeSet(I pos, size_t len, T val)
sets elements [pos, pos+len) to given value, adjusting the size of the vector to include new elements
Definition MRMesh/MRVector.h:84
T * data()
Definition MRMesh/MRVector.h:129
Vector(InputIt first, InputIt last)
Definition MRMesh/MRVector.h:32
Vector(std::vector< T > &&vec)
Definition MRMesh/MRVector.h:30
void reserve(size_t capacity)
Definition MRMesh/MRVector.h:50
I beginId() const
returns the identifier of the first element
Definition MRMesh/MRVector.h:121
void resizeNoInit(size_t targetSize)
Definition MRMesh/MRVector.h:47
void push_back(const T &t)
Definition MRMesh/MRVector.h:108
Vector(size_t size)
Definition MRMesh/MRVector.h:28
size_t heapBytes() const
returns the amount of memory this object occupies on heap
Definition MRMesh/MRVector.h:135
const_reference operator[](I i) const
Definition MRMesh/MRVector.h:52
I backId() const
returns the identifier of the back() element
Definition MRMesh/MRVector.h:124
Vector(std::initializer_list< T > init)
Definition MRMesh/MRVector.h:33
reference back()
Definition MRMesh/MRVector.h:118
typename std::vector< T >::const_reference const_reference
Definition MRMesh/MRVector.h:23
void resizeWithReserve(size_t newSize, const T &value)
doubles reserved memory until resize(newSize) can be done without reallocation
Definition MRMesh/MRVector.h:71
const T * data() const
Definition MRMesh/MRVector.h:130
typename std::vector< T >::value_type value_type
Definition MRMesh/MRVector.h:21
bool empty() const
Definition MRMesh/MRVector.h:39
bool operator!=(const Vector &b) const
Definition MRMesh/MRVector.h:36
Vector(size_t size, const T &val)
Definition MRMesh/MRVector.h:29
void resize(size_t newSize)
Definition MRMesh/MRVector.h:43
reference autoResizeAt(I i)
this accessor automatically adjusts the size of the vector
Definition MRMesh/MRVector.h:101
typename std::vector< T >::const_iterator const_iterator
Definition MRMesh/MRVector.h:25
std::vector< T > vec_
the user can directly manipulate the vector, anyway she cannot break anything
Definition MRMesh/MRVector.h:138
void resize(size_t newSize, const T &t)
Definition MRMesh/MRVector.h:44
void swap(Vector &b)
Definition MRMesh/MRVector.h:132
const_reference front() const
Definition MRMesh/MRVector.h:115
void push_back(T &&t)
Definition MRMesh/MRVector.h:109
T & emplace_back(Args &&... args)
Definition MRMesh/MRVector.h:113
const_reference back() const
Definition MRMesh/MRVector.h:117
I endId() const
returns backId() + 1
Definition MRMesh/MRVector.h:127
MR_BIND_IGNORE auto begin(const BitSet &a)
Definition MRMesh/MRBitSet.h:307
MR_BIND_IGNORE auto end(const BitSet &)
Definition MRMesh/MRBitSet.h:309
Definition MRCameraOrientationPlugin.h:8
T getAt(const Buffer< T, I > &bmap, I key, T def={})
given some buffer map and a key, returns the value associated with the key, or default value if key i...
Definition MRBuffer.h:119
void resizeNoInit(std::vector< T > &vec, size_t targetSize)
Definition MRResizeNoInit.h:14