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