contrib/libc++/include/experimental/dynarray

   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
  20 namespace std { namespace experimental {
  21
  22 template< typename T >
  23 class 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
  38 public:
  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
 117 namespace std { namespace experimental { inline namespace __array_extensions_v1 {
 118
 119 template <class _Tp>
 120 struct _LIBCPP_TYPE_VIS_ONLY dynarray
 121 {
 122 public:
 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
 137 private:
 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
 160 public:
 161
 162     _LIBCPP_INLINE_VISIBILITY
 163     explicit dynarray(size_type __c);
 164     _LIBCPP_INLINE_VISIBILITY
 165     dynarray(size_type __c, const value_type& __v);
 166     _LIBCPP_INLINE_VISIBILITY
 167     dynarray(const dynarray& __d);
 168     _LIBCPP_INLINE_VISIBILITY
 169     dynarray(initializer_list<value_type>);
 170
 171 //  We're not implementing these right now.
 172 //  Updated with the resolution of LWG issue #2255
 173 //     template <typename _Alloc>
 174 //       dynarray(allocator_arg_t, const _Alloc& __alloc, size_type __c);
 175 //     template <typename _Alloc>
 176 //       dynarray(allocator_arg_t, const _Alloc& __alloc, size_type __c, const value_type& __v);
 177 //     template <typename _Alloc>
 178 //       dynarray(allocator_arg_t, const _Alloc& __alloc, const dynarray& __d);
 179 //     template <typename _Alloc>
 180 //       dynarray(allocator_arg_t, const _Alloc& __alloc, initializer_list<value_type>);
 181
 182     dynarray& operator=(const dynarray&) = delete;
 183     _LIBCPP_INLINE_VISIBILITY
 184     ~dynarray();
 185
 186     // iterators:
 187     inline _LIBCPP_INLINE_VISIBILITY iterator       begin()        noexcept { return iterator(data()); }
 188     inline _LIBCPP_INLINE_VISIBILITY const_iterator begin()  const noexcept { return const_iterator(data()); }
 189     inline _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const noexcept { return const_iterator(data()); }
 190     inline _LIBCPP_INLINE_VISIBILITY iterator       end()          noexcept { return iterator(data() + __size_); }
 191     inline _LIBCPP_INLINE_VISIBILITY const_iterator end()    const noexcept { return const_iterator(data() + __size_); }
 192     inline _LIBCPP_INLINE_VISIBILITY const_iterator cend()   const noexcept { return const_iterator(data() + __size_); }
 193
 194     inline _LIBCPP_INLINE_VISIBILITY reverse_iterator       rbegin()        noexcept { return reverse_iterator(end()); }
 195     inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin()  const noexcept { return const_reverse_iterator(end()); }
 196     inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
 197     inline _LIBCPP_INLINE_VISIBILITY reverse_iterator       rend()          noexcept { return reverse_iterator(begin()); }
 198     inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend()    const noexcept { return const_reverse_iterator(begin()); }
 199     inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend()   const noexcept { return const_reverse_iterator(begin()); }
 200
 201     // capacity:
 202     inline _LIBCPP_INLINE_VISIBILITY size_type size()     const noexcept { return __size_; }
 203     inline _LIBCPP_INLINE_VISIBILITY size_type max_size() const noexcept { return __size_; }
 204     inline _LIBCPP_INLINE_VISIBILITY bool      empty()    const noexcept { return __size_ == 0; }
 205
 206     // element access:
 207     inline _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __n)       { return data()[__n]; }
 208     inline _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const { return data()[__n]; }
 209
 210     inline _LIBCPP_INLINE_VISIBILITY reference       front()       { return data()[0]; }
 211     inline _LIBCPP_INLINE_VISIBILITY const_reference front() const { return data()[0]; }
 212     inline _LIBCPP_INLINE_VISIBILITY reference       back()        { return data()[__size_-1]; }
 213     inline _LIBCPP_INLINE_VISIBILITY const_reference back()  const { return data()[__size_-1]; }
 214
 215     inline _LIBCPP_INLINE_VISIBILITY const_reference at(size_type __n) const;
 216     inline _LIBCPP_INLINE_VISIBILITY reference       at(size_type __n);
 217
 218     // data access:
 219     inline _LIBCPP_INLINE_VISIBILITY _Tp*       data()       noexcept { return __base_; }
 220     inline _LIBCPP_INLINE_VISIBILITY const _Tp* data() const noexcept { return __base_; }
 221
 222     // mutating member functions:
 223     inline _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __v) { fill_n(begin(), __size_, __v); }
 224 };
 225
 226 template <class _Tp>
 227 inline
 228 dynarray<_Tp>::dynarray(size_type __c) : dynarray ()
 229 {
 230     __base_ = __allocate (__c);
 231     value_type *__data = data ();
 232     for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
 233         ::new (__data) value_type;
 234 }
 235
 236 template <class _Tp>
 237 inline
 238 dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray ()
 239 {
 240     __base_ = __allocate (__c);
 241     value_type *__data = data ();
 242     for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
 243         ::new (__data) value_type (__v);
 244 }
 245
 246 template <class _Tp>
 247 inline
 248 dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray ()
 249 {
 250     size_t sz = __il.size();
 251     __base_ = __allocate (sz);
 252     value_type *__data = data ();
 253     auto src = __il.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(const dynarray& __d) : dynarray ()
 261 {
 262     size_t sz = __d.size();
 263     __base_ = __allocate (sz);
 264     value_type *__data = data ();
 265     auto src = __d.begin();
 266     for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
 267         ::new (__data) value_type (*src);
 268 }
 269
 270 template <class _Tp>
 271 inline
 272 dynarray<_Tp>::~dynarray()
 273 {
 274     value_type *__data = data () + __size_;
 275     for ( size_t i = 0; i < __size_; ++i )
 276         (--__data)->value_type::~value_type();
 277     __deallocate ( __base_ );
 278 }
 279
 280 template <class _Tp>
 281 inline _LIBCPP_INLINE_VISIBILITY
 282 typename dynarray<_Tp>::reference
 283 dynarray<_Tp>::at(size_type __n)
 284 {
 285     if (__n >= __size_)
 286     {
 287 #ifndef _LIBCPP_NO_EXCEPTIONS
 288         throw out_of_range("dynarray::at");
 289 #else
 290         assert(!"dynarray::at out_of_range");
 291 #endif
 292     }
 293     return data()[__n];
 294 }
 295
 296 template <class _Tp>
 297 inline _LIBCPP_INLINE_VISIBILITY
 298 typename dynarray<_Tp>::const_reference
 299 dynarray<_Tp>::at(size_type __n) const
 300 {
 301     if (__n >= __size_)
 302     {
 303 #ifndef _LIBCPP_NO_EXCEPTIONS
 304         throw out_of_range("dynarray::at");
 305 #else
 306         assert(!"dynarray::at out_of_range");
 307 #endif
 308     }
 309     return data()[__n];
 310 }
 311
 312 }}}
 313
 314
 315 _LIBCPP_BEGIN_NAMESPACE_STD
 316 template <class _Tp, class _Alloc>
 317 struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<std::experimental::dynarray<_Tp>, _Alloc> : true_type {};
 318 _LIBCPP_END_NAMESPACE_STD
 319
 320 #endif  // if _LIBCPP_STD_VER > 11
 321 #endif  // _LIBCPP_DYNARRAY