libsigc++: sigc Namespace Reference

libsigc++ 3.8.1

Classes | Typedefs | Functions
sigc Namespace Reference

The libsigc++ namespace. More...

## Classes
struct | adaptor_base
| A hint to the compiler. More...
struct | adaptor_functor
| Converts an arbitrary functor into an adaptor type. More...
struct | adaptor_trait
| Trait that specifies what is the adaptor version of a functor type. More...
struct | adaptor_trait< T_functor, false >
| Trait that specifies the adaptor version of a functor type. More...
struct | adaptor_trait< T_functor, true >
| Trait that specifies the adaptor version of a functor type. More...
struct | adapts
| Base type for adaptors. More...
struct | bind_functor
| Adaptor that binds arguments to the wrapped functor. More...
struct | bind_functor<-1, T_functor, T_type... >
| Adaptor that binds argument(s) to the wrapped functor. More...
struct | bind_return_functor
| Adaptor that fixes the return value of the wrapped functor. More...
class | bound_argument
| A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return()) argument. More...
class | bound_argument< std::reference_wrapper< const T_wrapped > >
| bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by const reference, specialized for const reference_wrapper<> types. More...
class | bound_argument< std::reference_wrapper< T_wrapped > >
| bound_argument object for a bound argument that is passed by bind() or returned by bind_return() by reference, specialized for std::reference_wrapper<> types. More...
class | bound_mem_functor
struct | compose1_functor
| Adaptor that combines two functors. More...
struct | compose2_functor
| Adaptor that combines three functors. More...
struct | connection
| Convenience class for safe disconnection. More...
struct | exception_catch_functor
struct | functor_trait
| Trait that specifies the appropriate functor type of any callable type. More...
struct | hide_functor
| Adaptor that adds a dummy parameter to the wrapped functor. More...
class | limit_reference
| A limit_reference<Foo> object stores a reference (Foo&), but makes sure that, if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the sigc::trackable reference instead of the derived reference. More...
class | limit_reference< T_type, true >
| limit_reference object for a class that derives from trackable. More...
class | mem_functor
struct | notifiable
class | pointer_functor
| pointer_functor wraps existing non-member functions with, or without, arguments. More...
class | pointer_functor< T_return(T_args...)>
struct | retype_functor
| Adaptor that performs C-style casts on the parameters passed on to the functor. More...
struct | retype_return_functor
| Adaptor that performs a C-style cast on the return value of a functor. More...
struct | retype_return_functor< void, T_functor >
| Adaptor that performs a C-style cast on the return value of a functor. More...
struct | scoped_connection
| Convenience class for safe disconnection, including automatic disconnection upon destruction. More...
class | signal< T_return(T_arg...)>
| signal can be used to connect() slots that are invoked during subsequent calls to emit(). More...
struct | signal_base
| Base class for the sigc::signal template. More...
class | signal_with_accumulator
| Signal declaration. More...
class | slot< T_return(T_arg...)>
| Converts an arbitrary functor to a unified type which is opaque. More...
class | slot_base
| Base type for slots. More...
class | track_obj_functor
| track_obj_functor wraps a functor and stores a reference to a trackable object. More...
struct | trackable
| Base class for objects with auto-disconnection. More...
class | trackable_signal< T_return(T_arg...)>
| trackable_signal can be used to connect() slots that are invoked during subsequent calls to emit(). More...
class | trackable_signal_with_accumulator
| Signal declaration. More...
struct | type_trait
struct | type_trait< const T_type & >
struct | type_trait< T_type & >
struct | type_trait< T_type && >
struct | type_trait< T_type[N]>
struct | type_trait< void >
struct | unwrap_reference
struct | unwrap_reference< std::reference_wrapper< const T_type > >
struct | unwrap_reference< std::reference_wrapper< T_type > >
struct | visitor
| sigc::visitor<T_functor>::do_visit_each() performs a functor on each of the targets of a functor. More...

## Typedefs
template<typename T>
using | type_trait_pass_t = typename type_trait<T>::pass
template<typename T>
using | type_trait_take_t = typename type_trait<T>::take

