stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elemi...@apache.org
Subject svn commit: r671306 - in /stdcxx/branches/4.3.x: doc/Doxyfile include/rw/_forward.h include/rw/_ref_wrap.h include/rw/_tuple.h include/rw/_tuple_traits.h include/tuple
Date Tue, 24 Jun 2008 19:11:52 GMT
Author: elemings
Date: Tue Jun 24 12:11:52 2008
New Revision: 671306

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

	STDCXX-958
	* include/tuple: Removed comments containing public API
	documentation in the interests implementing C++0x features as
	quickly as possible by saving time writing further documentation
	and dealing with documentation-related issues in the foreseeable
	future.
	* include/rw/_tuple.h: Likewise.
	* include/rw/_tuple_traits.h: Likewise.
	* include/rw/_forward.h: Likewise.
	* include/rw/_ref_wrap.h: Likewise.
	* doc/Doxyfile: Not needed for now.


Removed:
    stdcxx/branches/4.3.x/doc/Doxyfile
Modified:
    stdcxx/branches/4.3.x/include/rw/_forward.h
    stdcxx/branches/4.3.x/include/rw/_ref_wrap.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

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=671306&r1=671305&r2=671306&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/include/rw/_forward.h (original)
+++ stdcxx/branches/4.3.x/include/rw/_forward.h Tue Jun 24 12:11:52 2008
@@ -42,30 +42,11 @@
 
 // [20.2.2]  forward/move helpers
 
-/**
- * An identity wrapper.  Similar to the identity property, the identity
- * wrapper is a class template that simply reflects the type of its
- * template parameter.  This class template is used when a template
- * parameter type must be explicitly specified in order to apply the
- * correct move/forwarding semantics, usually in the \c std::forward()
- * function.
- *
- * @tparam _Type Any type.  No restrictions or requirements.
- * @see std::forward
- */
 template <class _Type>
 struct identity
 {
-    /** Identifies template parameter type. */
     typedef _Type type;
 
-    /**
-     * Conversion operator.  This operator converts the parameter value
-     * to the wrapped identity type.
-     *
-     * @param __x An value convertible to identity type.
-     * @return Same value as the function argument with identity type.
-     */
     const _Type& operator() (const _Type& __x) const {
         return __x;
     }
@@ -74,15 +55,6 @@
 
 #    if !defined _RWSTD_NO_RVALUE_REFERENCES
 
-/**
- * Forwards appropriate rvalue or lvalue reference type.  This function
- * is used to ensure that the appropriate reference type is used in move
- * semantics.
- *
- * @tparam _Type An lvalue or rvalue reference type.
- * @param __x An lvalue reference or rvalue reference.
- * @return An lvalue if __x is an lvalue reference; otherwise, an rvalue.
- */
 _EXPORT
 template <class _Type>
 _Type&&
@@ -91,15 +63,6 @@
     return __x;
 }
 
-/**
- * Move a value to an rvalue reference.  This function is used to
- * 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.
- * @return Same value as parameter with rvalue reference type.
- */
 _EXPORT
 template <class _Type>
 _TYPENAME _RW::__rw_remove_reference<_Type>::type&&
@@ -108,11 +71,6 @@
     return __x;
 }
 
-/**
- * @internal
- * Internal wrapper macro to utilize move semantics if available.
- * @param __x An lvalue or rvalue.
- */
 #      define _RWSTD_MOVE(__x)   std::move (__x)
 #    else   // no rvalue references
 #      define _RWSTD_MOVE(__x)   (__x)

Modified: stdcxx/branches/4.3.x/include/rw/_ref_wrap.h
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/include/rw/_ref_wrap.h?rev=671306&r1=671305&r2=671306&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/include/rw/_ref_wrap.h (original)
+++ stdcxx/branches/4.3.x/include/rw/_ref_wrap.h Tue Jun 24 12:11:52 2008
@@ -39,15 +39,6 @@
 _RWSTD_NAMESPACE (__rw) {
 
 
-/**
- * @class std::reference_wrapper
- *
- * Encapsulates a reference as an object.  This class template allows
- * references to be manipulated and behave as an ordinary object.
- *
- * @tparam Type A non-reference type.
- */
-
 template <class _Type>
 class __rw_ref_wrap
 {

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=671306&r1=671305&r2=671306&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/include/rw/_tuple.h (original)
+++ stdcxx/branches/4.3.x/include/rw/_tuple.h Tue Jun 24 12:11:52 2008
@@ -49,52 +49,22 @@
 
 // 20.3.1, class template 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.
- *
- * 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.  This specialization
- * also serves as the terminating instantiation of a recursive tuple
- * with one or more element types.
- */
 _RWSTD_SPECIALIZED_CLASS
 class tuple< >
 {
     // empty
 };
 
-/**
- * @internal
- * The basic template specialization for most tuples.  This class
- * template is used to instantiate all tuple types except for empty
- * tuples and tuples with exactly two 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... >
     : public tuple< _TailT... >
 {
     typedef tuple< _TailT... >  _Base;
 
-protected:
+//protected:
 
     _HeadT        _C_head;
 
@@ -106,63 +76,29 @@
     _HeadT&       __get ()       { return _C_head; }
     const _HeadT& __get () const { return _C_head; }
 
-    /**
-     * Construct tuple with default values.
-     */
     tuple ()
         : _Base (), _C_head () { /* empty */ }
 
-    /**
-     * Copy construct tuple from a different tuple value.
-     * @param __tuple Another tuple value with same type.
-     */
     tuple (const tuple& __tuple)
         : _Base (__tuple._C_tail ())
         , _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) {
         _Base::operator= (__tuple._C_tail ());
         _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)
         : _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)
         : _Base (std::forward<_Base> (__tuple._C_tail ()))
         , _C_head (_RWSTD_MOVE (__tuple._C_head)) { /* empty */ }
 
