Reference Manual

Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Namespace Members | Compound Members | File Members

# Inti Namespace Reference

Primary Namespace. More...

## Compounds

- class BoundSlot0_1
    Converts a slot taking one argument into a slot taking no arguments. More...
- class BoundSlot1_2
    Converts a slot taking two arguments into a slot taking one argument. More...
- class BoundSlot2_3
    Converts a slot taking three arguments into a slot taking two arguments. More...
- class BoundSlot3_4
    Converts a slot taking four arguments into a slot taking three arguments. More...
- class BoundSlot4_5
    Converts a slot taking five arguments into a slot taking four arguments. More...
- class BoundSlot5_6
    Converts a slot taking six arguments into a slot taking five arguments. More...
- class Connection
    A signal connection class. More...
- class Forward_StringIterator
    A const non-random access iterator that iterates over a String in the forward direction. More...
- class FunctionSlot0
    A slot template for static functions taking no arguments and returning a value of type R. More...
- class FunctionSlot1
    A slot template for static functions taking one argument of type P1 and returning a value of type R. More...
- class FunctionSlot2
    A slot template for static functions taking two arguments of type P1 and P2, and returning a value of type R. More...
- class FunctionSlot3
    A slot template for static functions taking three arguments of type P1, P2 and P3, and returning a value of type R. More...
- class FunctionSlot4
    A slot template for static functions taking four arguments of type P1, P2, P3 and P4, and returning a value of type R. More...
- class FunctionSlot5
    A slot template for static functions taking five arguments of type P1, P2, P3, P4 and P5, and returning a value of type R. More...
- class FunctionSlot6
    A slot template for static functions taking six arguments of type P1, P2, P3, P4, P5 and P6, and returning a value of type R. More...
- class IntegerObject
    A C++ template base class for integer objects. More...
- class MemoryHandler
    Memory tracking class. More...
- class MethodSlot0
    A slot template for methods in a class of type T taking no arguments and returning a value of type R. More...
- class MethodSlot1
    A slot template for methods in a class of type T taking one argument of type P1 and returning a value of type R. More...
- class MethodSlot2
    A slot template for methods in a class of type T taking two arguments of type P1 and P2, and returning a value of type R. More...
- class MethodSlot3
    A slot template for methods in a class of type T taking three arguments of type P1, P2 and P3, and returning a value of type R. More...
- class MethodSlot4
    A slot template for methods in a class of type T taking four arguments of type P1, P2, P3 and P4, and returning a value of type R. More...
- class MethodSlot5
    A slot template for methods in a class of type T taking five arguments of type P1, P2, P3, P4 and P5, and returning a value of type R. More...
- class MethodSlot6
    A slot template for methods in a class of type T taking six arguments of type P1, P2, P3, P4, P5 and P6, and returning a value of type R. More...
- class Node
    Base class for classes managing slots. More...
- class Pointer
    Smart pointer template class. More...
- class ReferencedBase
    The primary base class. More...
- class ReferencedObject
    Reference counted base class. More...
- class Reverse_StringIterator
    A const non-random access iterator that iterates over a String in the reverse direction. More...
- class Signal
    Base class for the C++ signal interface. More...
- class Signal0
    A template for a signal passing no arguments and returning a value of type R. More...
- class Signal1
    A template for a signal passing one argument of type P1 and returning a value of type R. More...
- class Signal2
    A template for a signal passing two arguments of type P1 and P2, and returning a value of type R. More...
- class Signal3
    A template for a signal passing three arguments of type P1, P2 and P3, and returning a value of type R. More...
- class Signal4
    A template for a signal passing four arguments of type P1, P2, P3 and P4, and returning a value of type R. More...
- class Signal5
    A template for a signal passing five arguments of type P1, P2, P3, P4 and P5, and returning a value of type R. More...
- class Signal6
    A template for a signal passing six arguments of type P1, P2, P3, P4, P5 and P6, and returning a value of type R. More...
- class Slot
    Base class for slots that can connect to Inti::Signals and Inti::G::Signals. More...
- class Slot0
    Base class template for slots passing no arguments and returning a value of type R. More...
- class Slot1
    Base class template for slots passing one argument of type P1 and returning a value of type R. More...
