stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elemi...@apache.org
Subject svn commit: r668829 - in /stdcxx/branches/4.3.x: include/rw/_forward.h include/rw/_tuple.h include/rw/_tuple_traits.h include/tuple tests/utilities/20.tuple.cnstr.cpp tests/utilities/20.tuple.h
Date Tue, 17 Jun 2008 21:03:44 GMT
Author: elemings
Date: Tue Jun 17 14:03:43 2008
New Revision: 668829

URL: http://svn.apache.org/viewvc?rev=668829&view=rev
Log:
2008-06-17  Eric Lemings <eric.lemings@roguewave.com>

	STDCXX-958
	* include/tuple (tuple_size): Implemented and documented.
	* include/rw/_tuple_traits.h: Corrected documentation for
	grouping and template parameters.
	* include/rw/_forward.h: Likewise.
	* include/rw/_tuple.h: Likewise.  Also, corrected/implemented,
	documented more constructors and operators.
	* tests/utilities/20.tuple.h: Added missing header.
	* tests/utilities/20.tuple.cnstr.cpp: Added more constructor,
	operator tests.


Added:
    stdcxx/branches/4.3.x/tests/utilities/20.tuple.h
Modified:
    stdcxx/branches/4.3.x/include/rw/_forward.h
    stdcxx/branches/4.3.x/include/rw/_tuple.h
    stdcxx/branches/4.3.x/include/rw/_tuple_traits.h
    stdcxx/branches/4.3.x/include/tuple
    stdcxx/branches/4.3.x/tests/utilities/20.tuple.cnstr.cpp

Modified: stdcxx/branches/4.3.x/include/rw/_forward.h
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/include/rw/_forward.h?rev=668829&r1=668828&r2=668829&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/include/rw/_forward.h (original)
+++ stdcxx/branches/4.3.x/include/rw/_forward.h Tue Jun 17 14:03:43 2008
@@ -49,7 +49,7 @@
  * correct move/forwarding semantics, usually in the \c std::forward()
  * function.
  *
- * @param _Type Any type.  No restrictions or requirements.
+ * @tparam _Type Any type.  No restrictions or requirements.
  * @see std::forward
  */
 template <class _Type>
@@ -78,7 +78,7 @@
  * is used to ensure that the appropriate reference type is used in move
  * semantics.
  *
- * @param _Type An lvalue or rvalue reference type.
+ * @tparam _Type An lvalue or rvalue reference type.
  * @param __x An lvalue reference or rvalue reference.
  * @returns An lvalue if __x is an lvalue reference; otherwise, an rvalue.
  */
@@ -95,6 +95,7 @@
  * explicitly bind constructors and other functions with rvalue
  * references that employ move semantics.
  *
+ * @tparam _Type Any type.  No requirements or restrictions.
  * @param __x An lvalue or rvalue.
  * @returns Same value as parameter with rvalue reference type.
  */

Modified: stdcxx/branches/4.3.x/include/rw/_tuple.h
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/include/rw/_tuple.h?rev=668829&r1=668828&r2=668829&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/include/rw/_tuple.h (original)
+++ stdcxx/branches/4.3.x/include/rw/_tuple.h Tue Jun 17 14:03:43 2008
@@ -42,29 +42,37 @@
 #    if !defined _RWSTD_NO_VARIADIC_TEMPLATES
 
 
