LWG 1118

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@119541 91177308-0d34-0410-b5e6-96231b3b80d8

include/__tuple

@@ -26,8 +26,42 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> class _LIBCPP_VISIBLE tuple_size;
+
+template <class _Tp>
+class _LIBCPP_VISIBLE tuple_size<const _Tp>
+    : public tuple_size<_Tp> {};
+
+template <class _Tp>
+class _LIBCPP_VISIBLE tuple_size<volatile _Tp>
+    : public tuple_size<_Tp> {};
+
+template <class _Tp>
+class _LIBCPP_VISIBLE tuple_size<const volatile _Tp>
+    : public tuple_size<_Tp> {};
+
 template <size_t _Ip, class _Tp> class _LIBCPP_VISIBLE tuple_element;
 
+template <size_t _Ip, class _Tp>
+class _LIBCPP_VISIBLE tuple_element<_Ip, const _Tp>
+{
+public:
+    typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
+};
+
+template <size_t _Ip, class _Tp>
+class _LIBCPP_VISIBLE tuple_element<_Ip, volatile _Tp>
+{
+public:
+    typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
+};
+
+template <size_t _Ip, class _Tp>
+class _LIBCPP_VISIBLE tuple_element<_Ip, const volatile _Tp>
+{
+public:
+    typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
+};
+
 template <class ..._Tp> class _LIBCPP_VISIBLE tuple;
 template <class _T1, class _T2> class _LIBCPP_VISIBLE pair;
 template <class _Tp, size_t _Size> struct _LIBCPP_VISIBLE array;

include/tuple

@@ -127,12 +127,6 @@ class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...>>
 {
 };
 
-template <class ..._Tp>
-class _LIBCPP_VISIBLE tuple_size<const tuple<_Tp...>>
-    : public integral_constant<size_t, sizeof...(_Tp)>
-{
-};
-
 // tuple_element
 
 template <size_t _Ip, class ..._Tp>
@@ -142,13 +136,6 @@ public:
     typedef typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
 };
 
-template <size_t _Ip, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, const tuple<_Tp...>>
-{
-public:
-    typedef const typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
-};
-
 // __tuple_leaf
 
 template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value>

test/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp

@@ -21,27 +21,20 @@
 #include <tuple>
 #include <type_traits>
 
+template <class T, std::size_t N, class U>
+void test()
+{
+    static_assert((std::is_same<typename std::tuple_element<N, T>::type, U>::value), "");
+    static_assert((std::is_same<typename std::tuple_element<N, const T>::type, const U>::value), "");
+    static_assert((std::is_same<typename std::tuple_element<N, volatile T>::type, volatile U>::value), "");
+    static_assert((std::is_same<typename std::tuple_element<N, const volatile T>::type, const volatile U>::value), "");
+}
 int main()
 {
-    {
+    test<std::tuple<int>, 0, int>();
-        typedef std::tuple<int> T;
+    test<std::tuple<char, int>, 0, char>();
-        static_assert((std::is_same<std::tuple_element<0, T>::type,
+    test<std::tuple<char, int>, 1, int>();
-                                    int>::value), "");
+    test<std::tuple<int*, char, int>, 0, int*>();
-    }
+    test<std::tuple<int*, char, int>, 1, char>();
-    {
+    test<std::tuple<int*, char, int>, 2, int>();
-        typedef std::tuple<char, int> T;
-        static_assert((std::is_same<std::tuple_element<0, T>::type,
-                                    char>::value), "");
-        static_assert((std::is_same<std::tuple_element<1, T>::type,
-                                    int>::value), "");
-    }
-    {
-        typedef std::tuple<int*, char, int> T;
-        static_assert((std::is_same<std::tuple_element<0, T>::type,
-                                    int*>::value), "");
-        static_assert((std::is_same<std::tuple_element<1, T>::type,
-                                    char>::value), "");
-        static_assert((std::is_same<std::tuple_element<2, T>::type,
-                                    int>::value), "");
-    }
 }

test/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp

@@ -18,26 +18,23 @@
 #include <tuple>
 #include <type_traits>
 
+template <class T, std::size_t N>
+void test()
+{
+    static_assert((std::is_base_of<std::integral_constant<std::size_t, N>,
+                                   std::tuple_size<T> >::value), "");
+    static_assert((std::is_base_of<std::integral_constant<std::size_t, N>,
+                                   std::tuple_size<const T> >::value), "");
+    static_assert((std::is_base_of<std::integral_constant<std::size_t, N>,
+                                   std::tuple_size<volatile T> >::value), "");
+    static_assert((std::is_base_of<std::integral_constant<std::size_t, N>,
+                                   std::tuple_size<const volatile T> >::value), "");
+}
+
 int main()
 {
-    {
+    test<std::tuple<>, 0>();
-        typedef std::tuple<> T;
+    test<std::tuple<int>, 1>();
-        static_assert((std::is_base_of<std::integral_constant<std::size_t, 0>,
+    test<std::tuple<char, int>, 2>();
-                                      std::tuple_size<T> >::value), "");
+    test<std::tuple<char, char*, int>, 3>();
-    }
-    {
-        typedef std::tuple<int> T;
-        static_assert((std::is_base_of<std::integral_constant<std::size_t, 1>,
-                                      std::tuple_size<T> >::value), "");
-    }
-    {
-        typedef std::tuple<char, int> T;
-        static_assert((std::is_base_of<std::integral_constant<std::size_t, 2>,
-                                      std::tuple_size<T> >::value), "");
-    }
-    {
-        typedef std::tuple<char, char*, int> T;
-        static_assert((std::is_base_of<std::integral_constant<std::size_t, 3>,
-                                      std::tuple_size<T> >::value), "");
-    }
 }