- class Slot2
    Base class template for slots passing two arguments of type P1 and P2, and returning a value of type R. More...
- class Slot3
    Base class template for slots passing three arguments of type P1, P2 and P3, and returning a value of type R. More...
- class Slot4
    Base class template for slots passing four arguments of type P1, P2, P3 and P4, and returning a value of type R. More...
- class Slot5
    Base class template for slots passing five arguments of type P1, P2, P3, P4 and P5, and returning a value of type R. More...
- class Slot6
    Base class template for slots passing six arguments of type P1, P2, P3, P4, P5 and P6, and returning a value of type R. More...
- class SlotNode
    A node class for managing slots connected to Inti::Signal's. More...
- class StackObject
    A C++ base class for automatic (or stack) objects. More...
- class String
    A UTF-8 standard string compatible string class. More...
- class StringIterator
    UTF-8 string iterator base class. More...

## Bind functions returning a new BoundSlot.

- template<typename R, typename P1> Slot0< R > * bind (Slot1< R, P1 > *s, P1 p1)
    Overloaded bind() factory function.
- template<typename R, typename P1, typename P2> Slot1< R, P1 > * bind (Slot2< R, P1, P2 > *s, P2 p2)
    Overloaded bind() factory function.
- template<typename R, typename P1, typename P2, typename P3> Slot2< R, P1, P2 > * bind (Slot3< R, P1, P2, P3 > *s, P3 p3)
    Overloaded bind() factory function.
- template<typename R, typename P1, typename P2, typename P3, typename P4> Slot3< R, P1, P2, P3 > * bind (Slot4< R, P1, P2, P3, P4 > *s, P4 p4)
    Overloaded bind() factory function.
- template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5> Slot4< R, P1, P2, P3, P4 > * bind (Slot5< R, P1, P2, P3, P4, P5 > *s, P5 p5)
    Overloaded bind() factory function.
- template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> Slot5< R, P1, P2, P3, P4,
  P5 > * bind (Slot6< R, P1, P2, P3, P4, P5, P6 > *s, P6 p6)
    Overloaded bind() factory function.

## GetText Methods

- const char * _ (const String &str)
    Convenient wrapper for GNU gettext.
- const char * _ (const String &str, const char *domain)
    Convenient wrapper for GNU dgettext.

## Equality operators

- template<typename T1, typename T2> bool operator== (const Pointer< T1 > &t1, const Pointer< T2 > &t2)
    Compares two Pointers.
- template<typename T1, typename T2> bool operator!= (const Pointer< T1 > &t1, const Pointer< T2 > &t2)
    Compares two Pointers.

## C++-style casting functions

- template<typename To, typename From> Pointer< To > cast_const (const Pointer< From > &from)
    Removes the const qualifier from a managed const dumb pointer.
- template<typename To, typename From> Pointer< To > cast_dynamic (const Pointer< From > &from)
    Casts a managed polymophic dumb pointer down or across its inheritance heirarchy.
- template<typename To, typename From> Pointer< To > cast_static (const Pointer< From > &from)
    Casts a managed dumb pointer to a pointer to a related type.

## Slot functions returning a new slot

- template<typename R> Slot0< R > * slot (R(*function)())
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R> Slot0< R > * slot (T1 *&object, R(T2::*function)())
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R> Slot0< R > * slot (T1 *const &object, R(T2::*function)())
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R> Slot0< R > * slot (T1 &object, R(T2::*function)())
    Overloaded slot factory function.
- template<typename R, typename P1> Slot1< R, P1 > * slot (R(*function)(P1))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1> Slot1< R, P1 > * slot (T1 *&object, R(T2::*function)(P1))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1> Slot1< R, P1 > * slot (T1 *const &object, R(T2::*function)(P1))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1> Slot1< R, P1 > * slot (T1 &object, R(T2::*function)(P1))
    Overloaded slot factory function.
- template<typename R, typename P1, typename P2> Slot2< R, P1, P2 > * slot (R(*function)(P1, P2))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2> Slot2< R, P1, P2 > * slot (T1 *&object, R(T2::*function)(P1, P2))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2> Slot2< R, P1, P2 > * slot (T1 *const &object, R(T2::*function)(P1, P2))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2> Slot2< R, P1, P2 > * slot (T1 &object, R(T2::*function)(P1, P2))
    Overloaded slot factory function.