+/// @defgroup tuple Tuples [tuple]
+/// @{
+
 _RWSTD_NAMESPACE (std) {
 
 
 // 20.3.1, class template tuple:
 
 /**
- * @defgroup tuple Tuples [tuple]
- *
  * A fixed-size collection of values with variable, heterogenous types.
  * This class template is used to instantatiate tuple types.  A tuple
  * type specifies zero or more element types for defining tuple values.
  * A tuple value can be constructed from a tuple type that holds one
  * value for each element type in the tuple.
  *
- * @param Types A list of zero or more types.  No applicable type
- *              requirements or restrictions.
+ * By definition, a homogenous tuple is a tuple that has the exact same
+ * number and type of elements as another tuple type.  A heterogenous
+ * tuple is just the opposite: a tuple type that has either a different
+ * number of element types or one or more different element types.
+ *
+ * @tparam Types A list of zero or more types.  No applicable type
+ *               requirements or restrictions.
  */
 template < class... Types >
 class tuple;
 
 /**
  * @internal
- * The template specialization for empty tuples.
+ * The template specialization for empty tuples.  This specialization
+ * also serves as the terminating instantiation of a recursive tuple
+ * with one or more element types.
  */
 _RWSTD_SPECIALIZED_CLASS
 class tuple< >
@@ -78,8 +86,8 @@
  * template is used to instantiate all tuple types except for empty
  * tuples and tuples with exactly two element types.
  *
- * @param _HeadT First element type (required).
- * @param _TailT Template parameter pack for remaining element types.
+ * @tparam _HeadT First element type (required).
+ * @tparam _TailT Zero or more additional element types.
  */
 template < class _HeadT, class... _TailT >
 class tuple< _HeadT, _TailT... >
@@ -97,38 +105,61 @@
      * Construct tuple with default values.
      */
     tuple ()
-        : _C_head (), _Base () { /* empty */ }
+        : _Base (), _C_head () { /* empty */ }
 
     /**
      * Copy construct tuple from a different tuple value.
      * @param __tuple Another tuple value with same type.
      */
     tuple (const tuple& __tuple)
-        : _C_head (__tuple._C_head), _Base (__tuple) { /* empty */ }
+        : _Base (__tuple), _C_head (__tuple._C_head) { /* empty */ }
 
     /**
      * Copy assign tuple from a different tuple value.
+     * @param __tuple Some other tuple value.
      * @param __tuple Another tuple value with same type.
+     * @return This tuple value.
      */
     tuple& operator= (const tuple& __tuple) {
-        _C_head = __tuple._C_head;
         _Base::operator= (__tuple);
+        _C_head = __tuple._C_head;
         return *this;
     }
 
+    /**
+     * Copy construct tuple from element values.  This explicit
+     * constructor creates a tuple value from element values.
+     *
+     * @param __head A value corresponding to first tuple element type.
+     * @param __tail List of corresponding values of remaining tuple
+     *               element types.
+     */
     _EXPLICIT
     tuple (const _HeadT& __head, const _TailT&... __tail)
-        : _C_head (__head), _Base (__tail...) { /* empty */ }
+        : _Base (__tail...), _C_head (__head) { /* empty */ }
 
 #      if !defined _RWSTD_NO_RVALUE_REFERENCES
 
+    /**
+     * Construct tuple by moving a value from some other tuple value.
+     * This move constructor moves the value from the given tuple value
+     * into this tuple.
+     * @param __tuple Some other homogenous tuple value.
+     */
     tuple (tuple&& __tuple)
-        : _C_head (std::move (__tuple._C_head))
-        , _Base (std::forward<_Base> (__tuple)) { /* empty */ }
+        : _Base (std::forward<_Base> (__tuple))
+        , _C_head (_RWSTD_MOVE (__tuple._C_head)) { /* empty */ }
 
+    /**
+     * Assign tuple by moving a value from some other tuple value.
+     * This assignment operator moves the value from the given tuple
+     * value into this tuple.
+     * @param __tuple Some other homogenous tuple value.
+     * @returns Lvalue reference to this tuple value.
+     */
     tuple& operator= (tuple&& __tuple) {
-        _C_head = std::move (__tuple._C_head);
         _Base::operator= (__tuple);
+        _C_head = _RWSTD_MOVE (__tuple._C_head);
         return *this;
     }
 
@@ -136,11 +167,33 @@
 
 #      if !defined _RWSTD_NO_MEMBER_TEMPLATES
 
+    /**
+     * Construct tuple by copying a heterogenous tuple value.  This copy
+     * constructor copies the value from a compatible, heterogenous
+     * tuple.
+     * @tparam _HeadU First element type in tuple.
+     * @tparam _TailU Remaining element types in tuple.
+     * @param __tuple A compatible, heterogenous tuple value.
+     */
     template <class _HeadU, class... _TailU>
-    tuple (const tuple<_HeadU, _TailU...>& __tuple);
+    tuple (const tuple<_HeadU, _TailU...>& __tuple)
+        : _Base (__tuple), _C_head (__tuple._C_head) { /* empty */ }
 
+    /**
+     * Assign tuple by copying a heterogenous tuple value.  This
+     * assignment operator copies the value from a compatible,
+     * heterogenous tuple.
+     * @tparam _HeadU First element type in tuple.
+     * @tparam _TailU Remaining element types in tuple.
+     * @param __tuple A compatible, heterogenous tuple value.
+     * @returns Lvalue reference to this tuple value.
+     */
     template <class _HeadU, class... _TailU>
-    tuple& operator= (const tuple<_HeadU, _TailU...>& __tuple);
+    tuple& operator= (const tuple<_HeadU, _TailU...>& __tuple) {
+        _Base::operator= (__tuple);
+        _C_head = __tuple._C_head;
+        return *this;
+    }
 
 #      endif   // !defined _RWSTD_NO_MEMBER_TEMPLATES
 
@@ -163,33 +216,61 @@
 
 #      if !defined _RWSTD_NO_MEMBER_TEMPLATES
 
-template <class _TypeT1, class _TypeT2>
-class tuple<_TypeT1, _TypeT2>
-    : pair<_TypeT1, _TypeT2>
+/**
+ * @internal
+ * Template specialization for tuples with exactly two element types.
+ * This specialization provides additional constructors and operators for
+ * making class template \c std::pair implicitly compatible with tuples.
+ * @tparam _TypeT1 First element type.
+ * @tparam _TypeT2 Second element type.
+ */
+template < class _TypeT1, class _TypeT2 >
+class tuple< _TypeT1, _TypeT2 >
 {
-    typedef pair< _TypeT1, _TypeT2 > _Base;
+    _TypeT1 _C_first;
+    _TypeT2 _C_second;
 
 public:
 
-    tuple (): _Base () { /* empty */ }
-    tuple (const tuple& __tuple): _Base (__tuple) { /* empty */ }
-    tuple& operator= (const tuple& __tuple);
+    tuple (): _C_first (), _C_second () { /* empty */ }
+
+    tuple (const tuple& __tuple)
+        : _C_first (__tuple._C_first)
+        , _C_second (__tuple._C_second) { /* empty */ }
+
+    tuple& operator= (const tuple& __tuple) {
+        _C_first = __tuple._C_first;
+        _C_second = __tuple._C_second;
+        return *this;
+    }
 
-    _EXPLICIT tuple (const _TypeT1& __t1, const _TypeT2& __t2);
+    _EXPLICIT tuple (const _TypeT1& __t1, const _TypeT2& __t2)
+        : _C_first (__t1), _C_second (__t2) { /* empty */ }
 
     template <class _TypeU1, class _TypeU2>
-    tuple (const pair<_TypeU1, _TypeU2>& __pair);
+    tuple (const pair<_TypeU1, _TypeU2>& __pair)
+        : _C_first (__pair.first), _C_second (__pair.second) { /* empty */ }
 
     template <class _TypeU1, class _TypeU2>
-    tuple& operator= (const pair<_TypeU1, _TypeU2>& __pair);
+    tuple& operator= (const pair<_TypeU1, _TypeU2>& __pair) {
+        _C_first = __pair.first;
+        _C_second = __pair.second;
+        return *this;
+    }
 
 #        if !defined _RWSTD_NO_RVALUE_REFERENCES
 
     template <class _TypeU1, class _TypeU2>
-    tuple (pair<_TypeU1, _TypeU2>&& __pair);
+    tuple (pair<_TypeU1, _TypeU2>&& __pair)
+        : _C_first (_RWSTD_MOVE (__pair.first))
+        , _C_second (_RWSTD_MOVE (__pair.second)) { /* empty */ }
 
     template <class _TypeU1, class _TypeU2>
-    tuple& operator= (pair<_TypeU1, _TypeU2>&& __pair);
+    tuple& operator= (pair<_TypeU1, _TypeU2>&& __pair) {
+        _C_first = _RWSTD_MOVE (__pair.first);
+        _C_second = _RWSTD_MOVE (__pair.second);
+        return *this;
+    }
 
 #        endif   // !defined _RWSTD_NO_RVALUE_REFERENCES
 
@@ -198,6 +279,8 @@
 #      endif   // !defined _RWSTD_NO_MEMBER_TEMPLATES
 
 
+/// @}
+
 }   // namespace std
 
 

Modified: stdcxx/branches/4.3.x/include/rw/_tuple_traits.h
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/include/rw/_tuple_traits.h?rev=668829&r1=668828&r2=668829&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/include/rw/_tuple_traits.h (original)
+++ stdcxx/branches/4.3.x/include/rw/_tuple_traits.h Tue Jun 17 14:03:43 2008
@@ -37,6 +37,9 @@
 #    include <rw/_meta_help.h>  // for __rw_true_type
 
 
+/// @ingroup tuple
+/// @{
+
 _RWSTD_NAMESPACE (std) {
 
 
@@ -50,8 +53,8 @@
  * other library components that tuple can be constructed with an
  * allocator even though it does not have a nested allocator_type.
  *
- * @param _Types Type list of tuple.
- * @param _Alloc Must conform to Allocator requirements (20.1.2).
+ * @tparam _Types List of element types in tuple.
+ * @tparam _Alloc Must conform to Allocator requirements (20.1.2).
  */
 template <class... _Types, class _Alloc> 
 struct uses_allocator<tuple<_Types...>, _Alloc>
@@ -69,7 +72,7 @@
  * trait informs other library components that tuple can be constructed
  * with an allocator prefix argument.
  *
- * @param _Types Type list of tuple.
+ * @tparam _Types List of element types in tuple.
  */
 template <class... _Types> 
 struct constructible_with_allocator_prefix<tuple<_Types...> > 
@@ -79,6 +82,8 @@
 }; 
 
 
+/// @}
+
 }   // namespace std
 
 

