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 <[EMAIL PROTECTED]>
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 preï¬x 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<T>::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<T>::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)