- template<typename R, typename P1, typename P2, typename P3> Slot3< R, P1, P2, P3 > * slot (R(*function)(P1, P2, P3))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3> Slot3< R, P1, P2, P3 > * slot (T1 *&object, R(T2::*function)(P1, P2, P3))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3> Slot3< R, P1, P2, P3 > * slot (T1 *const &object, R(T2::*function)(P1, P2, P3))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3> Slot3< R, P1, P2, P3 > * slot (T1 &object, R(T2::*function)(P1, P2, P3))
    Overloaded slot factory function.
- template<typename R, typename P1, typename P2, typename P3, typename P4> Slot4< R, P1, P2, P3, P4 > * slot (R(*function)(P1, P2, P3, P4))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4> Slot4< R, P1, P2, P3, P4 > * slot (T1 *&object, R(T2::*function)(P1, P2, P3, P4))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4> Slot4< R, P1, P2, P3, P4 > * slot (T1 *const &object, R(T2::*function)(P1, P2, P3, P4))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4> Slot4< R, P1, P2, P3, P4 > * slot (T1 &object, R(T2::*function)(P1, P2, P3, P4))
    Overloaded slot factory function.
- template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5> Slot5< R, P1, P2, P3, P4,
  P5 > * slot (R(*function)(P1, P2, P3, P4, P5))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5> Slot5< R, P1, P2, P3, P4,
  P5 > * slot (T1 *&object, R(T2::*function)(P1, P2, P3, P4, P5))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5> Slot5< R, P1, P2, P3, P4,
  P5 > * slot (T1 *const &object, R(T2::*function)(P1, P2, P3, P4, P5))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5> Slot5< R, P1, P2, P3, P4,
  P5 > * slot (T1 &object, R(T2::*function)(P1, P2, P3, P4, P5))
    Overloaded slot factory function.
- template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> Slot6< R, P1, P2, P3, P4,
  P5, P6 > * slot (R(*function)(P1, P2, P3, P4, P5, P6))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> Slot6< R, P1, P2, P3, P4,
  P5, P6 > * slot (T1 *&object, R(T2::*function)(P1, P2, P3, P4, P5, P6))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> Slot6< R, P1, P2, P3, P4,
  P5, P6 > * slot (T1 *const &object, R(T2::*function)(P1, P2, P3, P4, P5, P6))
    Overloaded slot factory function.
- template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> Slot6< R, P1, P2, P3, P4,
  P5, P6 > * slot (T1 &object, R(T2::*function)(P1, P2, P3, P4, P5, P6))
    Overloaded slot factory function.

## String i/o stream operators

- std::istream & operator>> (std::istream &is, String &str)
    Read a whitespace-terminated word from an istream to the string str.
- std::ostream & operator<< (std::ostream &os, const String &str)
    Write the string str to an ostream.

## StringIterator comparison operators

- bool operator== (const StringIterator &lhs, const StringIterator &rhs)
    Returns true if the string iterators lhs and rhs point to the same character.
- bool operator!= (const StringIterator &lhs, const StringIterator &rhs)
    Returns true if the string iterators lhs and rhs do not point to the same character.
- bool operator< (const StringIterator &lhs, const StringIterator &rhs)
    Returns true if lhs points to a character in a string that is before the character pointed to by rhs.
- bool operator> (const StringIterator &lhs, const StringIterator &rhs)
    Returns true if lhs points to a character in a string that is after the character pointed to by rhs.
- bool operator<= (const StringIterator &lhs, const StringIterator &rhs)
    Returns true if lhs points to a character in a string that is before the character or is the same character pointed to by rhs.
- bool operator>= (const StringIterator &lhs, const StringIterator &rhs)
    Returns true if lhs points to a character in a string that is the same character or after the character pointed to by rhs.

## String concatenation operators

- String operator+ (const String &lhs, const String &rhs)
    Append the string rhs to the end of the string lhs and return the result as a new String.
- String operator+ (const char *lhs, const String &rhs)
    Append the string rhs to the end of the character array lhs and return the result as a new String.