Modified: stdcxx/branches/4.3.x/include/tuple
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/include/tuple?rev=668829&r1=668828&r2=668829&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/include/tuple (original)
+++ stdcxx/branches/4.3.x/include/tuple Tue Jun 17 14:03:43 2008
@@ -34,6 +34,8 @@
 #ifndef _RWSTD_TUPLE_INCLUDED
 #  define _RWSTD_TUPLE_INCLUDED
 
+#  include <rw/_defs.h>
+#  include <rw/_meta_help.h>        // for __rw_integral_constant
 #  include <rw/_tuple.h>
 #  include <rw/_tuple_traits.h>
 
@@ -98,8 +100,20 @@
 template <class>
 class tuple_size; // undefined
 
+/**
+ * Determine number of element types in tuple.  This compile-time
+ * integral constant wrapper determines the number of element types in
+ * a tuple.  The class template is ill-formed for any non-tuple typle.
+ *
+ * @tparam _Types List of element types in tuple.
+ */
 template <class... _Types>
-class tuple_size<tuple<_Types...> >;
+class tuple_size< tuple<_Types...> >
+    : _RW::__rw_integral_constant< _RWSTD_SIZE_T, sizeof... (_Types) >
+{
+    // empty
+};
+
 
 template <int, class>
 class tuple_element; // undefined

