2005-08-26 Paolo Carlini <pcarlini@suse.de>

	PR libstdc++/23081
	* include/tr1/array: Implement members back(), front(), data(),
	and the tuple interface; tidy.
	* testsuite/tr1/6_containers/array/element_access/back.cc: New.
	* testsuite/tr1/6_containers/array/element_access/data.cc: Likewise.
	* testsuite/tr1/6_containers/array/element_access/front.cc: Likewise.
	* testsuite/tr1/6_containers/array/tuple_interface/get.cc: Likewise.
	* testsuite/tr1/6_containers/array/tuple_interface/tuple_element.cc:
	Likewise.
	* testsuite/tr1/6_containers/array/tuple_interface/tuple_size.cc:
	Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@103525 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 87 insertions, 58 deletions

diff --git a/libstdc++-v3/include/tr1/array b/libstdc++-v3/include/tr1/array
index 4f91687b60f..4b500fc48a2 100644
--- a/libstdc++-v3/include/tr1/array
+++ b/libstdc++-v3/include/tr1/array
@@ -1,6 +1,6 @@
 // class template array -*- C++ -*-
 
-// Copyright (C) 2004 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2005 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -37,6 +37,7 @@
 #include <new>
 #include <iterator>
 #include <algorithm>
+#include <cstddef>
 #include <bits/functexcept.h>
 
 //namespace std::tr1
@@ -46,7 +47,7 @@ namespace tr1
 {
   /// @brief  struct array [6.2.2].
   /// NB: Requires complete type _Tp.
-  template<typename _Tp, size_t _Nm = 1>
+  template<typename _Tp, std::size_t _Nm = 1>
     struct array
     {
       typedef _Tp 	    			value_type;
@@ -54,8 +55,8 @@ namespace tr1
       typedef const value_type&             	const_reference;
       typedef value_type*          		iterator;
       typedef const value_type*			const_iterator;
-      typedef size_t                    	size_type;
-      typedef ptrdiff_t                     	difference_type;
+      typedef std::size_t                    	size_type;
+      typedef std::ptrdiff_t                   	difference_type;
       typedef std::reverse_iterator<iterator>	reverse_iterator;
       typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
 
@@ -76,35 +77,35 @@ namespace tr1
       // Iterators.
       iterator 
       begin()
-      { return reinterpret_cast<iterator>(&_M_instance[0]); }
+      { return &_M_instance[0]; }
 
       const_iterator 
       begin() const 
-      { return reinterpret_cast<const_iterator>(&_M_instance[0]); }
+      { return &_M_instance[0]; }
 
       iterator 
       end() 
-      { return reinterpret_cast<iterator>(&_M_instance[_Nm]); }
+      { return &_M_instance[_Nm]; }
 
       const_iterator 
       end() const
-      { return reinterpret_cast<const_iterator>(&_M_instance[_Nm]); }
+      { return &_M_instance[_Nm]; }
 
       reverse_iterator 
       rbegin()
-      { return reverse_iterator(this->end()); }
+      { return reverse_iterator(end()); }
 
       const_reverse_iterator 
       rbegin() const
-      { return const_reverse_iterator(this->end()); }
+      { return const_reverse_iterator(end()); }
 
       reverse_iterator 
       rend()
-      { return reverse_iterator(this->begin()); }
+      { return reverse_iterator(begin()); }
 
       const_reverse_iterator 
       rend() const
-      { return const_reverse_iterator(this->begin()); }
+      { return const_reverse_iterator(begin()); }
 
       // Capacity.
       size_type 
@@ -119,18 +120,18 @@ namespace tr1
       // Element access.
       reference 
       operator[](size_type __n)
-      { return reinterpret_cast<reference>(_M_instance[__n]); }
+      { return _M_instance[__n]; }
 
       const_reference 
       operator[](size_type __n) const
-      { return reinterpret_cast<const_reference>(_M_instance[__n]); }
+      { return _M_instance[__n]; }
 
       const_reference 
       at(size_type __n) const
       { 
 	if (__builtin_expect(__n > _Nm, false))
 	  std::__throw_out_of_range("array::at");
-	return reinterpret_cast<const_reference>(_M_instance[__n]); 
+	return _M_instance[__n]; 
       }
 
       reference 
@@ -138,67 +139,95 @@ namespace tr1
       { 
 	if (__builtin_expect(__n > _Nm, false))
 	  std::__throw_out_of_range("array::at");
-	return reinterpret_cast<reference>(_M_instance[__n]); 
+	return _M_instance[__n]; 
       }
 
       reference 
-      front(); 
+      front()
+      { return *begin(); }
 
       const_reference 
-      front() const; 
+      front() const
+      { return *begin(); }
 
       reference 
-      back(); 
+      back()
+      { return *(end() - 1); }
 
       const_reference 
-      back() const; 
+      back() const
+      { return *(end() - 1); }
 
       _Tp* 
-      data(); 
+      data()
+      { return &_M_instance[0]; }
 
       const _Tp* 
-      data() const;
+      data() const
+      { return &_M_instance[0]; }
     };
 
   // Array comparisons.
- template<typename _Tp, size_t _Nm>
-   bool 
-   operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-   { return std::equal(__one.begin(), __one.end(), __two.begin()); }
-
- template<typename _Tp, size_t _Nm>
-   bool 
-   operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-   { return !(__one == __two); }
-
- template<typename _Tp, size_t _Nm>
-   bool 
-   operator<(const array<_Tp, _Nm>& a, const array<_Tp, _Nm>& b)
-   { 
-     return std::lexicographical_compare(a.begin(), a.end(), 
-					 b.begin(), b.end()); 
-   }
-
- template<typename _Tp, size_t _Nm>
-   bool 
-   operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-   { return __two < __one; }
-
- template<typename _Tp, size_t _Nm>
-   bool 
-   operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-   { return !(__one > __two); }
-
- template<typename _Tp, size_t _Nm>
-   bool 
-   operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-   { return !(__one < __two); }
+  template<typename _Tp, std::size_t _Nm>
+    bool 
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+  template<typename _Tp, std::size_t _Nm>
+    bool 
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    bool 
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    { 
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+					  __b.begin(), __b.end()); 
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+    bool 
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+    bool 
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    bool 
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
 
   // Specialized algorithms [6.2.2.2].
- template<typename _Tp, size_t _Nm>
-   void
-   swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
-   { swap_ranges(__one.begin(), __one.end(), __two.begin()); }
+  template<typename _Tp, std::size_t _Nm>
+    void
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    { swap_ranges(__one.begin(), __one.end(), __two.begin()); }
+
+  // Tuple interface to class template array [6.2.2.5].
+  template<typename _Tp> class tuple_size;
+  template<int _Int, typename _Tp> class tuple_element;
+  
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<array<_Tp, _Nm> >
+    { static const int value = _Nm; };
+ 
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, array<_Tp, _Nm> >
+    { typedef _Tp type; };
+
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    _Tp&
+    get(array<_Tp, _Nm>& __arr)
+    { return __arr[_Int]; }
+
+  template<int _Int, typename _Tp, std::size_t _Nm>
+    const _Tp&
+    get(const array<_Tp, _Nm>& __arr)
+    { return __arr[_Int]; }
 } // namespace std::tr1
 }