- String operator+ (char c, const String &rhs)
    Append the string rhs to the character c and return the result as a new String.
- String operator+ (const String &lhs, const char *rhs)
    Append the character array rhs to the end of the string lhs and return the result as a new String.
- String operator+ (const String &lhs, char c)
    Append the character c to the end of the string lhs and return the result as a new String.

## String comparison operators

- bool operator== (const String &lhs, const String &rhs)
    Returns true if the string lhs and the string rhs are characterwise equal.
- bool operator== (const char *lhs, const String &rhs)
    Returns true if the character array lhs and the string rhs are characterwise equal.
- bool operator== (const String &lhs, const char *rhs)
    Returns true if the string lhs and the character array rhs are characterwise equal.
- bool operator!= (const char *lhs, const String &rhs)
    Returns true if the character array lhs and the string rhs are not characterwise equal.
- bool operator!= (const String &lhs, const char *rhs)
    Returns true if the string lhs and the character array rhs are not characterwise equal.
- bool operator< (const String &lhs, const String &rhs)
    Returns true if the string lhs is lexicographically before the string rhs.
- bool operator< (const char *lhs, const String &rhs)
    Returns true if the character array lhs is lexicographically before the string rhs.
- bool operator< (const String &lhs, const char *rhs)
    Returns true if the string lhs is lexicographically before the character array rhs.
- bool operator> (const char *lhs, const String &rhs)
    Returns true if the character array lhs is lexicographically greater the string rhs.
- bool operator> (const String &lhs, const char *rhs)
    Returns true if the string lhs is lexicographically greater the character array rhs.
- bool operator<= (const char *lhs, const String &rhs)
    Returns true if the character array lhs is lexicographically before or equal to the string rhs.
- bool operator<= (const String &lhs, const char *rhs)
    Returns true if the string lhs is lexicographically before or equal to the character array rhs.
- bool operator>= (const char *lhs, const String &rhs)
    Returns true if the character array lhs is lexicographically greater or equal to the string rhs.
- bool operator>= (const String &lhs, const char *rhs)
    Returns true if the string lhs is lexicographically greater or equal to the character array rhs.
- bool operator!= (const String &lhs, const String &rhs)
    Returns true if the string lhs and the string rhs are not characterwise equal.
- bool operator> (const String &lhs, const String &rhs)
    Returns true if the string lhs is lexicographically greater the string rhs.
- bool operator<= (const String &lhs, const String &rhs)
    Returns true if the string lhs is lexicographically before or equal to the string rhs.
- bool operator>= (const String &lhs, const String &rhs)
    Returns true if the string lhs is lexicographically greater or equal to the string rhs.

## Detailed Description

Primary Namespace.

## Function Documentation

const char* _ | ( | const String & | str,
|  | const char * | domain
| ) |

  | Convenient wrapper for GNU dgettext. Parameters:
  str | A String to be passed to dgettext().
  domain | The name of translation domain; will always be a string literal.
Returns: The translation of str if it's available in domain. GNU gettext does two things. First, it marks a string as translable so xgettext() will find it when it scans your sources. The second thing it does is actually return the translated string. If no translation of str is available the str itself is returned. Libraries must specify the domain because the global domain is reserved for use by applications. Libraries use this method instead of defining a _ macro that calls dgettext(). When you run xgettext() don't forget to specify the '--keyword=_' option. This option tells xgettext that translatable strings are marked with an underscore instead of the word gettext.

const char* _ | ( | const String & | str | ) |

  | Convenient wrapper for GNU gettext. Parameters:
  str | A String to be passed to gettext().
Returns: The translation of str if it's available in the current domain. GNU gettext does two things. First, it marks a string as translable so xgettext() will find it when it scans your sources. The second thing it does is actually return the translated string. If no translation of str is available the str itself is returned. Applications should use this method instead of defining a _ macro that calls gettext(). When you run xgettext() don't forget to specify the '--keyword=_' option. This option tells xgettext that translatable strings are marked with an underscore instead of the word gettext.

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
Slot5<R, P1, P2, P3, P4, P5>* bind | ( | Slot6< R, P1, P2, P3, P4, P5, P6 > * | s,
|  | P6 | p6
| ) | `[inline]`

  | Overloaded bind() factory function. Parameters:
  s | A slot of type Slot1<R, P1, P2, P3, P4, P5, P6>.
  p6 | A value of type P6.