-    /**
-     * Assign tuple by moving a value from some other homogenous tuple.
-     * This assignment operator moves the value from the given tuple
-     * value into this tuple.
-     * @param __tuple Some other homogenous tuple value.
-     * @return Lvalue reference to this tuple value.
-     */
     tuple& operator= (tuple&& __tuple) {
         _Base::operator= (std::forward<_Base> (__tuple._C_tail ()));
         _C_head = _RWSTD_MOVE (__tuple._C_head);
@@ -171,28 +107,11 @@
 
 #      endif   // !defined _RWSTD_NO_RVALUE_REFERENCES
 
-    /**
-     * 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)
         : _Base (__tuple._C_tail ())
         , _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.
-     * @return Lvalue reference to this tuple value.
-     */
     template <class _HeadU, class... _TailU>
     tuple& operator= (const tuple<_HeadU, _TailU...>& __tuple) {
         _Base::operator= (__tuple._C_tail ());
@@ -202,41 +121,16 @@
 
 #      if !defined _RWSTD_NO_RVALUE_REFERENCES
 
-    /**
-     * Construct tuple by moving element values.  This explicit move
-     * constructor moves values from the corresponding element types.
-     * @tparam _HeadU First element type in other tuple.
-     * @tparam _TailU Remaining element types in other tuple.
-     * @param __head First value in element type list.
-     * @param __tail Remaining values in element type list.
-     */
     template <class _HeadU, class... _TailU>
     _EXPLICIT tuple (_HeadU&& __head, _TailU&&... __tail)
         : _Base (std::forward<_TailU> (__tail)...)
         , _C_head (_RWSTD_MOVE (__head)) { /* empty */ }
 
-    /**
-     * Construct tuple by moving a heterogenous tuple value.  This move
-     * constructor moves values from a heterogenous tuple into this
-     * tuple value.
-     * @tparam _HeadU First element type in other tuple.
-     * @tparam _TailU Remaining element types in other tuple.
-     * @param __tuple A compatible, heterogenous tuple value.
-     */
     template <class _HeadU, class... _TailU>
     tuple (tuple<_HeadU, _TailU...>&& __tuple)
         : _Base (std::forward<_Base> (__tuple._C_tail ()))
         , _C_head (_RWSTD_MOVE (__tuple._C_head)) { /* empty */ }
 
-    /**
-     * Assign tuple by moving a value from some other heterogenous tuple.
-     * This move assignment operator assigns a value to this tuple by
-     * moving values from a compatible, heterogenous tuple.
-     * @tparam _HeadU First element type in other tuple.
-     * @tparam _TailU Remaining element types in other tuple.
-     * @param __tuple A compatible, heterogenous tuple value.
-     * @return Lvalue reference to this tuple.
-     */
     template <class _HeadU, class... _TailU>
     tuple& operator= (tuple<_HeadU, _TailU...>&& __tuple) {
         _Base::operator= (std::forward<_Base> (__tuple._C_tail ()));
@@ -278,14 +172,6 @@
 };
 
 
-/**
- * @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 >
 {

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=671306&r1=671305&r2=671306&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 24 12:11:52 2008
@@ -38,9 +38,6 @@
 #    include <rw/_meta_help.h>  // for __rw_true_type
 
 
-/// @ingroup tuple
-/// @{
-
 _RWSTD_NAMESPACE (std) {
 
 
@@ -49,14 +46,6 @@
 template <class _Type, class _Alloc>
 struct uses_allocator;
 
-/**
- * Allows tuple construction with an allocator.  This trait informs
- * other library components that tuple can be constructed with an
- * allocator even though it does not have a nested allocator_type.
- *
- * @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>
     : _RW::__rw_true_type
@@ -68,13 +57,6 @@
 template <class _Type>
 struct constructible_with_allocator_prefix;
 
-/**
- * Allows tuple construction with an allocator prefix argument.  This
- * trait informs other library components that tuple can be constructed
- * with an allocator prefix argument.
- *
- * @tparam _Types List of element types in tuple.
- */
 template <class... _Types> 
 struct constructible_with_allocator_prefix<tuple<_Types...> > 
     : _RW::__rw_true_type
@@ -83,8 +65,6 @@
 }; 
 
 
-/// @}
-
 }   // namespace std
 
 

