Boost C++ Libraries

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 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>&);
  }
}

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 Signature, 
             typename SlotFunction = boost::function<R (T1, T2, ..., TN)> > 
      class slot;
  }
}

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

namespace boost {
  namespace signals2 {
    class trackable;
  }
}