libsigc++: sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator > Class Template Reference

libsigc++ 2.2.10

- Main Page
- Modules
- Namespaces
- Classes

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions

# sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator > Class Template Reference
Signals

Convenience wrapper for the numbered sigc::signal# templates. More...

`#include <sigc++/signal.h>`

Inheritance diagram for sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator >:
[legend]

List of all members.

## Public Member Functions
| accumulated (const accumulated& src)

## Detailed Description

### template<class T_return, class T_arg1 = nil, class T_arg2 = nil, class T_arg3 = nil, class T_arg4 = nil, class T_arg5 = nil, class T_arg6 = nil, class T_arg7 = nil>
template <class T_accumulator>
class sigc::signal< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 >::accumulated< T_accumulator >

Convenience wrapper for the numbered sigc::signal# templates.

Like sigc::signal but the additional template parameter T_accumulator defines the accumulator type that should be used.

An accumulator is a functor that uses a pair of special iterators to step through a list of slots and calculate a return value from the results of the slot invokations. The iterators' operator*() executes the slot. The return value is buffered, so that in an expression like

     a = (*i) * (*i);

the slot is executed only once. The accumulator must define its return value as `result_type`.

Example 1:
  This accumulator calculates the arithmetic mean value:

       struct arithmetic_mean_accumulator
       {
         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_;
         }
       };

Example 2:
  This accumulator stops signal emission when a slot returns zero:

       struct interruptable_accumulator
       {
         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;
         }
       };