## Functions
template<int I_location, typename T_functor, typename... T_bound>
decltype(auto) | bind (const T_functor & func, T_bound... b)
| Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.
template<typename T_functor, typename... T_type>
decltype(auto) | bind (const T_functor & func, T_type... b)
| Creates an adaptor of type sigc::bind_functor which fixes the last arguments of the passed functor.
template <typename T_return, typename T_functor>
bind_return_functor< T_return, T_functor > | bind_return (const T_functor & functor, T_return ret_value)
| Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed functor to the passed argument.
template<typename T_setter, typename T_getter>
compose1_functor< T_setter, T_getter > | compose (const T_setter & setter, const T_getter & getter)
| Creates an adaptor of type sigc::compose1_functor which combines two functors.
template<typename T_setter, typename T_getter1, typename T_getter2>
compose2_functor< T_setter, T_getter1, T_getter2 > | compose (const T_setter & setter, const T_getter1 & getter1, const T_getter2 & getter2)
| Creates an adaptor of type sigc::compose2_functor which combines three functors.
template<typename T_functor, typename T_catcher>
decltype(auto) | exception_catch (const T_functor & func, const T_catcher & catcher)
template<typename T_functor>
decltype(auto) | hide (const T_functor & func)
| Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.
template<int I_location, typename T_functor>
decltype(auto) | hide (const T_functor & func)
| Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.
template<typename T_functor>
retype_return_functor< void, T_functor > | hide_return (const T_functor & functor)
| Creates an adaptor of type sigc::retype_return_functor which drops the return value of the passed functor.
template <typename T_return, typename T_obj, typename T_obj2, typename... T_arg>
decltype(auto) | mem_fun (T_obj & obj, T_return(T_obj2::* func)(T_arg...))
| Creates a functor of type sigc::bound_mem_functor which encapsulates a method and an object instance.
template <typename T_return, typename T_obj, typename... T_arg>
decltype(auto) | mem_fun (T_return(T_obj::* func)(T_arg...))
| Creates a functor of type sigc::mem_functor which wraps a method.
template <typename T_return, typename... T_args>
decltype(auto) | ptr_fun (T_return(* func)(T_args...))
| Creates a functor of type sigc::pointer_functor which wraps an existing non-member function.
template<template< typename T_func, typename... T_arg > class T_functor, typename T_func, typename... T_arg>
decltype(auto) | retype (const T_functor< T_func, T_arg... > & functor)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
template <template< typename T_return, typename... T_arg > class T_functor, typename T_return, typename... T_arg>
decltype(auto) | retype (const T_functor< T_return(T_arg...)> & functor)
| Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
template <typename T_return, typename T_functor>
retype_return_functor< T_return, T_functor > | retype_return (const T_functor & functor)
| Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return value of the passed functor.
template <typename T_return, typename T_obj, typename... T_arg>
connection | signal_connect (signal< T_return(T_arg...)> & signal, const T_obj & obj, T_return(T_obj::* fun)(T_arg...) const)
| Connect a const method to a signal.
template <typename T_return, typename T_obj, typename... T_arg>
connection | signal_connect (signal< T_return(T_arg...)> & signal, T_obj & obj, T_return(T_obj::* fun)(T_arg...))
| Connect a non-const method to a signal.
template <typename T_return, typename... T_arg>
connection | signal_connect (signal< T_return(T_arg...)> & signal, T_return(* fun)(T_arg...))
| Connect a function to a signal.
void | swap (scoped_connection & sca, scoped_connection & scb)
| Swap two scoped connections.
template<typename T_functor, typename... T_obj>
decltype(auto) | track_obj (const T_functor & func, const T_obj &... obj)
| Creates an adaptor of type sigc::track_obj_functor which wraps a functor.
template<typename T_functor, typename T_obj1, typename... T_objs>
decltype(auto) | track_object (const T_functor & func, const T_obj1 & obj1, const T_objs &... objs)
| Creates an adaptor of type sigc::track_obj_functor which wraps a functor.
template<typename T_type>
const T_type & | unwrap (const std::reference_wrapper< const T_type > & v)
template<typename T_type>
T_type & | unwrap (const std::reference_wrapper< T_type > & v)
template<typename T_action, typename T_functor>
void | visit_each (const T_action & action, const T_functor & functor)
| This function performs a functor on each of the targets of a functor.
template<typename T_action, typename T_functor>
void | visit_each_trackable (const T_action & action, const T_functor & functor)
| This function performs a functor on each of the targets of a functor limited to a restricted type.

## Detailed Description

The libsigc++ namespace.

## Typedef Documentation

## ◆ type_trait_pass_t

template <typename T>

using sigc::type_trait_pass_t = typename type_trait<T>::pass

## ◆ type_trait_take_t

template <typename T>

using sigc::type_trait_take_t = typename type_trait<T>::take

## Function Documentation

## ◆ exception_catch()

template <typename T_functor, typename T_catcher>

decltype(auto) sigc::exception_catch | ( | const T_functor & | func,
|  | const T_catcher & | catcher )
| inline

## ◆ swap()

void sigc::swap | ( | scoped_connection & | sca,
|  | scoped_connection & | scb )
| noexcept

Swap two scoped connections.

## ◆ unwrap() [1/2]

template <typename T_type>

const T_type & sigc::unwrap | ( | const std::reference_wrapper< const T_type > & | v | ) |

## ◆ unwrap() [2/2]

template <typename T_type>

T_type & sigc::unwrap | ( | const std::reference_wrapper< T_type > & | v | ) |