Returns: A new slot that stores the value p6. When then returned slot is called it calls the original slot s, passing it the arguments passed to it and the value p6, as the last parameter. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
Slot4<R, P1, P2, P3, P4>* bind | ( | Slot5< R, P1, P2, P3, P4, P5 > * | s,
|  | P5 | p5
| ) | `[inline]`

  | Overloaded bind() factory function. Parameters:
  s | A slot of type Slot1<R, P1, P2, P3, P4, P5>.
  p5 | A value of type P5.
Returns: A new slot that stores the value p5. When then returned slot is called it calls the original slot s, passing it the arguments passed to it and the value p5, as the last parameter. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2, typename P3, typename P4>
Slot3<R, P1, P2, P3>* bind | ( | Slot4< R, P1, P2, P3, P4 > * | s,
|  | P4 | p4
| ) | `[inline]`

  | Overloaded bind() factory function. Parameters:
  s | A slot of type Slot1<R, P1, P2, P3, P4>.
  p4 | A value of type P4.
Returns: A new slot that stores the value p4. When then returned slot is called it calls the original slot s, passing it the arguments passed to it and the value p4, as the last parameter. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2, typename P3>
Slot2<R, P1, P2>* bind | ( | Slot3< R, P1, P2, P3 > * | s,
|  | P3 | p3
| ) | `[inline]`

  | Overloaded bind() factory function. Parameters:
  s | A slot of type Slot1<R, P1, P2, P3>.
  p3 | A value of type P3.
Returns: A new slot that stores the value p3. When then returned slot is called it calls the original slot s, passing it the arguments passed to it and the value p3, as the last parameter. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2>
Slot1<R, P1>* bind | ( | Slot2< R, P1, P2 > * | s,
|  | P2 | p2
| ) | `[inline]`

  | Overloaded bind() factory function. Parameters:
  s | A slot of type Slot1<R, P1, P2>.
  p2 | A value of type P2.
Returns: A new slot that stores the value p2. When then returned slot is called it calls the original slot s, passing it the arguments passed to it and the value p2, as the last parameter. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1>
Slot0<R>* bind | ( | Slot1< R, P1 > * | s,
|  | P1 | p1
| ) | `[inline]`

  | Overloaded bind() factory function. Parameters:
  s | A slot of type Slot1<R, P1>.
  p1 | A value of type P1.
Returns: A new slot that stores the value p1. When then returned slot is called it calls the original slot s, passing it the arguments passed to it and the value p1, as the last parameter. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename To, typename From>
Pointer<To> cast_const | ( | const Pointer< From > & | from | ) | `[inline]`

  | Removes the const qualifier from a managed const dumb pointer. Parameters:
  from | A Pointer that manages a const dumb pointer.
Returns: A new Pointer that manages the non-const dumb pointer. Calls const_cast on the dumb pointer and returns the non-const pointer as a new Pointer.

template<typename To, typename From>
Pointer<To> cast_dynamic | ( | const Pointer< From > & | from | ) | `[inline]`

  | Casts a managed polymophic dumb pointer down or across its inheritance heirarchy. Parameters:
  from | A Pointer managing a polymophic dumb pointer of type From.
Returns: A new Pointer managing the dumb pointer as a base or sibling pointer of type To. Calls dynmaic_cast to safely cast a managed polymophic dumb pointer of type From to a base, derived or sibling class pointer of type To.

template<typename To, typename From>
Pointer<To> cast_static | ( | const Pointer< From > & | from | ) | `[inline]`

  | Casts a managed dumb pointer to a pointer to a related type. Parameters:
  from | A Pointer managing a dumb pointer of type From.
Returns: A new Pointer managing the dumb pointer as a pointer of type To. Calls static_cast to cast a dumb pointer of type From to a pointer of type To.

template<typename T1, typename T2>
bool operator!= | ( | const Pointer< T1 > & | t1,
|  | const Pointer< T2 > & | t2
| ) | `[inline]`

