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 /*
  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 _LIBCPP_AVAILABILITY_DYNARRAY 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