Modified: stdcxx/branches/4.3.x/tests/utilities/20.tuple.cnstr.cpp
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/tests/utilities/20.tuple.cnstr.cpp?rev=668829&r1=668828&r2=668829&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/tests/utilities/20.tuple.cnstr.cpp (original)
+++ stdcxx/branches/4.3.x/tests/utilities/20.tuple.cnstr.cpp Tue Jun 17 14:03:43 2008
@@ -39,52 +39,91 @@
 {
     rw_info (0, __FILE__, __LINE__, "default constructor");
 
-    NullTuple null_tuple;
-    _RWSTD_UNUSED (null_tuple);
-
-    IntTuple int_tuple;
-    _RWSTD_UNUSED (int_tuple);
+    EmptyTuple et; _RWSTD_UNUSED (et);
+    IntTuple it; _RWSTD_UNUSED (it);
+    ConstIntTuple ct; _RWSTD_UNUSED (ct);
+    PairTuple pt; _RWSTD_UNUSED (pt);
+    NestedTuple nt; _RWSTD_UNUSED (nt);
+    BigTuple bt; _RWSTD_UNUSED (bt);
 
     UserClass::reset_totals ();
-    UserTuple user_tuple;
-    _RWSTD_UNUSED (user_tuple);
+    UserTuple ut; _RWSTD_UNUSED (ut);
+
     rw_assert (UserClass::n_total_def_ctor_ == 1, __FILE__, __LINE__,
                "tuple<UserClass>::tuple() called %d default ctors, "
                "expected 1", UserClass::n_total_def_ctor_);
+}
+
+/**************************************************************************/
+
+static void
+test_value_copy_ctor ()
+{
+    rw_info (0, __FILE__, __LINE__, "value copy constructor");
+
+    const int i = 1;
+    const IntTuple it (i);
+    ConstIntTuple ct (i); _RWSTD_UNUSED (ct);
+    NestedTuple nt (it);
+
+    const long l = 1;
+    const char* s = "string";
+    PairTuple pt (l, s);
+
+    UserClass::reset_totals ();
+    const UserClass uc;
+    UserTuple ut (uc); _RWSTD_UNUSED (ut);
+
+    rw_assert (1 == UserClass::n_total_def_ctor_, __FILE__, __LINE__,
+               "tuple<UserClass>::tuple() called %d default ctors, "
+               "expected 1", UserClass::n_total_def_ctor_);
+
+    const bool b = true; const char c = 'a';
+    const double d = 1.2; void* const p = 0;
+    BigTuple bt (b, c, i, d, p, uc); _RWSTD_UNUSED (bt);
+}
+
+/**************************************************************************/
 
