| 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 R, typename T1, typename T2, ..., typename TN,
                 typename Combiner = optional_last_value<R>,
                 typename Group = int, typename GroupCompare = std::less<Group>,
                 typename SlotFunction = functionN<R, T1, T2, ..., TN>,
                 typename ExtendedSlotFunction = functionN<R, const connection &, T1, T2, ..., TN>,
                 typename Mutex = mutex>
          class signalN;
        template<typename Signature, typename Combiner = optional_last_value<R>,
                 typename Group = int, typename GroupCompare = std::less<Group>,
                 typename SlotFunction = function<Signature>,
                 typename ExtendedSlotFunction = function<R (const connection &, T1, T2, ..., TN)>,
                 typename Mutex = mutex>
          class signal;
      }
    }

### 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 R, typename T1, typename T2, ..., typename TN,
                 typename SlotFunction = functionN<R, T1, T2, ..., TN> >
          class slotN;
        template<typename Signature, typename SlotFunction = function<Signature> >
          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;
      }
    }