[libcxx] r190697 - Initial implementation of <dynarray>. No allocator support pending resolution of LWG #2235; no stack allocation pending compiler support
Marshall Clow
mclow.lists at gmail.com
Fri Sep 13 08:22:56 PDT 2013
Author: marshall
Date: Fri Sep 13 10:22:55 2013
New Revision: 190697
URL: http://llvm.org/viewvc/llvm-project?rev=190697&view=rev
Log:
Initial implementation of <dynarray>. No allocator support pending resolution of LWG #2235; no stack allocation pending compiler support
Added:
libcxx/trunk/include/dynarray
libcxx/trunk/test/containers/sequences/dynarray/
libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/
libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/default.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.data/
libcxx/trunk/test/containers/sequences/dynarray/dynarray.data/default.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.mutate/
libcxx/trunk/test/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/
libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/at.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.traits/
libcxx/trunk/test/containers/sequences/dynarray/dynarray.traits/default.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/dynarray.zero/
libcxx/trunk/test/containers/sequences/dynarray/dynarray.zero/default.pass.cpp
libcxx/trunk/test/containers/sequences/dynarray/nothing_to_do.pass.cpp
Added: libcxx/trunk/include/dynarray
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/dynarray?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/include/dynarray (added)
+++ libcxx/trunk/include/dynarray Fri Sep 13 10:22:55 2013
@@ -0,0 +1,311 @@
+// -*- 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<iterator> reverse_iterator;
+ typedef reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+
+public:
+ // construct/copy/destroy:
+ explicit dynarray(size_type c);
+ template <typename Alloc>
+ dynarray(size_type c, const Alloc& alloc);
+ dynarray(size_type c, const T& v);
+ template <typename Alloc>
+ dynarray(size_type c, const T& v, const Alloc& alloc);
+ dynarray(const dynarray& d);
+ template <typename Alloc>
+ dynarray(const dynarray& d, const Alloc& alloc);
+ dynarray(initializer_list<T>);
+ template <typename Alloc>
+ dynarray(initializer_list<T>, 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 <__functional_base>
+#include <iterator>
+#include <stdexcept>
+#include <initializer_list>
+#include <new>
+#include <algorithm>
+
+#if defined(_LIBCPP_NO_EXCEPTIONS)
+ #include <cassert>
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY dynarray
+{
+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<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+private:
+ size_t __size_;
+ value_type * __base_;
+ _LIBCPP_ALWAYS_INLINE dynarray () noexcept : __base_(nullptr), __size_(0) {}
+
+ static inline _LIBCPP_INLINE_VISIBILITY value_type* __allocate ( size_t count )
+ {
+ if ( numeric_limits<size_t>::max() / sizeof (value_type) <= count )
+ {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+ throw bad_array_length();
+#else
+ assert(!"dynarray::allocation");
+#endif
+ }
+ return static_cast<value_type *> (::operator new (sizeof(value_type) * count));
+ }
+
+ static inline _LIBCPP_INLINE_VISIBILITY void __deallocate ( value_type* __ptr ) noexcept
+ {
+ ::operator delete (static_cast<void *> (__ptr));
+ }
+
+public:
+
+ explicit dynarray(size_type __c);
+ dynarray(size_type __c, const value_type& __v);
+ dynarray(const dynarray& __d);
+ dynarray(initializer_list<value_type>);
+
+// We're not implementing these right now.
+// Waiting for the resolution of LWG issue #2235
+// template <typename _Alloc>
+// dynarray(size_type __c, const _Alloc& __alloc);
+// template <typename _Alloc>
+// dynarray(size_type __c, const value_type& __v, const _Alloc& __alloc);
+// template <typename _Alloc>
+// dynarray(const dynarray& __d, const _Alloc& __alloc);
+// template <typename _Alloc>
+// dynarray(initializer_list<value_type>, const _Alloc& __alloc);
+
+ dynarray& operator=(const dynarray&) = delete;
+ ~dynarray();
+
+ // iterators:
+ inline _LIBCPP_INLINE_VISIBILITY iterator begin() noexcept { return iterator(data()); }
+ inline _LIBCPP_INLINE_VISIBILITY const_iterator begin() const noexcept { return const_iterator(data()); }
+ inline _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const noexcept { return const_iterator(data()); }
+ inline _LIBCPP_INLINE_VISIBILITY iterator end() noexcept { return iterator(data() + __size_); }
+ inline _LIBCPP_INLINE_VISIBILITY const_iterator end() const noexcept { return const_iterator(data() + __size_); }
+ inline _LIBCPP_INLINE_VISIBILITY const_iterator cend() const noexcept { return const_iterator(data() + __size_); }
+
+ inline _LIBCPP_INLINE_VISIBILITY reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+ inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+ inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
+ inline _LIBCPP_INLINE_VISIBILITY reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+ inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
+ inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
+
+ // capacity:
+ inline _LIBCPP_INLINE_VISIBILITY size_type size() const noexcept { return __size_; }
+ inline _LIBCPP_INLINE_VISIBILITY size_type max_size() const noexcept { return __size_; }
+ inline _LIBCPP_INLINE_VISIBILITY bool empty() const noexcept { return __size_ == 0; }
+
+ // element access:
+ inline _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) { return data()[__n]; }
+ inline _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const { return data()[__n]; }
+
+ inline _LIBCPP_INLINE_VISIBILITY reference front() { return data()[0]; }
+ inline _LIBCPP_INLINE_VISIBILITY const_reference front() const { return data()[0]; }
+ inline _LIBCPP_INLINE_VISIBILITY reference back() { return data()[__size_-1]; }
+ inline _LIBCPP_INLINE_VISIBILITY const_reference back() const { return data()[__size_-1]; }
+
+ inline _LIBCPP_INLINE_VISIBILITY const_reference at(size_type __n) const;
+ inline _LIBCPP_INLINE_VISIBILITY reference at(size_type __n);
+
+ // data access:
+ inline _LIBCPP_INLINE_VISIBILITY _Tp* data() noexcept { return __base_; }
+ inline _LIBCPP_INLINE_VISIBILITY const _Tp* data() const noexcept { return __base_; }
+
+ // mutating member functions:
+ inline _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __v) { fill_n(begin(), __size_, __v); }
+};
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::dynarray(size_type __c) : dynarray ()
+{
+ __base_ = __allocate (__c);
+ value_type *__data = data ();
+ for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
+ ::new (__data) value_type;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray ()
+{
+ __base_ = __allocate (__c);
+ value_type *__data = data ();
+ for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
+ ::new (__data) value_type (__v);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray ()
+{
+ size_t sz = __il.size();
+ __base_ = __allocate (sz);
+ value_type *__data = data ();
+ auto src = __il.begin();
+ for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
+ ::new (__data) value_type (*src);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray ()
+{
+ size_t sz = __d.size();
+ __base_ = __allocate (sz);
+ value_type *__data = data ();
+ auto src = __d.begin();
+ for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
+ ::new (__data) value_type (*src);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+dynarray<_Tp>::~dynarray()
+{
+ value_type *__data = data () + __size_;
+ for ( size_t i = 0; i < __size_; ++i )
+ (--__data)->value_type::~value_type();
+ __deallocate ( __base_ );
+}
+
+template <class _Tp>
+inline _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 <class _Tp>
+inline _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 <class _Tp, class _Alloc>
+struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<dynarray<_Tp>, _Alloc> : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // if _LIBCPP_STD_VER > 11
+#endif // _LIBCPP_DYNARRAY
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp Fri Sep 13 10:22:55 2013
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <class Alloc>
+// dynarray(size_type c, const Alloc& alloc);
+// template <class Alloc>
+// dynarray(size_type c, const T& v, const Alloc& alloc);
+// template <class Alloc>
+// dynarray(const dynarray& d, const Alloc& alloc);
+// template <class Alloc>
+// dynarray(initializer_list<T>, const Alloc& alloc);
+
+// ~dynarray();
+
+
+#include <__config>
+
+#if _LIBCPP_STD_VER > 11
+
+#include <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+#include "../../../test_allocator.h"
+
+template <class T, class Allocator>
+void check_allocator ( const std::dynarray<T> &dyn, const Allocator &alloc ) {
+ for ( int i = 0; i < dyn.size (); ++i )
+ assert ( dyn[i].get_allocator() == alloc );
+}
+
+template <class T, class Allocator>
+void test ( const std::initializer_list<T> &vals, const Allocator &alloc ) {
+ typedef std::dynarray<T> 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 <class T, class Allocator>
+void test ( const T &val, const Allocator &alloc1, const Allocator &alloc2 ) {
+ typedef std::dynarray<T> 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()
+{
+// This test is waiting on the resolution of LWG issue #2235
+// typedef test_allocator<char> Alloc;
+// typedef std::basic_string<char, std::char_traits<char>, 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
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/default.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/default.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.cons/default.pass.cpp Fri Sep 13 10:22:55 2013
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<T>);
+// dynarray(const dynarray& d);
+
+// ~dynarray();
+
+
+#include <__config>
+
+#if _LIBCPP_STD_VER > 11
+
+#include <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+template <class T>
+void test ( const std::initializer_list<T> &vals ) {
+ typedef std::dynarray<T> dynA;
+
+ dynA d1 ( vals );
+ assert ( d1.size () == vals.size() );
+ assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ()));
+ }
+
+
+template <class T>
+void test ( const T &val ) {
+ typedef std::dynarray<T> 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; } ));
+ }
+
+void test_bad_length () {
+ try { std::dynarray<int> ( std::numeric_limits<size_t>::max() / sizeof ( int ) + 1 ); }
+ catch ( std::bad_array_length & ) { return ; }
+ assert ( false );
+ }
+
+void test_bad_alloc () {
+ try { std::dynarray<int> ( std::numeric_limits<size_t>::max() / sizeof ( int ) - 1 ); }
+ catch ( std::bad_alloc & ) { return ; }
+ assert ( false );
+ }
+
+int main()
+{
+// test<int> ( 14 ); // ints don't get default initialized
+ test<long> ( 0 );
+ test<double> ( 14.0 );
+ test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
+ test<std::string> ( "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")} );
+
+// Make sure we don't pick up the Allocator version here
+ std::dynarray<long> d1 ( 20, 3 );
+ assert ( d1.size() == 20 );
+ assert ( std::all_of ( d1.begin (), d1.end (), []( long item ){ return item == 3L; } ));
+
+ test_bad_length ();
+ test_bad_alloc ();
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.data/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.data/default.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.data/default.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.data/default.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+
+template <class T>
+void dyn_test_const ( const std::dynarray<T> &dyn ) {
+ const T *data = dyn.data ();
+ assert ( data != NULL );
+ assert ( std::equal ( dyn.begin(), dyn.end(), data ));
+ }
+
+template <class T>
+void dyn_test ( std::dynarray<T> &dyn ) {
+ T *data = dyn.data ();
+ assert ( data != NULL );
+ assert ( std::equal ( dyn.begin(), dyn.end(), data ));
+ }
+
+
+
+template <class T>
+void test ( const T &val ) {
+ typedef std::dynarray<T> 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<int> ( 14 );
+ test<double> ( 14.0 );
+ test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
+ test<std::string> ( "fourteen" );
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+
+template <class T>
+void test ( const T &val ) {
+ typedef std::dynarray<T> 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<int> ( 14 );
+ test<double> ( 14.0 );
+ test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
+ test<std::string> ( "fourteen" );
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/at.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/at.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/at.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/at.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+template <class T>
+void dyn_at_fail ( std::dynarray<T> &dyn, size_t sz ) {
+ try { dyn.at (sz); }
+ catch (const std::out_of_range &) { return; }
+ assert ( false );
+ }
+
+template <class T>
+void dyn_at_fail_const ( const std::dynarray<T> &dyn, size_t sz ) {
+ try { dyn.at (sz); }
+ catch (const std::out_of_range &) { return; }
+ assert ( false );
+ }
+
+
+template <class T>
+void dyn_test_const ( const std::dynarray<T> &dyn, const std::initializer_list<T> &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 <class T>
+void dyn_test ( std::dynarray<T> &dyn, const std::initializer_list<T> &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 <class T>
+void test ( std::initializer_list<T> vals ) {
+ typedef std::dynarray<T> 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<int> ( {} );
+ test<std::complex<double>> ( {} );
+ test<std::string> ( {} );
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+template <class T>
+void dyn_test_const ( const std::dynarray<T> &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 <class T>
+void dyn_test ( std::dynarray<T> &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 <class T>
+void test ( const T &val ) {
+ typedef std::dynarray<T> 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<int> ( 14 );
+ test<double> ( 14.0 );
+ test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
+ test<std::string> ( "fourteen" );
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+template <class T>
+void dyn_test ( const std::dynarray<T> &dyn, size_t sz ) {
+ assert ( dyn.size () == sz );
+ assert ( dyn.max_size () == sz );
+ assert ( dyn.empty () == ( sz == 0 ));
+ }
+
+template <class T>
+void test ( std::initializer_list<T> vals ) {
+ typedef std::dynarray<T> 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<int> ( {} );
+ test<std::complex<double>> ( {} );
+ test<std::string> ( {} );
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+template <class T>
+void dyn_test_const ( const std::dynarray<T> &dyn ) {
+ const T *data = dyn.data ();
+ assert ( *data == dyn.front ());
+ assert ( *(data + dyn.size() - 1 ) == dyn.back ());
+ }
+
+template <class T>
+void dyn_test ( std::dynarray<T> &dyn ) {
+ T *data = dyn.data ();
+ assert ( *data == dyn.front ());
+ assert ( *(data + dyn.size() - 1 ) == dyn.back ());
+ }
+
+
+template <class T>
+void test ( const T &val ) {
+ typedef std::dynarray<T> 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<int> ( 14 );
+ test<double> ( 14.0 );
+ test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
+ test<std::string> ( "fourteen" );
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+template <class T>
+void dyn_test_const ( const std::dynarray<T> &dyn, const std::initializer_list<T> &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 <class T>
+void dyn_test ( std::dynarray<T> &dyn, const std::initializer_list<T> &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 <class T>
+void test ( std::initializer_list<T> vals ) {
+ typedef std::dynarray<T> 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<int> ( {} );
+ test<std::complex<double>> ( {} );
+ test<std::string> ( {} );
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.traits/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.traits/default.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.traits/default.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.traits/default.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <class Type, class Alloc>
+// struct uses_allocator<dynarray<Type>, Alloc> : true_type { };
+
+
+#include <__config>
+
+#if _LIBCPP_STD_VER > 11
+
+#include <dynarray>
+#include "../../../test_allocator.h"
+
+int main()
+{
+ static_assert ( std::uses_allocator<std::dynarray<int>, test_allocator<int>>::value, "" );
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/dynarray.zero/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/dynarray.zero/default.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/dynarray.zero/default.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/dynarray.zero/default.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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 <dynarray>
+#include <cassert>
+
+#include <algorithm>
+#include <complex>
+#include <string>
+
+
+template <class T>
+void test ( ) {
+ typedef std::dynarray<T> dynA;
+
+ dynA d1 ( 0 );
+ assert ( d1.size() == 0 );
+ assert ( d1.begin() == d1.end ());
+ }
+
+int main()
+{
+ test<int> ();
+ test<double> ();
+ test<std::complex<double>> ();
+ test<std::string> ();
+}
+#else
+int main() {}
+#endif
Added: libcxx/trunk/test/containers/sequences/dynarray/nothing_to_do.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/containers/sequences/dynarray/nothing_to_do.pass.cpp?rev=190697&view=auto
==============================================================================
--- libcxx/trunk/test/containers/sequences/dynarray/nothing_to_do.pass.cpp (added)
+++ libcxx/trunk/test/containers/sequences/dynarray/nothing_to_do.pass.cpp Fri Sep 13 10:22:55 2013
@@ -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()
+{
+}
More information about the cfe-commits
mailing list