| Compares two Pointers. Returns: true if both Pointers manage a different dumb pointer.

template<typename T1, typename T2>
bool operator== | ( | const Pointer< T1 > & | t1,
|  | const Pointer< T2 > & | t2
| ) | `[inline]`

| Compares two Pointers. Returns: true if both Pointers manage to same dumb pointer.

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
Slot6<R, P1, P2, P3, P4, P5, P6>* slot | ( | T1 & | object,
|  | R(T2::* | function)(P1, P2, P3, P4, P5, P6)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4, P5, P6).
Returns: A new slot passing six arguments of type P1, P2, P3, P4, P5 and P6, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
Slot6<R, P1, P2, P3, P4, P5, P6>* slot | ( | T1 *const & | object,
|  | R(T2::* | function)(P1, P2, P3, P4, P5, P6)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a const pointer to an object of type T1 (e.g. this).
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4, P5, P6).
Returns: A new slot passing six arguments of type P1, P2, P3, P4, P5 and P6, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
Slot6<R, P1, P2, P3, P4, P5, P6>* slot | ( | T1 *& | object,
|  | R(T2::* | function)(P1, P2, P3, P4, P5, P6)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a pointer to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4, P5, P6).
Returns: A new slot passing six arguments of type P1, P2, P3, P4, P5 and P6, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
Slot6<R, P1, P2, P3, P4, P5, P6>* slot | ( | R(* | function)(P1, P2, P3, P4, P5, P6) | ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  function | A static function with the signature R (*function)(P1, P2, P3, P4, P5, P6).
Returns: A new slot passing six arguments of type P1, P2, P3, P4, P5 and P6, and returning a value of type R. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
Slot5<R, P1, P2, P3, P4, P5>* slot | ( | T1 & | object,
|  | R(T2::* | function)(P1, P2, P3, P4, P5)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4, P5).
Returns: A new slot passing five arguments of type P1, P2, P3, P4 and P5, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
Slot5<R, P1, P2, P3, P4, P5>* slot | ( | T1 *const & | object,
|  | R(T2::* | function)(P1, P2, P3, P4, P5)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a const pointer to an object of type T1 (e.g. this).
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4, P5).
Returns: A new slot passing five arguments of type P1, P2, P3, P4 and P5, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
Slot5<R, P1, P2, P3, P4, P5>* slot | ( | T1 *& | object,
|  | R(T2::* | function)(P1, P2, P3, P4, P5)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a pointer to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4, P5).
Returns: A new slot passing five arguments of type P1, P2, P3, P4 and P5, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
Slot5<R, P1, P2, P3, P4, P5>* slot | ( | R(* | function)(P1, P2, P3, P4, P5) | ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  function | A static function with the signature R (*function)(P1, P2, P3, P4, P5).
Returns: A new slot passing five arguments of type P1, P2, P3, P4 and P5, and returning a value of type R. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4>
Slot4<R, P1, P2, P3, P4>* slot | ( | T1 & | object,
|  | R(T2::* | function)(P1, P2, P3, P4)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4).
Returns: A new slot passing four arguments of type P1, P2, P3 and P4, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4>
Slot4<R, P1, P2, P3, P4>* slot | ( | T1 *const & | object,
|  | R(T2::* | function)(P1, P2, P3, P4)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a const pointer to an object of type T1 (e.g. this).
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4).
Returns: A new slot passing four arguments of type P1, P2, P3 and P4, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3, typename P4>
Slot4<R, P1, P2, P3, P4>* slot | ( | T1 *& | object,
|  | R(T2::* | function)(P1, P2, P3, P4)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a pointer to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2, P3, P4).
Returns: A new slot passing four arguments of type P1, P2, P3 and P4, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2, typename P3, typename P4>
Slot4<R, P1, P2, P3, P4>* slot | ( | R(* | function)(P1, P2, P3, P4) | ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  function | A static function with the signature R (*function)(P1, P2, P3, P4).
Returns: A new slot passing four arguments of type P1, P2, P3 and P4, and returning a value of type R. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the sloat when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3>
Slot3<R, P1, P2, P3>* slot | ( | T1 & | object,
|  | R(T2::* | function)(P1, P2, P3)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2, P3).
Returns: A new slot passing three arguments of type P1, P2 and P3, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3>
Slot3<R, P1, P2, P3>* slot | ( | T1 *const & | object,
|  | R(T2::* | function)(P1, P2, P3)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a const pointer to an object of type T1 (e.g. this).
  function | A class method with the signature R (T2::*function)(P1, P2, P3).
Returns: A new slot passing three arguments of type P1, P2 and P3, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2, typename P3>
Slot3<R, P1, P2, P3>* slot | ( | T1 *& | object,
|  | R(T2::* | function)(P1, P2, P3)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a pointer to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2, P3).
Returns: A new slot passing three arguments of type P1, P2 and P3, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2, typename P3>
Slot3<R, P1, P2, P3>* slot | ( | R(* | function)(P1, P2, P3) | ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  function | A static function with the signature R (*function)(P1, P2, P3).
Returns: A new slot passing three arguments of type P1, P2 and P3, and returning a value of type R. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2>
Slot2<R, P1, P2>* slot | ( | T1 & | object,
|  | R(T2::* | function)(P1, P2)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2).
Returns: A new slot passing two arguments of type P1 and P2, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2>
Slot2<R, P1, P2>* slot | ( | T1 *const & | object,
|  | R(T2::* | function)(P1, P2)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a const pointer to an object of type T1 (e.g. this).
  function | A class method with the signature R (T2::*function)(P1, P2).
Returns: A new slot passing two arguments of type P1 and P2, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1, typename P2>
Slot2<R, P1, P2>* slot | ( | T1 *& | object,
|  | R(T2::* | function)(P1, P2)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a pointer to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1, P2).
Returns: A new slot passing two arguments of type P1 and P2, and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1, typename P2>
Slot2<R, P1, P2>* slot | ( | R(* | function)(P1, P2) | ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  function | A static function with the signature R (*function)(P1, P2).
Returns: A new slot passing two arguments of type P1 and P2, and returning a value of type R. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1>
Slot1<R, P1>* slot | ( | T1 & | object,
|  | R(T2::* | function)(P1)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1).
Returns: A new slot passing one argument of type P1 and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1>
Slot1<R, P1>* slot | ( | T1 *const & | object,
|  | R(T2::* | function)(P1)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a const pointer to an object of type T1 (e.g. this).
  function | A class method with the signature R (T2::*function)(P1).
Returns: A new slot passing one argument of type P1 and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R, typename P1>
Slot1<R, P1>* slot | ( | T1 *& | object,
|  | R(T2::* | function)(P1)
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a pointer to an object of type T1.
  function | A class method with the signature R (T2::*function)(P1).
Returns: A new slot passing one argument of type P1 and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R, typename P1>
Slot1<R, P1>* slot | ( | R(* | function)(P1) | ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  function | A static function with the signature R (*function)(P1).
Returns: A new slot passing one argument of type P1 and returning a value of type R. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R>
Slot0<R>* slot | ( | T1 & | object,
|  | R(T2::* | function)()
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to an object of type T1.
  function | A class method with the signature R (T2::*function)().
Returns: A new slot passing no arguments and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R>
Slot0<R>* slot | ( | T1 *const & | object,
|  | R(T2::* | function)()
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a const pointer to an object of type T1 (e.g. this).
  function | A class method with the signature R (T2::*function)().
Returns: A new slot passing no arguments and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename T1, typename T2, typename R>
Slot0<R>* slot | ( | T1 *& | object,
|  | R(T2::* | function)()
| ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  object | A reference to a pointer to an object of type T1.
  function | A class method with the signature R (T2::*function)().
Returns: A new slot passing no arguments and returning a value of type R. T1 can be the same object type as T2. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

template<typename R>
Slot0<R>* slot | ( | R(* | function)() | ) | `[inline]`

  | Overloaded slot factory function. Parameters:
  function | A static function with the signature R (*function)().
Returns: A new slot passing no arguments and returning a value of type R. If the returned slot is connected to a signal it doesn't have to be unreferenced. The signal it's connected to will unreference the slot when it is destroyed. Otherwise the slot must be unreferenced by calling unref().

Main Page - Footer