-    BigTuple big_tuple;
-    _RWSTD_UNUSED (big_tuple);
+static void
+test_value_move_ctor ()
+{
+    rw_info (0, __FILE__, __LINE__, "value move constructor");
 
-    NestedTuple nested_tuple;
-    _RWSTD_UNUSED (nested_tuple);
 }
 
 /**************************************************************************/
 
 static void
-test_value_ctor ()
+test_homo_copy_ctor ()
 {
-    rw_info (0, __FILE__, __LINE__, "value constructor");
-/*
-    // stored values are verified by get() tests in 20.tuple.elem
-    IntTuple it1 (1);
-    _RWSTD_UNUSED (it1);
-    int i1 = 1;
-    IntTuple it2 (i1);
-    _RWSTD_UNUSED (it2);
+    rw_info (0, __FILE__, __LINE__, "copy constructor (homogenous tuples)");
+
+    EmptyTuple et1, et2 (et1);
+    _RWSTD_UNUSED (et2);
+
+    const IntTuple it1;
+    IntTuple it2 (it1); _RWSTD_UNUSED (it2);
+
+    const ConstIntTuple ct1;
+    ConstIntTuple ct2 (ct1); _RWSTD_UNUSED (ct2);
+
+    PairTuple pt1;
+    PairTuple pt2 (pt1); _RWSTD_UNUSED (pt2);
+
+    const NestedTuple nt1;
+    NestedTuple nt2 (nt1); _RWSTD_UNUSED (nt2);
 
     UserClass::reset_totals ();
-    UserTuple ut1 (UserClass ());
+    const UserTuple ut1; UserTuple ut2 (ut1);
+    _RWSTD_UNUSED (ut1);
+
     rw_assert (UserClass::n_total_def_ctor_ == 1, __FILE__, __LINE__,
                "tuple<UserClass>::tuple() called %d default ctors, "
                "expected 1", UserClass::n_total_def_ctor_);
 
-    UserTuple ut1 (UserClass ());
-    _RWSTD_UNUSED (ut1);
-
-    // test constructor signature for reference and non-reference types
-    // test return type for reference and non-reference types
-*/
+    const BigTuple bt1; //BigTuple bt2 (bt1);
+    _RWSTD_UNUSED (bt1); //_RWSTD_UNUSED (bt2);
 }
 
 /**************************************************************************/
