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