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
17namespace std { namespace experimental {
18
19template< typename T >
20class 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
35public:
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_LIBCPP_PUSH_MACROS
111#include <__undef_macros>
112
113namespace std { namespace experimental { inline namespace __array_extensions_v1 {
114
115template <class _Tp>
116struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_DYNARRAY dynarray
117{
118public:
119    // types:
120    typedef dynarray __self;
121    typedef _Tp                                   value_type;
122    typedef value_type&                           reference;
123    typedef const value_type&                     const_reference;
124    typedef value_type*                           iterator;
125    typedef const value_type*                     const_iterator;
126    typedef value_type*                           pointer;
127    typedef const value_type*                     const_pointer;
128    typedef size_t                                size_type;
129    typedef ptrdiff_t                             difference_type;
130    typedef std::reverse_iterator<iterator>       reverse_iterator;
131    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
132
133private:
134    size_t                  __size_;
135    value_type *            __base_;
136    _LIBCPP_ALWAYS_INLINE dynarray () noexcept :  __size_(0), __base_(nullptr) {}
137
138    static inline _LIBCPP_INLINE_VISIBILITY value_type* __allocate ( size_t count )
139    {
140        if ( numeric_limits<size_t>::max() / sizeof (value_type) <= count )
141            __throw_bad_array_length();
142
143        return static_cast<value_type *> (_VSTD::__allocate (sizeof(value_type) * count));
144    }
145
146    static inline _LIBCPP_INLINE_VISIBILITY void __deallocate_value( value_type* __ptr ) noexcept
147    {
148        _VSTD::__libcpp_deallocate (static_cast<void *> (__ptr));
149    }
150
151public:
152
153    _LIBCPP_INLINE_VISIBILITY
154    explicit dynarray(size_type __c);
155    _LIBCPP_INLINE_VISIBILITY
156    dynarray(size_type __c, const value_type& __v);
157    _LIBCPP_INLINE_VISIBILITY
158    dynarray(const dynarray& __d);
159    _LIBCPP_INLINE_VISIBILITY
160    dynarray(initializer_list<value_type>);
161
162//  We're not implementing these right now.
163//  Updated with the resolution of LWG issue #2255
164//     template <typename _Alloc>
165//       dynarray(allocator_arg_t, const _Alloc& __alloc, size_type __c);
166//     template <typename _Alloc>
167//       dynarray(allocator_arg_t, const _Alloc& __alloc, size_type __c, const value_type& __v);
168//     template <typename _Alloc>
169//       dynarray(allocator_arg_t, const _Alloc& __alloc, const dynarray& __d);
170//     template <typename _Alloc>
171//       dynarray(allocator_arg_t, const _Alloc& __alloc, initializer_list<value_type>);
172
173    dynarray& operator=(const dynarray&) = delete;
174    _LIBCPP_INLINE_VISIBILITY
175    ~dynarray();
176
177    // iterators:
178    inline _LIBCPP_INLINE_VISIBILITY iterator       begin()        noexcept { return iterator(data()); }
179    inline _LIBCPP_INLINE_VISIBILITY const_iterator begin()  const noexcept { return const_iterator(data()); }
180    inline _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const noexcept { return const_iterator(data()); }
181    inline _LIBCPP_INLINE_VISIBILITY iterator       end()          noexcept { return iterator(data() + __size_); }
182    inline _LIBCPP_INLINE_VISIBILITY const_iterator end()    const noexcept { return const_iterator(data() + __size_); }
183    inline _LIBCPP_INLINE_VISIBILITY const_iterator cend()   const noexcept { return const_iterator(data() + __size_); }
184
185    inline _LIBCPP_INLINE_VISIBILITY reverse_iterator       rbegin()        noexcept { return reverse_iterator(end()); }
186    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin()  const noexcept { return const_reverse_iterator(end()); }
187    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
188    inline _LIBCPP_INLINE_VISIBILITY reverse_iterator       rend()          noexcept { return reverse_iterator(begin()); }
189    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend()    const noexcept { return const_reverse_iterator(begin()); }
190    inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend()   const noexcept { return const_reverse_iterator(begin()); }
191
192    // capacity:
193    inline _LIBCPP_INLINE_VISIBILITY size_type size()     const noexcept { return __size_; }
194    inline _LIBCPP_INLINE_VISIBILITY size_type max_size() const noexcept { return __size_; }
195    inline _LIBCPP_INLINE_VISIBILITY bool      empty()    const noexcept { return __size_ == 0; }
196
197    // element access:
198    inline _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __n)       { return data()[__n]; }
199    inline _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const { return data()[__n]; }
200
201    inline _LIBCPP_INLINE_VISIBILITY reference       front()       { return data()[0]; }
202    inline _LIBCPP_INLINE_VISIBILITY const_reference front() const { return data()[0]; }
203    inline _LIBCPP_INLINE_VISIBILITY reference       back()        { return data()[__size_-1]; }
204    inline _LIBCPP_INLINE_VISIBILITY const_reference back()  const { return data()[__size_-1]; }
205
206    inline _LIBCPP_INLINE_VISIBILITY const_reference at(size_type __n) const;
207    inline _LIBCPP_INLINE_VISIBILITY reference       at(size_type __n);
208
209    // data access:
210    inline _LIBCPP_INLINE_VISIBILITY _Tp*       data()       noexcept { return __base_; }
211    inline _LIBCPP_INLINE_VISIBILITY const _Tp* data() const noexcept { return __base_; }
212
213    // mutating member functions:
214    inline _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __v) { fill_n(begin(), __size_, __v); }
215};
216
217template <class _Tp>
218inline
219dynarray<_Tp>::dynarray(size_type __c) : dynarray ()
220{
221    __base_ = __allocate (__c);
222    value_type *__data = data ();
223    for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
224        ::new (__data) value_type;
225}
226
227template <class _Tp>
228inline
229dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray ()
230{
231    __base_ = __allocate (__c);
232    value_type *__data = data ();
233    for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
234        ::new (__data) value_type (__v);
235}
236
237template <class _Tp>
238inline
239dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray ()
240{
241    size_t sz = __il.size();
242    __base_ = __allocate (sz);
243    value_type *__data = data ();
244    auto src = __il.begin();
245    for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
246        ::new (__data) value_type (*src);
247}
248
249template <class _Tp>
250inline
251dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray ()
252{
253    size_t sz = __d.size();
254    __base_ = __allocate (sz);
255    value_type *__data = data ();
256    auto src = __d.begin();
257    for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
258        ::new (__data) value_type (*src);
259}
260
261template <class _Tp>
262inline
263dynarray<_Tp>::~dynarray()
264{
265    value_type *__data = data () + __size_;
266    for ( size_t i = 0; i < __size_; ++i )
267        (--__data)->value_type::~value_type();
268    __deallocate_value( __base_ );
269}
270
271template <class _Tp>
272inline _LIBCPP_INLINE_VISIBILITY
273typename dynarray<_Tp>::reference
274dynarray<_Tp>::at(size_type __n)
275{
276    if (__n >= __size_)
277        __throw_out_of_range("dynarray::at");
278
279    return data()[__n];
280}
281
282template <class _Tp>
283inline _LIBCPP_INLINE_VISIBILITY
284typename dynarray<_Tp>::const_reference
285dynarray<_Tp>::at(size_type __n) const
286{
287    if (__n >= __size_)
288        __throw_out_of_range("dynarray::at");
289
290    return data()[__n];
291}
292
293}}}
294
295
296_LIBCPP_BEGIN_NAMESPACE_STD
297template <class _Tp, class _Alloc>
298struct _LIBCPP_TEMPLATE_VIS uses_allocator<std::experimental::dynarray<_Tp>, _Alloc> : true_type {};
299_LIBCPP_END_NAMESPACE_STD
300
301_LIBCPP_POP_MACROS
302
303#endif  // if _LIBCPP_STD_VER > 11
304#endif  // _LIBCPP_DYNARRAY
305