Modified: stdcxx/branches/4.3.x/include/tuple
URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/include/tuple?rev=671306&r1=671305&r2=671306&view=diff
==============================================================================
--- stdcxx/branches/4.3.x/include/tuple (original)
+++ stdcxx/branches/4.3.x/include/tuple Tue Jun 24 12:11:52 2008
@@ -66,12 +66,6 @@
     typedef _Type& type;
 };
 
-/**
- * @internal
- * Transform a tuple element type into a suitable make_tuple() return
- * type.
- * @tparam _Type A tuple element type.
- */
 template <class _Type>
 class __rw_make_tuple
 {
@@ -93,17 +87,6 @@
 
 #    if !defined _RWSTD_NO_RVALUE_REFERENCES
 
-/**
- * @function make_tuple
- *
- * Create a new tuple from a list of element values.  This function
- * constructs a new tuple from the corresponding element values by
- * utilizing move semantics.
- *
- * @tparam _Types The list of elements types in the tuple.
- * @param __values A corresponding list of element values.
- * @return A tuple object containing the given element values.
- */
 template <class... _Types>
 tuple<_TYPENAME _RW::__rw_make_tuple<_Types>::type...>
 make_tuple (_Types&&... __values)
@@ -140,16 +123,6 @@
 
 // 20.3.1.4, tuple helper classes:
 
-/**
- * @class tuple_size
- *
- * 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;
 
@@ -162,26 +135,12 @@
 };
 
 
-/**
- * @class tuple_element
- *
- * Determine the Nth element type of a tuple.  Instances of this class
- * class template provide a type member that identifies the Nth element
- * type of a tuple \c T where 0 <= N <
- * <code>tuple_size&lt;T&gt;::value</code>.  If N is not in this range
- * or for any other arbitrary type, the program is ill-formed.
- *
- * @tparam Index An integer constant indicating the Nth element type.
- * @tparam Types List of element types in the tuple.
- */
-
 template <int Index, class... Types>
 struct tuple_element;
 
 template <class _Head, class... _Tail>
 struct tuple_element<0, tuple<_Head, _Tail...> >
 {
-    /** The Nth element type of the tuple. */
     typedef _Head type;
 
 
@@ -216,20 +175,6 @@
 
 // 20.3.1.5, element access:
 
-/**
- * @function get
- *
- * Access Nth element value of a tuple.  This function returns a
- * cv-qualified value reference to the Nth element in a tuple \c T
- * where 0 <= N < <code>tuple_size&lt;T&gt;::value</code>.  If
N is
- * not in this range, the program is ill-formed.
- *
- * @tparam Index An integer constant indicating the Nth element type.
- * @tparam Types List of element types in the tuple.
- * @param tuple A tuple value.
- * @return CV-qualified reference to the Nth element value of tuple.
- */
-
 template <int _Index, class _Head, class... _Tail>
 _TYPENAME tuple_element<_Index, tuple<_Head, _Tail...> >::_Ref
 get (tuple<_Head, _Tail...>& __tuple)
@@ -257,11 +202,6 @@
 bool operator< (const tuple<_TypesT...>& __x,
                 const tuple<_TypesU...>& __y);
 
-/**
- * @param __x Tuple value on LHS of operator.
- * @param __y Tuple value on RHS of operator.
- * @return !(__x == __y)
- */
 template <class... _TypesT, class... _TypesU>
 bool operator!= (const tuple<_TypesT...>& __x,
                  const tuple<_TypesU...>& __y)
@@ -269,11 +209,6 @@
     return !(__x == __y);
 }
 
-/**
- * @param __x Tuple value on LHS of operator.
- * @param __y Tuple value on RHS of operator.
- * @return __y < __x
- */
 template <class... _TypesT, class... _TypesU>
 bool operator> (const tuple<_TypesT...>& __x,
                 const tuple<_TypesU...>& __y)
@@ -281,12 +216,6 @@
     return __y < __x;
 }
 
-
-/**
- * @param __x Tuple value on LHS of operator.
- * @param __y Tuple value on RHS of operator.
- * @return !(__y < __x)
- */
 template <class... _TypesT, class... _TypesU>
 bool operator<= (const tuple<_TypesT...>& __x,
                  const tuple<_TypesU...>& __y)
@@ -294,11 +223,6 @@
     return !(__y < __x);
 }
 
-/**
- * @param __x Tuple value on LHS of operator.
- * @param __y Tuple value on RHS of operator.
- * @return !(__x < __y)
- */
 template <class... _TypesT, class... _TypesU>
 bool operator>= (const tuple<_TypesT...>& __x,
                  const tuple<_TypesU...>& __y)



Mime
View raw message