Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.
PrevUpHomeNext

Reference

Header <boost/signals2.hpp>
Header <boost/signals2/connection.hpp>
Header <boost/signals2/deconstruct.hpp>
Header <boost/signals2/dummy_mutex.hpp>
Header <boost/signals2/last_value.hpp>
Header <boost/signals2/mutex.hpp>
Header <boost/signals2/optional_last_value.hpp>
Header <boost/signals2/shared_connection_block.hpp>
Header <boost/signals2/signal.hpp>
Header <boost/signals2/signal_base.hpp>
Header <boost/signals2/signal_type.hpp>
Header <boost/signals2/slot.hpp>
Header <boost/signals2/slot_base.hpp>
Header <boost/signals2/trackable.hpp>

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

namespace boost {
  namespace signals2 {
    class connection;
    void swap(connection&, connection&);
    class scoped_connection;
  }
}
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 &);
  }
}
namespace boost {
  namespace signals2 {
    class dummy_mutex;
  }
}
namespace boost {
  namespace signals2 {
    template<typename T> class last_value;

    template<> class last_value<void>;

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

    template<> class optional_last_value<void>;
  }
}
namespace boost {
  namespace signals2 {
    class shared_connection_block;
  }
}
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;
  }
}
namespace boost {
  namespace signals2 {
    class signal_base;
  }
}
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;
    }
  }
}
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;
  }
}
namespace boost {
  namespace signals2 {
    class slot_base;
    class expired_slot;
  }
}
namespace boost {
  namespace signals2 {
    class trackable;
  }
}

PrevUpHomeNext