| Home | Libraries | People | FAQ | More

## Reference

### Header <boost/signals2.hpp>

Including the "boost/signals2.hpp" header pulls in all the other headers of the Signals2 library. It is provided as a convenience.

### Header <boost/signals2/connection.hpp>

    namespace boost {
      namespace signals2 {
        class connection;
        void swap(connection&, connection&);
        class scoped_connection;
      }
    }

### Header <boost/signals2/deconstruct.hpp>

    namespace boost {
      namespace signals2 {
        class deconstruct_access;
        class postconstructor_invoker;
        template<typename T> postconstructor_invoker<T> deconstruct();
        template<typename T, typename A1>
          postconstructor_invoker<T> deconstruct(const A1 &);
        template<typename T, typename A1, typename A2>
          postconstructor_invoker<T> deconstruct(const A1 &, const A2 &);
        template<typename T, typename A1, typename A2, ..., typename AN>
          postconstructor_invoker<T>
          deconstruct(const A1 &, const A2 &, ..., const AN &);
      }
    }

### Header <boost/signals2/dummy_mutex.hpp>

    namespace boost {
      namespace signals2 {
        class dummy_mutex;
      }
    }

### Header <boost/signals2/last_value.hpp>

    namespace boost {
      namespace signals2 {
        template<typename T> class last_value;

        template<> class last_value<void>;

        class no_slots_error;
      }
    }

### Header <boost/signals2/mutex.hpp>

    namespace boost {
      namespace signals2 {
        class mutex;
      }
    }

### Header <boost/signals2/optional_last_value.hpp>

    namespace boost {
      namespace signals2 {
        template<typename T> class optional_last_value;

        template<> class optional_last_value<void>;
      }
    }

### Header <boost/signals2/shared_connection_block.hpp>

    namespace boost {
      namespace signals2 {
        class shared_connection_block;
      }
    }

### Header <boost/signals2/signal.hpp>

    namespace boost {
      namespace signals2 {

        enum connect_position { at_front, at_back };

        template<typename Signature,
                 typename Combiner = boost::signals2::optional_last_value<R>,
                 typename Group = int, typename GroupCompare = std::less<Group>,
                 typename SlotFunction = boost::function<Signature>,
                 typename ExtendedSlotFunction = boost::function<R (const connection &, T1, T2, ..., TN)>,
                 typename Mutex = boost::signals2::mutex>
          class signal;
        template<typename Signature, typename Combiner, typename Group,
                 typename GroupCompare, typename SlotFunction,
                 typename ExtendedSlotFunction, typename Mutex>
          void swap(signal<Signature, Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex>&,
                    signal<Signature, Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex>&);
      }
    }

### Header <boost/signals2/signal_base.hpp>

    namespace boost {
      namespace signals2 {
        class signal_base;
      }
    }

### Header <boost/signals2/signal_type.hpp>

    namespace boost {
      namespace signals2 {
        template<typename A0, typename A1 = boost::parameter::void_,
                 typename A2 = boost::parameter::void_,
                 typename A3 = boost::parameter::void_,
                 typename A4 = boost::parameter::void_,
                 typename A5 = boost::parameter::void_,
                 typename A6 = boost::parameter::void_>
          class signal_type;
        namespace keywords {
          template<typename Signature> class signature_type;
          template<typename Combiner> class combiner_type;
          template<typename Group> class group_type;
          template<typename GroupCompare> class group_compare_type;
          template<typename SlotFunction> class slot_function_type;
          template<typename ExtendedSlotFunction> class extended_slot_function_type;
          template<typename Mutex> class mutex_type;
        }
      }
    }

### Header <boost/signals2/slot.hpp>

    namespace boost {
      namespace signals2 {
        template<typename Signature,
                 typename SlotFunction = boost::function<R (T1, T2, ..., TN)> >
          class slot;
      }
    }

### Header <boost/signals2/slot_base.hpp>

    namespace boost {
      namespace signals2 {
        class slot_base;
        class expired_slot;
      }
    }

### Header <boost/signals2/trackable.hpp>

    namespace boost {
      namespace signals2 {
        class trackable;
      }
    }