[libsigc++2] Documentation changes
- From: David King <davidk src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libsigc++2] Documentation changes
- Date: Tue, 12 Oct 2010 14:05:13 +0000 (UTC)
commit d19ddcc5f6584c83c81943c223515e567c8b03d9
Author: David King <davidk openismus com>
Date: Tue Oct 12 15:50:43 2010 +0200
Documentation changes
* *.h.m4: Minor changes to documentation to fix up code example
formatting, by removing the additional two spaces of indentation.
Additionally, fix some spelling and grammar mistakes and typos.
ChangeLog | 8 +++
sigc++/adaptors/lambda/macros/base.h.m4 | 52 +++++++++---------
sigc++/adaptors/lambda/macros/group.h.m4 | 70 ++++++++++++------------
sigc++/adaptors/macros/adaptor_trait.h.m4 | 44 +++++++-------
sigc++/adaptors/macros/bind.h.m4 | 74 ++++++++++++------------
sigc++/adaptors/macros/compose.h.m4 | 30 +++++-----
sigc++/adaptors/macros/exception_catch.h.m4 | 38 ++++++------
sigc++/adaptors/macros/hide.h.m4 | 54 +++++++++---------
sigc++/adaptors/macros/retype.h.m4 | 32 +++++-----
sigc++/adaptors/macros/retype_return.h.m4 | 8 +-
sigc++/functors/macros/functor_trait.h.m4 | 4 +-
sigc++/functors/macros/mem_fun.h.m4 | 60 ++++++++++----------
sigc++/functors/macros/ptr_fun.h.m4 | 36 ++++++------
sigc++/functors/macros/slot.h.m4 | 22 ++++----
sigc++/macros/signal.h.m4 | 80 ++++++++++++++-------------
15 files changed, 311 insertions(+), 301 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index c731115..76a7baf 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2010-10-12 David King <davidk openismus com>
+
+ Documentation changes
+
+ * *.h.m4: Minor changes to documentation to fix up code example
+ formatting, by removing the additional two spaces of indentation.
+ Additionally, fix some spelling and grammar mistakes and typos.
+
2010-09-27 Armin Burgmeier <armin arbur net>
* MSVC_Net2005/libsigc++2.sln:
diff --git a/sigc++/adaptors/lambda/macros/base.h.m4 b/sigc++/adaptors/lambda/macros/base.h.m4
index cde9b98..7a558dd 100644
--- a/sigc++/adaptors/lambda/macros/base.h.m4
+++ b/sigc++/adaptors/lambda/macros/base.h.m4
@@ -57,26 +57,26 @@ divert(0)dnl
namespace sigc {
/** @defgroup lambdas Lambdas
- * libsigc++ ships with basic lambda functionality and the sigc::group adaptor that uses lambdas to transform a functor's parameter list.
+ * libsigc++ ships with basic lambda functionality and the sigc::group adaptor, which uses lambdas to transform a functor's parameter list.
*
* The lambda selectors sigc::_1, sigc::_2, ..., sigc::_9 are used to select the
* first, second, ..., nineth argument from a list.
*
* @par Examples:
- * @code
- * std::cout << sigc::_1(10,20,30); // returns 10
- * std::cout << sigc::_2(10,20,30); // returns 20
- * ...
- * @endcode
+ * @code
+ * std::cout << sigc::_1(10,20,30); // returns 10
+ * std::cout << sigc::_2(10,20,30); // returns 20
+ * ...
+ * @endcode
*
- * Operators are defined so that lambda selectors can be used e.g. as placeholders in
- * arithmetic expressions.
+ * Operators are defined so that, for example, lambda selectors can be used as
+ * placeholders in arithmetic expressions.
*
* @par Examples:
- * @code
- * std::cout << (sigc::_1 + 5)(3); // returns (3 + 5)
- * std::cout << (sigc::_1 * sigc::_2)(7,10); // returns (7 * 10)
- * @endcode
+ * @code
+ * std::cout << (sigc::_1 + 5)(3); // returns (3 + 5)
+ * std::cout << (sigc::_1 * sigc::_2)(7,10); // returns (7 * 10)
+ * @endcode
*/
/** A hint to the compiler.
@@ -257,21 +257,21 @@ dnl { return lambda<typename internal::convert_array<const T_type>::type>(v); }
* sigc::var creates a 0-ary functor, returning the value of a referenced variable.
*
* @par Example:
- * @code
- * int main(int argc, char* argv[])
- * {
- * int data;
- * sigc::signal<int> readValue;
+ * @code
+ * int main(int argc, char* argv[])
+ * {
+ * int data;
+ * sigc::signal<int> readValue;
*
- * readValue.connect(sigc::var(data));
+ * readValue.connect(sigc::var(data));
*
- * data = 3;
- * std::cout << readValue() << std::endl; //Prints 3.
+ * data = 3;
+ * std::cout << readValue() << std::endl; //Prints 3.
*
- * data = 5;
- * std::cout << readValue() << std::endl; //Prints 5.
- * }
- * @endcode
+ * data = 5;
+ * std::cout << readValue() << std::endl; //Prints 5.
+ * }
+ * @endcode
*/
template <class T_type>
lambda<T_type&> var(T_type& v)
@@ -285,7 +285,7 @@ lambda<const T_type&> var(const T_type& v)
/** Deduces the type of the object stored in an object of the passed lambda type.
- * If the type passed as template argument is no lambda type,
+ * If the type passed as template argument is not of lambda type,
* type is defined to unwrap_reference<T_type>::type.
*/
template <class T_type>
@@ -298,7 +298,7 @@ struct unwrap_lambda_type<lambda<T_type> >
/** Gets the object stored inside a lambda object.
- * Returns the object passed as argument if it is not of type lambda.
+ * Returns the object passed as argument, if it is not of type lambda.
*/
template <class T_type>
T_type& unwrap_lambda_value(T_type& a)
diff --git a/sigc++/adaptors/lambda/macros/group.h.m4 b/sigc++/adaptors/lambda/macros/group.h.m4
index fa3ab4c..115d755 100644
--- a/sigc++/adaptors/lambda/macros/group.h.m4
+++ b/sigc++/adaptors/lambda/macros/group.h.m4
@@ -109,61 +109,61 @@ __FIREWALL__
/** @defgroup group_ group()
* sigc::group() alters an arbitrary functor by rebuilding its arguments from one or more lambda expressions.
- * For each parameter that should be passed to the wrapped functor one lambda expression
+ * For each parameter that should be passed to the wrapped functor, one lambda expression
* has to be passed into group(). Lambda selectors can be used as placeholders for the
* arguments passed into the new functor. Arguments that don't have a placeholder in one
* of the lambda expressions are dropped.
*
* @par Examples:
- * @code
- * void foo(int, int);
- * int bar(int);
- * // argument binding ...
- * sigc::group(&foo,10,sigc::_1)(20); //fixes the first argument and calls foo(10,20)
- * sigc::group(&foo,sigc::_1,30)(40); //fixes the second argument and calls foo(40,30)
- * // argument reordering ...
- * sigc::group(&foo,sigc::_2,sigc::_1)(1,2); //calls foo(2,1)
- * // argument hiding ...
- * sigc::group(&foo,sigc::_1,sigc::_2)(1,2,3); //calls foo(1,2)
- * // functor composition ...
- * sigc::group(&foo,sigc::_1,sigc::group(&bar,sigc::_2))(1,2); //calls foo(1,bar(2))
- * // algebraic expressions ...
- * sigc::group(&foo,sigc::_1*sigc::_2,sigc::_1/sigc::_2)(6,3); //calls foo(6*3,6/3)
- * @endcode
+ * @code
+ * void foo(int, int);
+ * int bar(int);
+ * // argument binding ...
+ * sigc::group(&foo,10,sigc::_1)(20); //fixes the first argument and calls foo(10,20)
+ * sigc::group(&foo,sigc::_1,30)(40); //fixes the second argument and calls foo(40,30)
+ * // argument reordering ...
+ * sigc::group(&foo,sigc::_2,sigc::_1)(1,2); //calls foo(2,1)
+ * // argument hiding ...
+ * sigc::group(&foo,sigc::_1,sigc::_2)(1,2,3); //calls foo(1,2)
+ * // functor composition ...
+ * sigc::group(&foo,sigc::_1,sigc::group(&bar,sigc::_2))(1,2); //calls foo(1,bar(2))
+ * // algebraic expressions ...
+ * sigc::group(&foo,sigc::_1*sigc::_2,sigc::_1/sigc::_2)(6,3); //calls foo(6*3,6/3)
+ * @endcode
*
* The functor sigc::group() returns can be passed into
* sigc::signal::connect() directly.
*
* @par Example:
- * @code
- * sigc::signal<void,int,int> some_signal;
- * void foo(int);
- * some_signal.connect(sigc::group(&foo,sigc::_2));
- * @endcode
+ * @code
+ * sigc::signal<void,int,int> some_signal;
+ * void foo(int);
+ * some_signal.connect(sigc::group(&foo,sigc::_2));
+ * @endcode
*
- * Like in sigc::bind() you can bind references to functors by passing the objects
+ * Like in sigc::bind(), you can bind references to functors by passing the objects
* through the sigc::ref() helper function.
*
* @par Example:
- * @code
- * int some_int;
- * sigc::signal<void> some_signal;
- * void foo(int&);
- * some_signal.connect(sigc::group(&foo,sigc::ref(some_int)));
- * @endcode
+ * @code
+ * int some_int;
+ * sigc::signal<void> some_signal;
+ * void foo(int&);
+ * some_signal.connect(sigc::group(&foo,sigc::ref(some_int)));
+ * @endcode
*
* If you bind an object of a sigc::trackable derived type to a functor
* by reference, a slot assigned to the group adaptor is cleared automatically
* when the object goes out of scope.
*
* @par Example:
- * @code
- * struct bar : public sigc::trackable {} some_bar;
- * sigc::signal<void> some_signal;
- * void foo(bar&);
- * some_signal.connect(sigc::group(&foo,sigc::ref(some_bar)));
- * // disconnected automatically if some_bar goes out of scope
- * @endcode
+ * @code
+ * struct bar : public sigc::trackable {} some_bar;
+ * sigc::signal<void> some_signal;
+ * void foo(bar&);
+ * some_signal.connect(sigc::group(&foo,sigc::ref(some_bar)));
+ * // disconnected automatically if some_bar goes out of scope
+ * @endcode
*
* @ingroup adaptors, lambdas
*/
diff --git a/sigc++/adaptors/macros/adaptor_trait.h.m4 b/sigc++/adaptors/macros/adaptor_trait.h.m4
index 4c73de3..2d1fa06 100644
--- a/sigc++/adaptors/macros/adaptor_trait.h.m4
+++ b/sigc++/adaptors/macros/adaptor_trait.h.m4
@@ -113,7 +113,7 @@ template <class T_functor> struct adapts;
* All adaptor tyes in libsigc++ are unnumbered and have
* a <tt>template operator()</tt> member of every argument count
* they support. These functions in turn invoke a stored adaptor's
- * <tt>template operator()</tt> processing the arguments and return
+ * <tt>template operator()</tt>, processing the arguments and return
* value in a characteristic manner. Explicit function template
* instantiation is used to pass type hints thus saving copy costs.
*
@@ -239,32 +239,32 @@ struct adaptor_trait<T_functor, false>
* inherits from sigc::adaptor_base.
*
* @par Example of a simple adaptor:
- * @code
- * template <T_functor>
- * struct my_adpator : public sigc::adapts<T_functor>
- * {
- * template <class T_arg1=void, class T_arg2=void>
- * struct deduce_result_type
- * { typedef typename sigc::deduce_result_type<T_functor, T_arg1, T_arg2>::type type; };
- * typedef typename sigc::functor_trait<T_functor>::result_type result_type;
+ * @code
+ * template <T_functor>
+ * struct my_adpator : public sigc::adapts<T_functor>
+ * {
+ * template <class T_arg1=void, class T_arg2=void>
+ * struct deduce_result_type
+ * { typedef typename sigc::deduce_result_type<T_functor, T_arg1, T_arg2>::type type; };
+ * typedef typename sigc::functor_trait<T_functor>::result_type result_type;
*
- * result_type
- * operator()() const;
+ * result_type
+ * operator()() const;
*
- * template <class T_arg1>
- * typename deduce_result_type<T_arg1>::type
- * operator()(T_arg1 _A_arg1) const;
+ * template <class T_arg1>
+ * typename deduce_result_type<T_arg1>::type
+ * operator()(T_arg1 _A_arg1) const;
*
- * template <class T_arg1, class T_arg2>
- * typename deduce_result_type<T_arg1, T_arg2>::type
- * operator()(T_arg1 _A_arg1, class T_arg2) const;
+ * template <class T_arg1, class T_arg2>
+ * typename deduce_result_type<T_arg1, T_arg2>::type
+ * operator()(T_arg1 _A_arg1, class T_arg2) const;
*
- * explicit adaptor_functor(const T_functor& _A_functor) // Constructs a my_functor object that wraps the passed functor.
- * : sigc::adapts<T_functor>(_A_functor) {}
+ * explicit adaptor_functor(const T_functor& _A_functor) // Constructs a my_functor object that wraps the passed functor.
+ * : sigc::adapts<T_functor>(_A_functor) {}
*
- * mutable T_functor functor_; // Functor that is invoked from operator()().
- * };
- * @endcode
+ * mutable T_functor functor_; // Functor that is invoked from operator()().
+ * };
+ * @endcode
*
* @ingroup adaptors
*/
diff --git a/sigc++/adaptors/macros/bind.h.m4 b/sigc++/adaptors/macros/bind.h.m4
index c38e6fa..cd360f6 100644
--- a/sigc++/adaptors/macros/bind.h.m4
+++ b/sigc++/adaptors/macros/bind.h.m4
@@ -250,72 +250,72 @@ struct count_void<void,void,void,void,void,void,void>
/** @defgroup bind bind(), bind_return()
* sigc::bind() alters an arbitrary functor by fixing arguments to certain values.
* Up to CALL_SIZE arguments can be bound at a time.
- * For single argument binding overloads of sigc::bind() are provided that let you
+ * For single argument binding, overloads of sigc::bind() are provided that let you
* specify the zero-based position of the argument to fix with the first template parameter.
* (A value of @p -1 fixes the last argument so sigc::bind<-1>() gives the same result as sigc::bind().)
* The types of the arguments can optionally be specified if not deduced.
*
* @par Examples:
- * @code
- * void foo(int, int, int);
- * // single argument binding ...
- * sigc::bind(&foo,1)(2,3); //fixes the last (third) argument and calls foo(2,3,1)
- * sigc::bind<-1>(&foo,1)(2,3); //same as bind(&foo,1)(2,3) (calls foo(2,3,1))
- * sigc::bind<0>(&foo,1)(2,3); //fixes the first argument and calls foo(1,2,3)
- * sigc::bind<1>(&foo,1)(2,3); //fixes the second argument and calls foo(2,1,3)
- * sigc::bind<2>(&foo,1)(2,3); //fixes the third argument and calls foo(2,3,1)
- * // multi argument binding ...
- * sigc::bind(&foo,1,2)(3); //fixes the last two arguments and calls foo(3,1,2)
- * sigc::bind(&foo,1,2,3)(); //fixes all three arguments and calls foo(1,2,3)
- * @endcode
+ * @code
+ * void foo(int, int, int);
+ * // single argument binding ...
+ * sigc::bind(&foo,1)(2,3); //fixes the last (third) argument and calls foo(2,3,1)
+ * sigc::bind<-1>(&foo,1)(2,3); //same as bind(&foo,1)(2,3) (calls foo(2,3,1))
+ * sigc::bind<0>(&foo,1)(2,3); //fixes the first argument and calls foo(1,2,3)
+ * sigc::bind<1>(&foo,1)(2,3); //fixes the second argument and calls foo(2,1,3)
+ * sigc::bind<2>(&foo,1)(2,3); //fixes the third argument and calls foo(2,3,1)
+ * // multi argument binding ...
+ * sigc::bind(&foo,1,2)(3); //fixes the last two arguments and calls foo(3,1,2)
+ * sigc::bind(&foo,1,2,3)(); //fixes all three arguments and calls foo(1,2,3)
+ * @endcode
*
* The functor sigc::bind() returns can be passed into
* sigc::signal::connect() directly.
*
* @par Example:
- * @code
- * sigc::signal<void> some_signal;
- * void foo(int);
- * some_signal.connect(sigc::bind(&foo,1));
- * @endcode
+ * @code
+ * sigc::signal<void> some_signal;
+ * void foo(int);
+ * some_signal.connect(sigc::bind(&foo,1));
+ * @endcode
*
* sigc::bind_return() alters an arbitrary functor by
* fixing its return value to a certain value.
*
* @par Example:
- * @code
- * void foo();
- * std::cout << sigc::bind_return(&foo, 5)(); // calls foo() and returns 5
- * @endcode
+ * @code
+ * void foo();
+ * std::cout << sigc::bind_return(&foo, 5)(); // calls foo() and returns 5
+ * @endcode
*
* You can bind references to functors by passing the objects through
* the sigc::ref() helper function.
*
* @par Example:
- * @code
- * int some_int;
- * sigc::signal<void> some_signal;
- * void foo(int&);
- * some_signal.connect(sigc::bind(&foo,sigc::ref(some_int)));
- * @endcode
+ * @code
+ * int some_int;
+ * sigc::signal<void> some_signal;
+ * void foo(int&);
+ * some_signal.connect(sigc::bind(&foo,sigc::ref(some_int)));
+ * @endcode
*
* If you bind an object of a sigc::trackable derived type to a functor
* by reference, a slot assigned to the bind adaptor is cleared automatically
* when the object goes out of scope.
*
* @par Example:
- * @code
- * struct bar : public sigc::trackable {} some_bar;
- * sigc::signal<void> some_signal;
- * void foo(bar&);
- * some_signal.connect(sigc::bind(&foo,sigc::ref(some_bar)));
- * // disconnected automatically if some_bar goes out of scope
- * @endcode
+ * @code
+ * struct bar : public sigc::trackable {} some_bar;
+ * sigc::signal<void> some_signal;
+ * void foo(bar&);
+ * some_signal.connect(sigc::bind(&foo,sigc::ref(some_bar)));
+ * // disconnected automatically if some_bar goes out of scope
+ * @endcode
*
* For a more powerful version of this functionality see the lambda
* library adaptor sigc::group() which can bind, hide and reorder
- * arguments arbitrarily. Although sigc::group() is more flexible,
- * sigc::bind() provides a means of binding parameters when then total
+ * arguments arbitrarily. Although sigc::group() is more flexible,
+ * sigc::bind() provides a means of binding parameters when the total
* number of parameters called is variable.
*
* @ingroup adaptors
diff --git a/sigc++/adaptors/macros/compose.h.m4 b/sigc++/adaptors/macros/compose.h.m4
index 17ad895..5298801 100644
--- a/sigc++/adaptors/macros/compose.h.m4
+++ b/sigc++/adaptors/macros/compose.h.m4
@@ -47,30 +47,30 @@ namespace sigc {
/** @defgroup compose compose()
* sigc::compose() combines two or three arbitrary functors.
- * On invokation parameters are passed on to one or two getter functor(s).
+ * On invokation, parameters are passed on to one or two getter functor(s).
* The return value(s) are then passed on to the setter function.
*
* @par Examples:
- * @code
- * float square_root(float a) { return sqrtf(a); }
- * float sum(float a, float b) { return a+b; }
- * std::cout << sigc::compose(&square_root, &sum)(9, 16); // calls square_root(sum(3,6))
- * std::cout << sigc::compose(&sum, &square_root, &square_root)(9); // calls sum(square_root(9), square_root(9))
- * @endcode
+ * @code
+ * float square_root(float a) { return sqrtf(a); }
+ * float sum(float a, float b) { return a+b; }
+ * std::cout << sigc::compose(&square_root, &sum)(9, 16); // calls square_root(sum(3,6))
+ * std::cout << sigc::compose(&sum, &square_root, &square_root)(9); // calls sum(square_root(9), square_root(9))
+ * @endcode
*
- * The functor sigc::compose() returns can be passed into
- * sigc::signal::connect() directly.
+ * The functor sigc::compose() returns can be passed directly into
+ * sigc::signal::connect().
*
* @par Example:
- * @code
- * sigc::signal<float,float,float> some_signal;
- * some_signal.connect(sigc::compose(&square_root, &sum));
- * @endcode
+ * @code
+ * sigc::signal<float,float,float> some_signal;
+ * some_signal.connect(sigc::compose(&square_root, &sum));
+ * @endcode
*
* For a more powerful version of this functionality see the lambda
* library adaptor sigc::group() which can bind, hide and reorder
- * arguments arbitrarily. Although sigc::group() is more flexible,
- * sigc::bind() provides a means of binding parameters when then total
+ * arguments arbitrarily. Although sigc::group() is more flexible,
+ * sigc::bind() provides a means of binding parameters when the total
* number of parameters called is variable.
*
* @ingroup adaptors
diff --git a/sigc++/adaptors/macros/exception_catch.h.m4 b/sigc++/adaptors/macros/exception_catch.h.m4
index 028503a..47bff0a 100644
--- a/sigc++/adaptors/macros/exception_catch.h.m4
+++ b/sigc++/adaptors/macros/exception_catch.h.m4
@@ -59,33 +59,33 @@ namespace sigc {
* Note that the catcher is expected to return the same type
* as the wrapped functor so that normal flow can continue.
*
- * Catchers can be cascaded to catch multiple types because uncaught
+ * Catchers can be cascaded to catch multiple types, because uncaught
* rethrown exceptions proceed to the next catcher adaptor.
*
* @par Examples:
- * @code
- * struct my_catch
+ * @code
+ * struct my_catch
+ * {
+ * int operator()()
* {
- * int operator()()
- * {
- * try { throw; }
- * catch (std::range_error e) // catch what types we know
- * { std::cerr << "caught " << e.what() << std::endl; }
- * return 1;
- * }
+ * try { throw; }
+ * catch (std::range_error e) // catch what types we know
+ * { std::cerr << "caught " << e.what() << std::endl; }
+ * return 1;
* }
- * int foo(); // throws std::range_error
- * sigc::exception_catch(&foo, my_catch())();
- * @endcode
+ * }
+ * int foo(); // throws std::range_error
+ * sigc::exception_catch(&foo, my_catch())();
+ * @endcode
*
- * The functor sigc::execption_catch() returns can be passed into
- * sigc::signal::connect() directly.
+ * The functor sigc::exception_catch() returns can be directly passed into
+ * sigc::signal::connect().
*
* @par Example:
- * @code
- * sigc::signal<int> some_signal;
- * some_signal.connect(sigc::exception_catch(&foo, my_catch));
- * @endcode
+ * @code
+ * sigc::signal<int> some_signal;
+ * some_signal.connect(sigc::exception_catch(&foo, my_catch));
+ * @endcode
*
* @ingroup adaptors
*/
diff --git a/sigc++/adaptors/macros/hide.h.m4 b/sigc++/adaptors/macros/hide.h.m4
index 9e68fbc..030c387 100644
--- a/sigc++/adaptors/macros/hide.h.m4
+++ b/sigc++/adaptors/macros/hide.h.m4
@@ -47,7 +47,7 @@ ifelse($2,1,[dnl
#endif
],$1,0,[dnl
- /** Invokes the wrapped functor ignoring the last argument.dnl
+ /** Invokes the wrapped functor, ignoring the last argument.dnl
FOR(1, eval($2-1),[
* @param _A_arg%1 Argument to be passed on to the functor.])
* @param _A_arg$2 Argument to be ignored.
@@ -68,7 +68,7 @@ FOR(1, eval($2-1),[
#endif
],[dnl
- /** Invokes the wrapped functor ignoring the $1[]th argument.dnl
+ /** Invokes the wrapped functor, ignoring the $1[]th argument.dnl
FOR(1, eval($1-1),[
* @param _A_arg%1 Argument to be passed on to the functor.])
* @param _A_arg$1 Argument to be ignored.dnl
@@ -137,40 +137,40 @@ namespace sigc {
* The type of the parameter can optionally be specified if not deduced.
*
* @par Examples:
- * @code
- * void foo(int, int);
- * // single argument hiding ...
- * sigc::hide(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2)
- * sigc::hide<-1>(&foo)(1,2,3); // same as sigc::hide(&foo)(1,2,3) (calls foo(1,2))
- * sigc::hide<0>(&foo)(1,2,3); // adds a dummy parameter at the beginning and calls foo(2,3)
- * sigc::hide<1>(&foo)(1,2,3); // adds a dummy parameter in the middle and calls foo(1,3)
- * sigc::hide<2>(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2)
- * @endcode
- *
- * The functor sigc::hide() returns can be passed into
- * sigc::signal::connect() directly.
+ * @code
+ * void foo(int, int);
+ * // single argument hiding ...
+ * sigc::hide(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2)
+ * sigc::hide<-1>(&foo)(1,2,3); // same as sigc::hide(&foo)(1,2,3) (calls foo(1,2))
+ * sigc::hide<0>(&foo)(1,2,3); // adds a dummy parameter at the beginning and calls foo(2,3)
+ * sigc::hide<1>(&foo)(1,2,3); // adds a dummy parameter in the middle and calls foo(1,3)
+ * sigc::hide<2>(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2)
+ * @endcode
+ *
+ * The functor sigc::hide() returns can be directly passed into
+ * sigc::signal::connect().
*
* @par Example:
- * @code
- * sigc::signal<void,int> some_signal;
- * void foo();
- * some_signal.connect(sigc::hide(&foo));
- * @endcode
+ * @code
+ * sigc::signal<void,int> some_signal;
+ * void foo();
+ * some_signal.connect(sigc::hide(&foo));
+ * @endcode
*
* sigc::hide() can be nested in order to discard multiple arguments.
* @par Example:
- * @code
- * // multiple argument hiding ...
- * sigc::hide(sigc::hide(&foo))(1,2,3,4); // adds two dummy parameters at the back and calls foo(1,2)
- * @endcode
+ * @code
+ * // multiple argument hiding ...
+ * sigc::hide(sigc::hide(&foo))(1,2,3,4); // adds two dummy parameters at the back and calls foo(1,2)
+ * @endcode
* sigc::hide_return() alters an arbitrary functor by
* dropping its return value, thus converting it to a void functor.
*
* For a more powerful version of this functionality see the lambda
* library adaptor sigc::group() which can bind, hide and reorder
- * arguments arbitrarily. Although sigc::group() is more flexible,
- * sigc::hide() provides a means of hiding parameters when then total
+ * arguments arbitrarily. Although sigc::group() is more flexible,
+ * sigc::hide() provides a means of hiding parameters when the total
* number of parameters called is variable.
*
* @ingroup adaptors
@@ -211,7 +211,7 @@ void visit_each(const T_action& _A_action,
* position of the dummy parameter in the returned functor (@p -1 stands for the last parameter).
*
* @param _A_func Functor that should be wrapped.
- * @return Adaptor that executes @e _A_func ignoring the value of the dummy parameter.
+ * @return Adaptor that executes @e _A_func, ignoring the value of the dummy parameter.
*
* @ingroup hide
*/
@@ -224,7 +224,7 @@ hide(const T_functor& _A_func)
* This overload adds a dummy parameter at the back of the functor's parameter list.
*
* @param _A_func Functor that should be wrapped.
- * @return Adaptor that executes @e _A_func ignoring the value of the last parameter.
+ * @return Adaptor that executes @e _A_func, ignoring the value of the last parameter.
*
* @ingroup hide
*/
diff --git a/sigc++/adaptors/macros/retype.h.m4 b/sigc++/adaptors/macros/retype.h.m4
index d0cbb17..c7297f2 100644
--- a/sigc++/adaptors/macros/retype.h.m4
+++ b/sigc++/adaptors/macros/retype.h.m4
@@ -90,35 +90,35 @@ namespace sigc {
*
* Use this adaptor for inline conversion between numeric or other simple types.
* @par Example:
- * @code
- * void foo(int);
- * sigc::retype(sigc::ptr_fun(&foo))(5.7F); // calls foo(5)
- * @endcode
+ * @code
+ * void foo(int);
+ * sigc::retype(sigc::ptr_fun(&foo))(5.7F); // calls foo(5)
+ * @endcode
*
- * The functor sigc::retype() returns can be passed into
- * sigc::signal::connect() directly.
+ * The functor that sigc::retype() returns can be passed directly into
+ * sigc::signal::connect().
*
* @par Example:
- * @code
- * sigc::signal<void,float> some_signal;
- * void foo(int);
- * some_signal.connect(sigc::retype(sigc::ptr_fun(&foo)));
- * @endcode
+ * @code
+ * sigc::signal<void,float> some_signal;
+ * void foo(int);
+ * some_signal.connect(sigc::retype(sigc::ptr_fun(&foo)));
+ * @endcode
*
* This adaptor builds an exception in that it only works on sig::pointer_functor,
* sigc::mem_functor and sigc::slot because it needs sophisticated information about
* the parameter types that cannot be deduced from arbitrary functor types.
*
* sigc::retype_return() alters the return type of an arbitrary functor.
- * Like in sigc::retype() a C-style cast is preformed. Usage sigc::retype_return() is
+ * Like in sigc::retype() a C-style cast is performed. Usage sigc::retype_return() is
* not restricted to libsigc++ functor types but you need to
* specify the new return type as a template parameter.
*
* @par Example:
- * @code
- * float foo();
- * std::cout << sigc::retype_return<int>(&foo)(); // converts foo's return value to an integer
- * @endcode
+ * @code
+ * float foo();
+ * std::cout << sigc::retype_return<int>(&foo)(); // converts foo's return value to an integer
+ * @endcode
*
* @ingroup adaptors
*/
diff --git a/sigc++/adaptors/macros/retype_return.h.m4 b/sigc++/adaptors/macros/retype_return.h.m4
index 1536ab7..123073d 100644
--- a/sigc++/adaptors/macros/retype_return.h.m4
+++ b/sigc++/adaptors/macros/retype_return.h.m4
@@ -57,7 +57,7 @@ __FIREWALL__
namespace sigc {
-/** Adaptor that perform a C-style cast on the return value of a functor.
+/** Adaptor that performs a C-style cast on the return value of a functor.
* Use the convenience function sigc::retype_return() to create an instance of retype_return_functor.
*
* The following template arguments are used:
@@ -92,13 +92,13 @@ T_return retype_return_functor<T_return, T_functor>::operator()()
{ return T_return(this->functor_()); }
-/** Adaptor that perform a C-style cast on the return value of a functor.
+/** Adaptor that performs a C-style cast on the return value of a functor.
* This template specialization is for a void return. It drops the return value of the functor it invokes.
* Use the convenience function sigc::hide_return() to create an instance of sigc::retype_return_functor<void>.
*
* @ingroup retype
*/
-/* The void specialization needed because of explicit cast to T_return.
+/* The void specialization is needed because of explicit cast to T_return.
*/
template <class T_functor>
struct retype_return_functor<void, T_functor> : public adapts<T_functor>
@@ -141,7 +141,7 @@ void visit_each(const T_action& _A_action,
* The template argument @e T_return specifies the target type of the cast.
*
* @param _A_functor Functor that should be wrapped.
- * @return Adaptor that executes @e _A_functor performing a C-style casts on the return value.
+ * @return Adaptor that executes @e _A_functor performing a C-style cast on the return value.
*
* @ingroup retype
*/
diff --git a/sigc++/functors/macros/functor_trait.h.m4 b/sigc++/functors/macros/functor_trait.h.m4
index f7e56bd..f5997da 100644
--- a/sigc++/functors/macros/functor_trait.h.m4
+++ b/sigc++/functors/macros/functor_trait.h.m4
@@ -91,7 +91,7 @@ struct nil;
* Functors are copyable types that define operator()().
*
* Types that define operator()() overloads with different return types are referred to
- * as multi-type functors. Multi-type functors are only partly supported in libsigc++.
+ * as multi-type functors. Multi-type functors are only partially supported in libsigc++.
*
* Closures are functors that store all information needed to invoke a callback from operator()().
*
@@ -103,7 +103,7 @@ struct nil;
*
* The basic functor types libsigc++ provides are created with ptr_fun() and mem_fun()
* and can be converted into slots implicitly.
- * The set of adaptors that ships with libsigc++ is documented in the equally named module.
+ * The set of adaptors that ships with libsigc++ is documented in the @ref adaptors module.
*/
/** A hint to the compiler.
diff --git a/sigc++/functors/macros/mem_fun.h.m4 b/sigc++/functors/macros/mem_fun.h.m4
index 2e90425..535dfd1 100644
--- a/sigc++/functors/macros/mem_fun.h.m4
+++ b/sigc++/functors/macros/mem_fun.h.m4
@@ -193,49 +193,49 @@ namespace sigc {
/** @defgroup mem_fun mem_fun()
* mem_fun() is used to convert a pointer to a method to a functor.
*
- * Optionally a reference or pointer to an object can be bound to the functor.
- * Note that only if the object type inherits from sigc::trackable
- * the slot is cleared automatically when the object goes out of scope!
+ * Optionally, a reference or pointer to an object can be bound to the functor.
+ * Note that only if the object type inherits from sigc::trackable is
+ * the slot automatically cleared when the object goes out of scope!
*
* If the member function pointer is to an overloaded type, you must specify
* the types using template arguments starting with the first argument.
* It is not necessary to supply the return type.
*
* @par Example:
- * @code
- * struct foo : public sigc::trackable
- * {
- * void bar(int) {}
- * };
- * foo my_foo;
- * sigc::slot<void, int> sl = sigc::mem_fun(my_foo, &foo::bar);
- * @endcode
+ * @code
+ * struct foo : public sigc::trackable
+ * {
+ * void bar(int) {}
+ * };
+ * foo my_foo;
+ * sigc::slot<void, int> sl = sigc::mem_fun(my_foo, &foo::bar);
+ * @endcode
*
* For const methods mem_fun() takes a const reference or pointer to an object.
*
* @par Example:
- * @code
- * struct foo : public sigc::trackable
- * {
- * void bar(int) const {}
- * };
- * const foo my_foo;
- * sigc::slot<void, int> sl = sigc::mem_fun(my_foo, &foo::bar);
- * @endcode
+ * @code
+ * struct foo : public sigc::trackable
+ * {
+ * void bar(int) const {}
+ * };
+ * const foo my_foo;
+ * sigc::slot<void, int> sl = sigc::mem_fun(my_foo, &foo::bar);
+ * @endcode
*
- * Use mem_fun#() if there is an abiguity as to the number of arguments.
+ * Use mem_fun#() if there is an ambiguity as to the number of arguments.
*
* @par Example:
- * @code
- * struct foo : public sigc::trackable
- * {
- * void bar(int) {}
- * void bar(float) {}
- * void bar(int, int) {}
- * };
- * foo my_foo;
- * sigc::slot<void, int> sl = sigc::mem_fun1<int>(my_foo, &foo::bar);
- * @endcode
+ * @code
+ * struct foo : public sigc::trackable
+ * {
+ * void bar(int) {}
+ * void bar(float) {}
+ * void bar(int, int) {}
+ * };
+ * foo my_foo;
+ * sigc::slot<void, int> sl = sigc::mem_fun1<int>(my_foo, &foo::bar);
+ * @endcode
*
* @ingroup sigcfunctors
*/
diff --git a/sigc++/functors/macros/ptr_fun.h.m4 b/sigc++/functors/macros/ptr_fun.h.m4
index a9499d2..0dbd4bc 100644
--- a/sigc++/functors/macros/ptr_fun.h.m4
+++ b/sigc++/functors/macros/ptr_fun.h.m4
@@ -85,32 +85,32 @@ namespace sigc {
* It is not necessary to supply the return type.
*
* @par Example:
- * @code
- * void foo(int) {}
- * sigc::slot<void, int> sl = sigc::ptr_fun(&foo);
- * @endcode
+ * @code
+ * void foo(int) {}
+ * sigc::slot<void, int> sl = sigc::ptr_fun(&foo);
+ * @endcode
*
- * Use ptr_fun#() if there is an abiguity as to the number of arguments.
+ * Use ptr_fun#() if there is an ambiguity as to the number of arguments.
*
* @par Example:
- * @code
- * void foo(int) {} // choose this one
- * void foo(float) {}
- * void foo(int, int) {}
- * sigc::slot<void, long> sl = sigc::ptr_fun1<int>(&foo);
- * @endcode
+ * @code
+ * void foo(int) {} // choose this one
+ * void foo(float) {}
+ * void foo(int, int) {}
+ * sigc::slot<void, long> sl = sigc::ptr_fun1<int>(&foo);
+ * @endcode
*
* ptr_fun() can also be used to convert a pointer to a static member
* function to a functor, like so:
*
* @par Example:
- * @code
- * struct foo
- * {
- * static void bar(int) {}
- * };
- * sigc::slot<void, int> sl = sigc::ptr_fun(&foo::bar);
- * @endcode
+ * @code
+ * struct foo
+ * {
+ * static void bar(int) {}
+ * };
+ * sigc::slot<void, int> sl = sigc::ptr_fun(&foo::bar);
+ * @endcode
*
* @ingroup sigcfunctors
*/
diff --git a/sigc++/functors/macros/slot.h.m4 b/sigc++/functors/macros/slot.h.m4
index f02041c..f5a45c0 100644
--- a/sigc++/functors/macros/slot.h.m4
+++ b/sigc++/functors/macros/slot.h.m4
@@ -75,7 +75,7 @@ FOR(1, $1,[
inline slot$1() {}
/** Constructs a slot from an arbitrary functor.
- * @param _A_func The desirer functor the new slot should be assigned to.
+ * @param _A_func The desired functor the new slot should be assigned to.
*/
template <class T_functor>
slot$1(const T_functor& _A_func)
@@ -109,19 +109,19 @@ ifelse($1, $2,[dnl
FOR(1,$1,[
* - @e T_arg%1 Argument type used in the definition of operator()(). The default @p nil means no argument.])
*
- * To use simply assign the slot to the desired functor. If the functor
+ * To use, simply assign the slot to the desired functor. If the functor
* is not compatible with the parameter list defined with the template
- * arguments compiler errors are triggered. When called the slot
+ * arguments, compiler errors are triggered. When called, the slot
* will invoke the functor with minimal copies.
- * block() and unblock() can be used to block the functor's invocation
- * from operator()() temporarily.
+ * block() and unblock() can be used to temporarily block the functor's
+ * invocation from operator()().
*
* @par Example:
- * @code
- * void foo(int) {}
- * sigc::slot<void, long> s = sigc::ptr_fun(&foo);
- * s(19);
- * @endcode
+ * @code
+ * void foo(int) {}
+ * sigc::slot<void, long> s = sigc::ptr_fun(&foo);
+ * s(19);
+ * @endcode
*
* @ingroup slot
*/
@@ -145,7 +145,7 @@ public:
inline slot() {}
/** Constructs a slot from an arbitrary functor.
- * @param _A_func The desirer functor the new slot should be assigned to.
+ * @param _A_func The desired functor the new slot should be assigned to.
*/
template <class T_functor>
slot(const T_functor& _A_func)
diff --git a/sigc++/macros/signal.h.m4 b/sigc++/macros/signal.h.m4
index 6c72b29..283c165 100644
--- a/sigc++/macros/signal.h.m4
+++ b/sigc++/macros/signal.h.m4
@@ -22,7 +22,7 @@ define([SIGNAL_EMIT_N],[dnl
/** Abstracts signal emission.
* This template implements the emit() function of signal$1.
* Template specializations are available to optimize signal
- * emission when no accumulator is used, i.e. the template
+ * emission when no accumulator is used, for example when the template
* argument @e T_accumulator is @p nil.
*/
template <LIST(class T_return, LOOP(class T_arg%1, $1), class T_accumulator)>
@@ -277,7 +277,7 @@ define([SIGNAL_N],[dnl
* signal$1 can be used to connect() slots that are invoked
* during subsequent calls to emit(). Any functor or slot
* can be passed into connect(). It is converted into a slot
- * implicitely.
+ * implicitly.
*
* If you want to connect one signal to another, use make_slot()
* to retrieve a functor that emits the signal when invoked.
@@ -285,7 +285,7 @@ define([SIGNAL_N],[dnl
* Be careful if you directly pass one signal into the connect()
* method of another: a shallow copy of the signal is made and
* the signal's slots are not disconnected until both the signal
- * and its clone are destroyed which is probably not what you want!
+ * and its clone are destroyed, which is probably not what you want!
*
* An STL-style list interface for the signal's list of slots
* can be retrieved with slots(). This interface supports
@@ -295,7 +295,9 @@ define([SIGNAL_N],[dnl
* - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).dnl
FOR(1,$1,[
* - @e T_arg%1 Argument type used in the definition of emit().])
- * - @e T_accumulator The accumulator type used for emission. The default @p nil means that no accumulator should be used, i.e. signal emission returns the return value of the last slot invoked.
+ * - @e T_accumulator The accumulator type used for emission. The default
+ * @p nil means that no accumulator should be used, for example if signal
+ * emission returns the return value of the last slot invoked.
*
* You should use the more convenient unnumbered sigc::signal template.
*
@@ -396,7 +398,7 @@ ifelse($1, $2,[dnl
* Be careful if you directly pass one signal into the connect()
* method of another: a shallow copy of the signal is made and
* the signal's slots are not disconnected until both the signal
- * and its clone are destroyed which is probably not what you want!
+ * and its clone are destroyed, which is probably not what you want!
*
* An STL-style list interface for the signal's list of slots
* can be retrieved with slots(). This interface supports
@@ -411,12 +413,12 @@ FOR(1,$1,[
* To specify an accumulator type the nested class signal::accumulated can be used.
*
* @par Example:
- * @code
- * void foo(int) {}
- * sigc::signal<void, long> sig;
- * sig.connect(sigc::ptr_fun(&foo));
- * sig.emit(19);
- * @endcode
+ * @code
+ * void foo(int) {}
+ * sigc::signal<void, long> sig;
+ * sig.connect(sigc::ptr_fun(&foo));
+ * sig.emit(19);
+ * @endcode
*
* @ingroup signal
*/
@@ -449,38 +451,38 @@ ifelse($1, $2,[dnl
* The accumulator must define its return value as @p result_type.
*
* @par Example 1:
- * This accumulator calculates the arithmetic mean value:
- * @code
- * struct arithmetic_mean_accumulator
+ * This accumulator calculates the arithmetic mean value:
+ * @code
+ * struct arithmetic_mean_accumulator
+ * {
+ * typedef double result_type;
+ * template<typename T_iterator>
+ * result_type operator()(T_iterator first, T_iterator last) const
* {
- * typedef double result_type;
- * template<typename T_iterator>
- * result_type operator()(T_iterator first, T_iterator last) const
- * {
- * result_type value_ = 0;
- * int n_ = 0;
- * for (; first != last; ++first, ++n_)
- * value_ += *first;
- * return value_ / n_;
- * }
- * };
- * @endcode
+ * result_type value_ = 0;
+ * int n_ = 0;
+ * for (; first != last; ++first, ++n_)
+ * value_ += *first;
+ * return value_ / n_;
+ * }
+ * };
+ * @endcode
*
* @par Example 2:
- * This accumulator stops signal emission when a slot returns zero:
- * @code
- * struct interruptable_accumulator
+ * This accumulator stops signal emission when a slot returns zero:
+ * @code
+ * struct interruptable_accumulator
+ * {
+ * typedef bool result_type;
+ * template<typename T_iterator>
+ * result_type operator()(T_iterator first, T_iterator last) const
* {
- * typedef bool result_type;
- * template<typename T_iterator>
- * result_type operator()(T_iterator first, T_iterator last) const
- * {
- * for (; first != last; ++first, ++n_)
- * if (!*first) return false;
- * return true;
- * }
- * };
- * @endcode
+ * for (; first != last; ++first, ++n_)
+ * if (!*first) return false;
+ * return true;
+ * }
+ * };
+ * @endcode
*
* @ingroup signal
],[
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
