1 // -*- C++ -*- 2 //===-------------------------- dynarray ----------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_DYNARRAY 12 #define _LIBCPP_DYNARRAY 13 14 /* 15 dynarray synopsis 16 17 namespace std { namespace experimental { 18 19 template< typename T > 20 class dynarray 21 { 22 // types: 23 typedef T value_type; 24 typedef T& reference; 25 typedef const T& const_reference; 26 typedef T* pointer; 27 typedef const T* const_pointer; 28 typedef implementation-defined iterator; 29 typedef implementation-defined const_iterator; 30 typedef reverse_iterator<iterator> reverse_iterator; 31 typedef reverse_iterator<const_iterator> const_reverse_iterator; 32 typedef size_t size_type; 33 typedef ptrdiff_t difference_type; 34 35 public: 36 // construct/copy/destroy: 37 explicit dynarray(size_type c); 38 dynarray(size_type c, const T& v); 39 dynarray(const dynarray& d); 40 dynarray(initializer_list<T>); 41 42 template <class Alloc> 43 dynarray(allocator_arg_t, const Alloc& a, size_type c, const Alloc& alloc); 44 template <class Alloc> 45 dynarray(allocator_arg_t, const Alloc& a, size_type c, const T& v, const Alloc& alloc); 46 template <class Alloc> 47 dynarray(allocator_arg_t, const Alloc& a, const dynarray& d, const Alloc& alloc); 48 template <class Alloc> 49 dynarray(allocator_arg_t, const Alloc& a, initializer_list<T>, const Alloc& alloc); 50 dynarray& operator=(const dynarray&) = delete; 51 ~dynarray(); 52 53 // iterators: 54 iterator begin() noexcept; 55 const_iterator begin() const noexcept; 56 const_iterator cbegin() const noexcept; 57 iterator end() noexcept; 58 const_iterator end() const noexcept; 59 const_iterator cend() const noexcept; 60 61 reverse_iterator rbegin() noexcept; 62 const_reverse_iterator rbegin() const noexcept; 63 const_reverse_iterator crbegin() const noexcept; 64 reverse_iterator rend() noexcept; 65 const_reverse_iterator rend() const noexcept; 66 const_reverse_iterator crend() const noexcept; 67 68 // capacity: 69 size_type size() const noexcept; 70 size_type max_size() const noexcept; 71 bool empty() const noexcept; 72 73 // element access: 74 reference operator[](size_type n); 75 const_reference operator[](size_type n) const; 76 77 reference front(); 78 const_reference front() const; 79 reference back(); 80 const_reference back() const; 81 82 const_reference at(size_type n) const; 83 reference at(size_type n); 84 85 // data access: 86 T* data() noexcept; 87 const T* data() const noexcept; 88 89 // mutating member functions: 90 void fill(const T& v); 91 }; 92 93 }} // std::experimental 94 95 */ 96 #include <__config> 97 #if _LIBCPP_STD_VER > 11 98 99 #include <__functional_base> 100 #include <iterator> 101 #include <stdexcept> 102 #include <initializer_list> 103 #include <new> 104 #include <algorithm> 105 106 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 107 #pragma GCC system_header 108 #endif 109 110 namespace std { namespace experimental { inline namespace __array_extensions_v1 { 111 112 template <class _Tp> 113 struct _LIBCPP_TEMPLATE_VIS dynarray 114 { 115 public: 116 // types: 117 typedef dynarray __self; 118 typedef _Tp value_type; 119 typedef value_type& reference; 120 typedef const value_type& const_reference; 121 typedef value_type* iterator; 122 typedef const value_type* const_iterator; 123 typedef value_type* pointer; 124 typedef const value_type* const_pointer; 125 typedef size_t size_type; 126 typedef ptrdiff_t difference_type; 127 typedef std::reverse_iterator<iterator> reverse_iterator; 128 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 129 130 private: 131 size_t __size_; 132 value_type * __base_; 133 _LIBCPP_ALWAYS_INLINE dynarray () noexcept : __size_(0), __base_(nullptr) {} 134 135 static inline _LIBCPP_INLINE_VISIBILITY value_type* __allocate ( size_t count ) 136 { 137 if ( numeric_limits<size_t>::max() / sizeof (value_type) <= count ) 138 __throw_bad_array_length(); 139 140 return static_cast<value_type *> (_VSTD::__allocate (sizeof(value_type) * count)); 141 } 142 143 static inline _LIBCPP_INLINE_VISIBILITY void __deallocate_value( value_type* __ptr ) noexcept 144 { 145 _VSTD::__libcpp_deallocate (static_cast<void *> (__ptr)); 146 } 147 148 public: 149 150 _LIBCPP_INLINE_VISIBILITY 151 explicit dynarray(size_type __c); 152 _LIBCPP_INLINE_VISIBILITY 153 dynarray(size_type __c, const value_type& __v); 154 _LIBCPP_INLINE_VISIBILITY 155 dynarray(const dynarray& __d); 156 _LIBCPP_INLINE_VISIBILITY 157 dynarray(initializer_list<value_type>); 158 159 // We're not implementing these right now. 160 // Updated with the resolution of LWG issue #2255 161 // template <typename _Alloc> 162 // dynarray(allocator_arg_t, const _Alloc& __alloc, size_type __c); 163 // template <typename _Alloc> 164 // dynarray(allocator_arg_t, const _Alloc& __alloc, size_type __c, const value_type& __v); 165 // template <typename _Alloc> 166 // dynarray(allocator_arg_t, const _Alloc& __alloc, const dynarray& __d); 167 // template <typename _Alloc> 168 // dynarray(allocator_arg_t, const _Alloc& __alloc, initializer_list<value_type>); 169 170 dynarray& operator=(const dynarray&) = delete; 171 _LIBCPP_INLINE_VISIBILITY 172 ~dynarray(); 173 174 // iterators: 175 inline _LIBCPP_INLINE_VISIBILITY iterator begin() noexcept { return iterator(data()); } 176 inline _LIBCPP_INLINE_VISIBILITY const_iterator begin() const noexcept { return const_iterator(data()); } 177 inline _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const noexcept { return const_iterator(data()); } 178 inline _LIBCPP_INLINE_VISIBILITY iterator end() noexcept { return iterator(data() + __size_); } 179 inline _LIBCPP_INLINE_VISIBILITY const_iterator end() const noexcept { return const_iterator(data() + __size_); } 180 inline _LIBCPP_INLINE_VISIBILITY const_iterator cend() const noexcept { return const_iterator(data() + __size_); } 181 182 inline _LIBCPP_INLINE_VISIBILITY reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } 183 inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } 184 inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } 185 inline _LIBCPP_INLINE_VISIBILITY reverse_iterator rend() noexcept { return reverse_iterator(begin()); } 186 inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } 187 inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } 188 189 // capacity: 190 inline _LIBCPP_INLINE_VISIBILITY size_type size() const noexcept { return __size_; } 191 inline _LIBCPP_INLINE_VISIBILITY size_type max_size() const noexcept { return __size_; } 192 inline _LIBCPP_INLINE_VISIBILITY bool empty() const noexcept { return __size_ == 0; } 193 194 // element access: 195 inline _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) { return data()[__n]; } 196 inline _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const { return data()[__n]; } 197 198 inline _LIBCPP_INLINE_VISIBILITY reference front() { return data()[0]; } 199 inline _LIBCPP_INLINE_VISIBILITY const_reference front() const { return data()[0]; } 200 inline _LIBCPP_INLINE_VISIBILITY reference back() { return data()[__size_-1]; } 201 inline _LIBCPP_INLINE_VISIBILITY const_reference back() const { return data()[__size_-1]; } 202 203 inline _LIBCPP_INLINE_VISIBILITY const_reference at(size_type __n) const; 204 inline _LIBCPP_INLINE_VISIBILITY reference at(size_type __n); 205 206 // data access: 207 inline _LIBCPP_INLINE_VISIBILITY _Tp* data() noexcept { return __base_; } 208 inline _LIBCPP_INLINE_VISIBILITY const _Tp* data() const noexcept { return __base_; } 209 210 // mutating member functions: 211 inline _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __v) { fill_n(begin(), __size_, __v); } 212 }; 213 214 template <class _Tp> 215 inline 216 dynarray<_Tp>::dynarray(size_type __c) : dynarray () 217 { 218 __base_ = __allocate (__c); 219 value_type *__data = data (); 220 for ( __size_ = 0; __size_ < __c; ++__size_, ++__data ) 221 ::new (__data) value_type; 222 } 223 224 template <class _Tp> 225 inline 226 dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray () 227 { 228 __base_ = __allocate (__c); 229 value_type *__data = data (); 230 for ( __size_ = 0; __size_ < __c; ++__size_, ++__data ) 231 ::new (__data) value_type (__v); 232 } 233 234 template <class _Tp> 235 inline 236 dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray () 237 { 238 size_t sz = __il.size(); 239 __base_ = __allocate (sz); 240 value_type *__data = data (); 241 auto src = __il.begin(); 242 for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src ) 243 ::new (__data) value_type (*src); 244 } 245 246 template <class _Tp> 247 inline 248 dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray () 249 { 250 size_t sz = __d.size(); 251 __base_ = __allocate (sz); 252 value_type *__data = data (); 253 auto src = __d.begin(); 254 for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src ) 255 ::new (__data) value_type (*src); 256 } 257 258 template <class _Tp> 259 inline 260 dynarray<_Tp>::~dynarray() 261 { 262 value_type *__data = data () + __size_; 263 for ( size_t i = 0; i < __size_; ++i ) 264 (--__data)->value_type::~value_type(); 265 __deallocate_value( __base_ ); 266 } 267 268 template <class _Tp> 269 inline _LIBCPP_INLINE_VISIBILITY 270 typename dynarray<_Tp>::reference 271 dynarray<_Tp>::at(size_type __n) 272 { 273 if (__n >= __size_) 274 __throw_out_of_range("dynarray::at"); 275 276 return data()[__n]; 277 } 278 279 template <class _Tp> 280 inline _LIBCPP_INLINE_VISIBILITY 281 typename dynarray<_Tp>::const_reference 282 dynarray<_Tp>::at(size_type __n) const 283 { 284 if (__n >= __size_) 285 __throw_out_of_range("dynarray::at"); 286 287 return data()[__n]; 288 } 289 290 }}} 291 292 293 _LIBCPP_BEGIN_NAMESPACE_STD 294 template <class _Tp, class _Alloc> 295 struct _LIBCPP_TEMPLATE_VIS uses_allocator<std::experimental::dynarray<_Tp>, _Alloc> : true_type {}; 296 _LIBCPP_END_NAMESPACE_STD 297 298 #endif // if _LIBCPP_STD_VER > 11 299 #endif // _LIBCPP_DYNARRAY 300
