Index: test/containers/sequences/dynarray/nothing_to_do.pass.cpp =================================================================== --- test/containers/sequences/dynarray/nothing_to_do.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/nothing_to_do.pass.cpp (revision 0) @@ -0,0 +1,12 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +int main() +{ +} Index: test/containers/sequences/dynarray/dynarray.data/default.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.data/default.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.data/default.pass.cpp (revision 0) @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.data + +// T* data() noexcept; +// const T* data() const noexcept; + + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + + +template +void dyn_test_const ( const std::dynarray &dyn ) { + const T *data = dyn.data (); + assert ( data != NULL ); + assert ( std::equal ( dyn.begin(), dyn.end(), data )); + } + +template +void dyn_test ( std::dynarray &dyn ) { + T *data = dyn.data (); + assert ( data != NULL ); + assert ( std::equal ( dyn.begin(), dyn.end(), data )); + } + + + +template +void test ( const T &val ) { + typedef std::dynarray dynA; + + dynA d1 ( 4 ); + dyn_test ( d1 ); + dyn_test_const ( d1 ); + + dynA d2 ( 7, val ); + dyn_test ( d2 ); + dyn_test_const ( d2 ); + } + +int main() +{ + test ( 14 ); + test ( 14.0 ); + test> ( std::complex ( 14, 0 )); + test ( "fourteen" ); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp (revision 0) @@ -0,0 +1,47 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.data + +// void fill(const T& v); +// const T* data() const noexcept; + + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + + +template +void test ( const T &val ) { + typedef std::dynarray dynA; + + dynA d1 ( 4 ); + d1.fill ( val ); + assert ( std::all_of ( d1.begin (), d1.end (), + [&val]( const T &item ){ return item == val; } )); + } + +int main() +{ + test ( 14 ); + test ( 14.0 ); + test> ( std::complex ( 14, 0 )); + test ( "fourteen" ); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.zero/default.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.zero/default.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.zero/default.pass.cpp (revision 0) @@ -0,0 +1,49 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.zero + +// dynarray shall provide support for the special case of construction with a size of zero. +// In the case that the size is zero, begin() == end() == unique value. +// The return value of data() is unspecified. +// The effect of calling front() or back() for a zero-sized dynarray is undefined. + + + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + + +template +void test ( ) { + typedef std::dynarray dynA; + + dynA d1 ( 0 ); + assert ( d1.size() == 0 ); + assert ( d1.begin() == d1.end ()); + } + +int main() +{ + test (); + test (); + test> (); + test (); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp (revision 0) @@ -0,0 +1,83 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.cons + +// template +// dynarray(size_type c, const Alloc& alloc); +// template +// dynarray(size_type c, const T& v, const Alloc& alloc); +// template +// dynarray(const dynarray& d, const Alloc& alloc); +// template +// dynarray(initializer_list, const Alloc& alloc); + +// ~dynarray(); + + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include +#include "../../../test_allocator.h" + +template +void check_allocator ( const std::dynarray &dyn, const Allocator &alloc ) { + for ( int i = 0; i < dyn.size (); ++i ) + assert ( dyn[i].get_allocator() == alloc ); +} + +template +void test ( const std::initializer_list &vals, const Allocator &alloc ) { + typedef std::dynarray dynA; + + dynA d1 ( vals, alloc ); + assert ( d1.size () == vals.size() ); + assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ())); + check_allocator ( d1, alloc ); + } + + +template +void test ( const T &val, const Allocator &alloc1, const Allocator &alloc2 ) { + typedef std::dynarray dynA; + + dynA d1 ( 4, alloc1 ); + assert ( d1.size () == 4 ); + assert ( std::all_of ( d1.begin (), d1.end (), []( const T &item ){ return item == T(); } )); + check_allocator ( d1, alloc1 ); + + dynA d2 ( 7, val, alloc1 ); + assert ( d2.size () == 7 ); + assert ( std::all_of ( d2.begin (), d2.end (), [&val]( const T &item ){ return item == val; } )); + check_allocator ( d2, alloc1 ); + + dynA d3 ( d2, alloc2 ); + assert ( d3.size () == 7 ); + assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } )); + check_allocator ( d3, alloc2 ); + } + +int main() +{ + typedef test_allocator Alloc; + typedef std::basic_string, Alloc> nstr; + + test ( nstr("fourteen"), Alloc(3), Alloc(4) ); + test ( { nstr("1"), nstr("1"), nstr("2"), nstr("3"), nstr("5"), nstr("8")}, Alloc(6)); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.cons/default.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.cons/default.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.cons/default.pass.cpp (revision 0) @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.cons + +// explicit dynarray(size_type c); +// dynarray(size_type c, const T& v); +// dynarray(initializer_list); +// dynarray(const dynarray& d); + +// ~dynarray(); + + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + +template +void test ( const std::initializer_list &vals ) { + typedef std::dynarray dynA; + + dynA d1 ( vals ); + assert ( d1.size () == vals.size() ); + assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ())); + } + + +template +void test ( const T &val ) { + typedef std::dynarray dynA; + + dynA d1 ( 4 ); + assert ( d1.size () == 4 ); + assert ( std::all_of ( d1.begin (), d1.end (), []( const T &item ){ return item == T(); } )); + + dynA d2 ( 7, val ); + assert ( d2.size () == 7 ); + assert ( std::all_of ( d2.begin (), d2.end (), [&val]( const T &item ){ return item == val; } )); + + dynA d3 ( d2 ); + assert ( d3.size () == 7 ); + assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } )); + } + +int main() +{ +// test ( 14 ); // ints don't get default initialized + test ( 14.0 ); + test> ( std::complex ( 14, 0 )); + test ( "fourteen" ); + + test ( { 1, 1, 2, 3, 5, 8 } ); + test ( { 1., 1., 2., 3., 5., 8. } ); + test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), + std::string("5"), std::string("8")} ); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp (revision 0) @@ -0,0 +1,106 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.overview + + +// iterator begin() noexcept; +// const_iterator begin() const noexcept; +// const_iterator cbegin() const noexcept; +// iterator end() noexcept; +// const_iterator end() const noexcept; +// const_iterator cend() const noexcept; +// +// reverse_iterator rbegin() noexcept; +// const_reverse_iterator rbegin() const noexcept; +// const_reverse_iterator crbegin() const noexcept; +// reverse_iterator rend() noexcept; +// const_reverse_iterator rend() const noexcept; +// const_reverse_iterator crend() const noexcept; + + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + +template +void dyn_test_const ( const std::dynarray &dyn ) { + const T *data = dyn.data (); + assert ( data == &*dyn.begin ()); + assert ( data == &*dyn.cbegin ()); + + assert ( data + dyn.size() - 1 == &*dyn.rbegin ()); + assert ( data + dyn.size() - 1 == &*dyn.crbegin ()); + + assert ( dyn.size () == std::distance ( dyn.begin(), dyn.end())); + assert ( dyn.size () == std::distance ( dyn.cbegin(), dyn.cend())); + assert ( dyn.size () == std::distance ( dyn.rbegin(), dyn.rend())); + assert ( dyn.size () == std::distance ( dyn.crbegin(), dyn.crend())); + + assert ( dyn.begin () == dyn.cbegin ()); + assert ( &*dyn.begin () == &*dyn.cbegin ()); + assert ( dyn.rbegin () == dyn.crbegin ()); + assert ( &*dyn.rbegin () == &*dyn.crbegin ()); + assert ( dyn.end () == dyn.cend ()); + assert ( dyn.rend () == dyn.crend ()); + } + +template +void dyn_test ( std::dynarray &dyn ) { + T *data = dyn.data (); + assert ( data == &*dyn.begin ()); + assert ( data == &*dyn.cbegin ()); + + assert ( data + dyn.size() - 1 == &*dyn.rbegin ()); + assert ( data + dyn.size() - 1 == &*dyn.crbegin ()); + + assert ( dyn.size () == std::distance ( dyn.begin(), dyn.end())); + assert ( dyn.size () == std::distance ( dyn.cbegin(), dyn.cend())); + assert ( dyn.size () == std::distance ( dyn.rbegin(), dyn.rend())); + assert ( dyn.size () == std::distance ( dyn.crbegin(), dyn.crend())); + + assert ( dyn.begin () == dyn.cbegin ()); + assert ( &*dyn.begin () == &*dyn.cbegin ()); + assert ( dyn.rbegin () == dyn.crbegin ()); + assert ( &*dyn.rbegin () == &*dyn.crbegin ()); + assert ( dyn.end () == dyn.cend ()); + assert ( dyn.rend () == dyn.crend ()); + } + + +template +void test ( const T &val ) { + typedef std::dynarray dynA; + + dynA d1 ( 4 ); + dyn_test ( d1 ); + dyn_test_const ( d1 ); + + dynA d2 ( 7, val ); + dyn_test ( d2 ); + dyn_test_const ( d2 ); + } + +int main() +{ + test ( 14 ); + test ( 14.0 ); + test> ( std::complex ( 14, 0 )); + test ( "fourteen" ); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp (revision 0) @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.overview + +// size_type size() const noexcept; +// size_type max_size() const noexcept; +// bool empty() const noexcept; + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + +template +void dyn_test ( const std::dynarray &dyn, size_t sz ) { + assert ( dyn.size () == sz ); + assert ( dyn.max_size () == sz ); + assert ( dyn.empty () == ( sz == 0 )); + } + +template +void test ( std::initializer_list vals ) { + typedef std::dynarray dynA; + + dynA d1 ( vals ); + dyn_test ( d1, vals.size ()); + } + +int main() +{ + test ( { 1, 1, 2, 3, 5, 8 } ); + test ( { 1., 1., 2., 3., 5., 8. } ); + test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), + std::string("5"), std::string("8")} ); + + test ( {} ); + test> ( {} ); + test ( {} ); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.overview/at.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.overview/at.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.overview/at.pass.cpp (revision 0) @@ -0,0 +1,92 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.overview + +// const_reference at(size_type n) const; +// reference at(size_type n); + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + +template +void dyn_at_fail ( std::dynarray &dyn, size_t sz ) { + try { dyn.at (sz); } + catch (const std::out_of_range &) { return; } + assert ( false ); + } + +template +void dyn_at_fail_const ( const std::dynarray &dyn, size_t sz ) { + try { dyn.at (sz); } + catch (const std::out_of_range &) { return; } + assert ( false ); + } + + +template +void dyn_test_const ( const std::dynarray &dyn, const std::initializer_list &vals ) { + const T *data = dyn.data (); + auto it = vals.begin (); + for ( size_t i = 0; i < dyn.size(); ++i, ++it ) { + assert ( data + i == &dyn.at(i)); + assert ( *it == dyn.at(i)); + } + + dyn_at_fail_const ( dyn, dyn.size ()); + dyn_at_fail_const ( dyn, 2*dyn.size ()); + dyn_at_fail_const ( dyn, size_t (-1)); + } + +template +void dyn_test ( std::dynarray &dyn, const std::initializer_list &vals ) { + T *data = dyn.data (); + auto it = vals.begin (); + for ( size_t i = 0; i < dyn.size(); ++i, ++it ) { + assert ( data + i == &dyn.at(i)); + assert ( *it == dyn.at(i)); + } + + dyn_at_fail ( dyn, dyn.size ()); + dyn_at_fail ( dyn, 2*dyn.size ()); + dyn_at_fail ( dyn, size_t (-1)); + } + + +template +void test ( std::initializer_list vals ) { + typedef std::dynarray dynA; + + dynA d1 ( vals ); + dyn_test ( d1, vals ); + dyn_test_const ( d1, vals ); + } + +int main() +{ + test ( { 1, 1, 2, 3, 5, 8 } ); + test ( { 1., 1., 2., 3., 5., 8. } ); + test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), + std::string("5"), std::string("8")} ); + + test ( {} ); + test> ( {} ); + test ( {} ); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp (revision 0) @@ -0,0 +1,69 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.overview + +// const_reference at(size_type n) const; +// reference at(size_type n); + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + +template +void dyn_test_const ( const std::dynarray &dyn, const std::initializer_list &vals ) { + const T *data = dyn.data (); + auto it = vals.begin (); + for ( size_t i = 0; i < dyn.size(); ++i, ++it ) { + assert ( data + i == &dyn[i]); + assert ( *it == dyn[i]); + } + } + +template +void dyn_test ( std::dynarray &dyn, const std::initializer_list &vals ) { + T *data = dyn.data (); + auto it = vals.begin (); + for ( size_t i = 0; i < dyn.size(); ++i, ++it ) { + assert ( data + i == &dyn[i]); + assert ( *it == dyn[i]); + } + } + + +template +void test ( std::initializer_list vals ) { + typedef std::dynarray dynA; + + dynA d1 ( vals ); + dyn_test ( d1, vals ); + dyn_test_const ( d1, vals ); + } + +int main() +{ + test ( { 1, 1, 2, 3, 5, 8 } ); + test ( { 1., 1., 2., 3., 5., 8. } ); + test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), + std::string("5"), std::string("8")} ); + + test ( {} ); + test> ( {} ); + test ( {} ); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp (revision 0) @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.overview + +// reference front(); +// const_reference front() const; +// reference back(); +// const_reference back() const; + + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include + +#include +#include +#include + +template +void dyn_test_const ( const std::dynarray &dyn ) { + const T *data = dyn.data (); + assert ( *data == dyn.front ()); + assert ( *(data + dyn.size() - 1 ) == dyn.back ()); + } + +template +void dyn_test ( std::dynarray &dyn ) { + T *data = dyn.data (); + assert ( *data == dyn.front ()); + assert ( *(data + dyn.size() - 1 ) == dyn.back ()); + } + + +template +void test ( const T &val ) { + typedef std::dynarray dynA; + + dynA d1 ( 4 ); + dyn_test ( d1 ); + dyn_test_const ( d1 ); + + dynA d2 ( 7, val ); + dyn_test ( d2 ); + dyn_test_const ( d2 ); + } + +int main() +{ + test ( 14 ); + test ( 14.0 ); + test> ( std::complex ( 14, 0 )); + test ( "fourteen" ); +} +#else +int main() {} +#endif Index: test/containers/sequences/dynarray/dynarray.traits/default.pass.cpp =================================================================== --- test/containers/sequences/dynarray/dynarray.traits/default.pass.cpp (revision 0) +++ test/containers/sequences/dynarray/dynarray.traits/default.pass.cpp (revision 0) @@ -0,0 +1,29 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// dynarray.data + +// template +// struct uses_allocator, Alloc> : true_type { }; + + +#include <__config> + +#if _LIBCPP_STD_VER > 11 + +#include +#include "../../../test_allocator.h" + +int main() +{ + static_assert ( std::uses_allocator, test_allocator>::value, "" ); +} +#else +int main() {} +#endif Index: include/dynarray =================================================================== --- include/dynarray (revision 0) +++ include/dynarray (revision 0) @@ -0,0 +1,353 @@ +// -*- C++ -*- +//===-------------------------- dynarray ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_DYNARRAY +#define _LIBCPP_DYNARRAY + +#include <__config> +#if _LIBCPP_STD_VER > 11 + +/* + dynarray synopsis + +namespace std { + +template< typename T > +class dynarray +{ + // types: + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T* pointer; + typedef const T* const_pointer; + typedef implementation-defined iterator; + typedef implementation-defined const_iterator; + typedef reverse_iterator reverse_iterator; + typedef reverse_iterator const_reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + +public: + // construct/copy/destroy: + explicit dynarray(size_type c); + template + dynarray(size_type c, const Alloc& alloc); + dynarray(size_type c, const T& v); + template + dynarray(size_type c, const T& v, const Alloc& alloc); + dynarray(const dynarray& d); + template + dynarray(const dynarray& d, const Alloc& alloc); + dynarray(initializer_list); + template + dynarray(initializer_list, const Alloc& alloc); + + dynarray& operator=(const dynarray&) = delete; + ~dynarray(); + + // iterators: + iterator begin() noexcept; + const_iterator begin() const noexcept; + const_iterator cbegin() const noexcept; + iterator end() noexcept; + const_iterator end() const noexcept; + const_iterator cend() const noexcept; + + reverse_iterator rbegin() noexcept; + const_reverse_iterator rbegin() const noexcept; + const_reverse_iterator crbegin() const noexcept; + reverse_iterator rend() noexcept; + const_reverse_iterator rend() const noexcept; + const_reverse_iterator crend() const noexcept; + + // capacity: + size_type size() const noexcept; + size_type max_size() const noexcept; + bool empty() const noexcept; + + // element access: + reference operator[](size_type n); + const_reference operator[](size_type n) const; + + reference front(); + const_reference front() const; + reference back(); + const_reference back() const; + + const_reference at(size_type n) const; + reference at(size_type n); + + // data access: + T* data() noexcept; + const T* data() const noexcept; + + // mutating member functions: + void fill(const T& v); +}; + +} // std + +*/ + +#include +#include +#include +#include +#include // for __uses_alloc_ctor + +#if defined(_LIBCPP_NO_EXCEPTIONS) + #include +#endif + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) +{ + new (__storage) _Tp (_VSTD::forward<_Args>(__args)...); +} + +template +void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) +{ + new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...); +} + +template +void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) +{ + new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a); +} + +template +void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args) +{ + __user_alloc_construct_impl( + __uses_alloc_ctor<_Tp, _Allocator>(), + __storage, __a, _VSTD::forward<_Args>(__args)... + ); +} + +template +struct _LIBCPP_TYPE_VIS_ONLY dynarray +{ +private: + size_t size_; + void * base_; + dynarray () _NOEXCEPT : base_(nullptr), size_(0) {} + + static inline void * __allocate ( size_t count ) { return ::operator new (sizeof(_Tp) * count ); } +public: + // types: + typedef dynarray __self; + typedef _Tp value_type; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* iterator; + typedef const value_type* const_iterator; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + explicit dynarray(size_type __c); + template + dynarray(size_type __c, const _Alloc& __alloc); + dynarray(size_type __c, const value_type& __v); + template + dynarray(size_type __c, const value_type& __v, const _Alloc& __alloc); + dynarray(const dynarray& __d); + template + dynarray(const dynarray& __d, const _Alloc& __alloc); + _LIBCPP_INLINE_VISIBILITY dynarray(initializer_list); + template + dynarray(initializer_list, const _Alloc& __alloc); + + _LIBCPP_INLINE_VISIBILITY dynarray& operator=(const dynarray&) = delete; + _LIBCPP_INLINE_VISIBILITY ~dynarray(); + + // iterators: + _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT { return iterator(data()); } + _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT { return const_iterator(data()); } + _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const _NOEXCEPT { return const_iterator(data()); } + _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT { return iterator(data() + size_); } + _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT { return const_iterator(data() + size_); } + _LIBCPP_INLINE_VISIBILITY const_iterator cend() const _NOEXCEPT { return const_iterator(data() + size_); } + + _LIBCPP_INLINE_VISIBILITY reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); } + _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); } + _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(end()); } + _LIBCPP_INLINE_VISIBILITY reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); } + _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); } + _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(begin()); } + + // capacity: + _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT { return size_; } + _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT { return size_; } + _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT { return size_ == 0; } + + // element access: + _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) { return data()[__n]; } + _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const { return data()[__n]; } + + _LIBCPP_INLINE_VISIBILITY reference front() { return data()[0]; } + _LIBCPP_INLINE_VISIBILITY const_reference front() const { return data()[0]; } + _LIBCPP_INLINE_VISIBILITY reference back() { return data()[size_-1]; } + _LIBCPP_INLINE_VISIBILITY const_reference back() const { return data()[size_-1]; } + + _LIBCPP_INLINE_VISIBILITY const_reference at(size_type __n) const; + _LIBCPP_INLINE_VISIBILITY reference at(size_type __n); + + // data access: + _LIBCPP_INLINE_VISIBILITY _Tp* data() _NOEXCEPT { return reinterpret_cast< _Tp *> (base_); } + _LIBCPP_INLINE_VISIBILITY const _Tp* data() const _NOEXCEPT { return reinterpret_cast (base_); } + + // mutating member functions: + _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __v) { fill_n(begin(), size_, __v); } +}; + +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::dynarray(size_type __c) : dynarray () +{ + base_ = __allocate (__c); + _Tp *__data = data (); + for ( size_ = 0; size_ < __c; ++size_, ++__data ) + new (__data) _Tp; +} + +template +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::dynarray(size_type __c, const _Alloc& __alloc) : dynarray () +{ + base_ = __allocate (__c); + _Tp *__data = data (); + for ( size_ = 0; size_ < __c; ++size_, ++__data ) + __user_alloc_construct<_Tp, _Alloc> ( __data, __alloc ); +} + +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray () +{ + base_ = __allocate (__c); + uninitialized_fill_n ( begin (), __c, __v ); + size_ = __c; +} + +template +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::dynarray(size_type __c, const value_type& __v, const _Alloc& __alloc) +{ + base_ = __allocate (__c); + _Tp *__data = data (); + for ( size_ = 0; size_ < __c; ++size_, ++__data ) + __user_alloc_construct<_Tp, _Alloc> ( __data, __alloc, __v ); +} + +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::dynarray(initializer_list __il) : dynarray () +{ + size_t sz = __il.size(); + base_ = __allocate (sz); + uninitialized_copy_n ( __il.begin(), sz, begin()); + size_ = sz; +} + +template +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::dynarray(initializer_list __il, const _Alloc& __alloc) : dynarray () +{ + size_t sz = __il.size(); + base_ = __allocate (sz); + _Tp *__data = data (); + auto src = __il.begin (); + for ( size_ = 0; size_ < sz; ++size_, ++src, ++__data ) + __user_alloc_construct<_Tp, _Alloc> ( __data, __alloc, *src ); +} + +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray () +{ + size_t sz = __d.size(); + base_ = __allocate (sz); + uninitialized_copy_n ( __d.begin(), sz, begin()); + size_ = sz; +} + +template +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::dynarray(const dynarray& __d, const _Alloc& __alloc) : dynarray () +{ + size_t sz = __d.size(); + base_ = __allocate (sz); + _Tp *__data = data (); + auto src = __d.begin (); + for ( size_ = 0; size_ < sz; ++size_, ++src, ++__data ) + __user_alloc_construct<_Tp, _Alloc> ( __data, __alloc, *src ); +} + +template +_LIBCPP_INLINE_VISIBILITY +dynarray<_Tp>::~dynarray() +{ + _Tp *__data = data () + size_; + for ( size_t i = 0; i < size_; ++i, --__data ) + __data->_Tp::~_Tp(); +} + +template +_LIBCPP_INLINE_VISIBILITY +typename dynarray<_Tp>::reference +dynarray<_Tp>::at(size_type __n) +{ + if (__n >= size_) +#ifndef _LIBCPP_NO_EXCEPTIONS + throw out_of_range("dynarray::at"); +#else + assert(!"dynarray::at out_of_range"); +#endif + return data()[__n]; +} + +template +_LIBCPP_INLINE_VISIBILITY +typename dynarray<_Tp>::const_reference +dynarray<_Tp>::at(size_type __n) const +{ + if (__n >= size_) +#ifndef _LIBCPP_NO_EXCEPTIONS + throw out_of_range("dynarray::at"); +#else + assert(!"dynarray::at out_of_range"); +#endif + return data()[__n]; +} + +template +struct _LIBCPP_TYPE_VIS_ONLY uses_allocator, _Alloc> : true_type {}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // if _LIBCPP_STD_VER > 11 +#endif // _LIBCPP_DYNARRAY