@@ -93,14 +132,19 @@
 run_test (int /*unused*/, char* /*unused*/ [])
 {
     test_default_ctor ();
-    test_value_ctor ();
 
-    //test_homogenous_copy_ctor ();
-    //test_heterogenous_copy_ctor ();
-    //test_pair_copy_ctor ();
+    test_value_copy_ctor ();
+    test_value_move_ctor ();
 
-    //test_homogenous_copy_assignment ();
-    //test_heterogenous_copy_assignment ();
+    test_homo_copy_ctor ();
+    //test_homo_move_ctor ();
+    //test_homo_copy_assign ();
+    //test_homo_move_assign ();
+
+    //test_hetero_copy_ctor ();
+    //test_hetero_move_ctor ();
+    //test_hetero_copy_assign ();
+    //test_hetero_move_assign ();
 
     //test_pair_copy_ctor ();
     //test_pair_move_ctor ();

Added: stdcxx/branches/4.3.x/tests/utilities/20.tuple.h
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/tests/utilities/20.tuple.h?rev=668829&view=auto
==============================================================================
--- stdcxx/branches/4.3.x/tests/utilities/20.tuple.h (added)
+++ stdcxx/branches/4.3.x/tests/utilities/20.tuple.h Tue Jun 17 14:03:43 2008
@@ -0,0 +1,54 @@
+/***************************************************************************
+ *
+ * 20.tuple.h - common support for all tuple tests
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * Licensed to the Apache Software  Foundation (ASF) under one or more
+ * contributor  license agreements.  See  the NOTICE  file distributed
+ * with  this  work  for  additional information  regarding  copyright
+ * ownership.   The ASF  licenses this  file to  you under  the Apache
+ * License, Version  2.0 (the  "License"); you may  not use  this file
+ * except in  compliance with the License.   You may obtain  a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the  License is distributed on an  "AS IS" BASIS,
+ * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
+ * implied.   See  the License  for  the  specific language  governing
+ * permissions and limitations under the License.
+ *
+ * Copyright 1994-2008 Rogue Wave Software.
+ * 
+ **************************************************************************/
+
+#ifndef RW_20_TUPLE_H_INCLUDED
+#define RW_20_TUPLE_H_INCLUDED
+
+#include <tuple>
+
+#include <rw/_meta_prop.h>
+
+#include <rw_driver.h>
+#include <rw_value.h>
+
+
+// various tuple types for test purposes
+
+typedef std::tuple < >                      EmptyTuple;
+typedef std::tuple < int >                  IntTuple;
+typedef std::tuple < const int >            ConstIntTuple;
+typedef std::tuple < long, const char* >    PairTuple;
+typedef std::tuple < UserClass >            UserTuple;
+typedef std::tuple < std::tuple < int > >   NestedTuple;
+
+#define BigList      bool, char, int, double, void*, UserClass
+
+typedef std::tuple < BigList >              BigTuple;
+
+
+#endif   // define RW_20_TUPLE_H_INCLUDED



Mime
View raw message