Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/signals')
4 files changed, 2 insertions, 30 deletions
diff --git a/3rdParty/Boost/src/boost/signals/detail/named_slot_map.hpp b/3rdParty/Boost/src/boost/signals/detail/named_slot_map.hpp index 88625fa..3f7cf1c 100644 --- a/3rdParty/Boost/src/boost/signals/detail/named_slot_map.hpp +++ b/3rdParty/Boost/src/boost/signals/detail/named_slot_map.hpp @@ -1,51 +1,50 @@ // Boost.Signals library // Copyright Douglas Gregor 2001-2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org #ifndef BOOST_SIGNALS_NAMED_SLOT_MAP_HPP #define BOOST_SIGNALS_NAMED_SLOT_MAP_HPP #include <boost/signals/detail/config.hpp> #include <boost/signals/detail/signals_common.hpp> #include <boost/signals/connection.hpp> -#include <boost/utility.hpp> #include <boost/shared_ptr.hpp> #include <boost/function/function2.hpp> #include <boost/iterator/iterator_facade.hpp> #include <map> #include <memory> #include <utility> namespace boost { namespace BOOST_SIGNALS_NAMESPACE { enum connect_position { at_back, at_front }; namespace detail { class stored_group { public: enum storage_kind { sk_empty, sk_front, sk_back, sk_group }; stored_group(storage_kind p_kind = sk_empty) : kind(p_kind), group() { } template<typename T> stored_group(const T& p_group) : kind(sk_group), group(new T(p_group)) { } bool is_front() const { return kind == sk_front; } bool is_back() const { return kind == sk_back; } bool empty() const { return kind == sk_empty; } void* get() const { return group.get(); } private: storage_kind kind; shared_ptr<void> group; }; typedef function2<bool, stored_group, stored_group> compare_type; @@ -95,71 +94,71 @@ class BOOST_SIGNALS_DECL named_slot_map_iterator : public: named_slot_map_iterator() : slot_assigned(false) { } named_slot_map_iterator(const named_slot_map_iterator& other) : group(other.group), last_group(other.last_group), slot_assigned(other.slot_assigned) { if (slot_assigned) slot_ = other.slot_; } named_slot_map_iterator& operator=(const named_slot_map_iterator& other) { slot_assigned = other.slot_assigned; group = other.group; last_group = other.last_group; if (slot_assigned) slot_ = other.slot_; return *this; } connection_slot_pair& dereference() const { return *slot_; } void increment() { ++slot_; if (slot_ == group->second.end()) { ++group; init_next_group(); } } bool equal(const named_slot_map_iterator& other) const { return (group == other.group && (group == last_group || slot_ == other.slot_)); } -#if BOOST_WORKAROUND(_MSC_VER, <= 1700) +#if BOOST_WORKAROUND(_MSC_VER, <= 1900) void decrement(); void advance(difference_type); #endif private: named_slot_map_iterator(group_iterator giter, group_iterator last) : group(giter), last_group(last), slot_assigned(false) { init_next_group(); } named_slot_map_iterator(group_iterator giter, group_iterator last, slot_pair_iterator slot) : group(giter), last_group(last), slot_(slot), slot_assigned(true) { } void init_next_group() { while (group != last_group && group->second.empty()) ++group; if (group != last_group) { slot_ = group->second.begin(); slot_assigned = true; } } group_iterator group; group_iterator last_group; slot_pair_iterator slot_; bool slot_assigned; friend class named_slot_map; }; class BOOST_SIGNALS_DECL named_slot_map { public: typedef named_slot_map_iterator iterator; diff --git a/3rdParty/Boost/src/boost/signals/detail/signal_base.hpp b/3rdParty/Boost/src/boost/signals/detail/signal_base.hpp index 0438cf7..991e9fc 100644 --- a/3rdParty/Boost/src/boost/signals/detail/signal_base.hpp +++ b/3rdParty/Boost/src/boost/signals/detail/signal_base.hpp @@ -1,55 +1,55 @@ // Boost.Signals library // Copyright Douglas Gregor 2001-2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org #ifndef BOOST_SIGNALS_SIGNAL_BASE_HEADER #define BOOST_SIGNALS_SIGNAL_BASE_HEADER #include <boost/signals/detail/config.hpp> #include <boost/signals/detail/signals_common.hpp> #include <boost/signals/detail/named_slot_map.hpp> #include <boost/signals/connection.hpp> #include <boost/signals/trackable.hpp> #include <boost/signals/slot.hpp> #include <boost/smart_ptr.hpp> -#include <boost/utility.hpp> +#include <boost/noncopyable.hpp> #include <boost/function/function2.hpp> #include <utility> #include <vector> #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { namespace BOOST_SIGNALS_NAMESPACE { namespace detail { // Must be constructed before calling the slots, because it safely // manages call depth class BOOST_SIGNALS_DECL call_notification { public: call_notification(const shared_ptr<signal_base_impl>&); ~call_notification(); shared_ptr<signal_base_impl> impl; }; // Implementation of base class for all signals. It handles the // management of the underlying slot lists. class BOOST_SIGNALS_DECL signal_base_impl { public: friend class call_notification; typedef function2<bool, stored_group, stored_group> compare_type; // Make sure that an exception does not cause the "clearing" flag to // remain set class temporarily_set_clearing { public: temporarily_set_clearing(signal_base_impl* b) : base(b) { diff --git a/3rdParty/Boost/src/boost/signals/detail/signals_common.hpp b/3rdParty/Boost/src/boost/signals/detail/signals_common.hpp index fe1a5a1..9cf078d 100644 --- a/3rdParty/Boost/src/boost/signals/detail/signals_common.hpp +++ b/3rdParty/Boost/src/boost/signals/detail/signals_common.hpp @@ -65,98 +65,80 @@ namespace boost { { typedef Then type; }; }; struct SelectElse { template<typename Then, typename Else> struct Result { typedef Else type; }; }; template<bool Condition> struct Selector { typedef SelectThen type; }; template<> struct Selector<false> { typedef SelectElse type; }; } // end namespace intimate template<bool Condition, typename Then, typename Else> struct IF { typedef typename intimate::Selector<Condition>::type select; typedef typename select::template Result<Then,Else>::type type; }; // Determine if the incoming argument is a reference_wrapper -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template<typename T> struct is_ref { BOOST_STATIC_CONSTANT(bool, value = false); }; template<typename T> struct is_ref<reference_wrapper<T> > { BOOST_STATIC_CONSTANT(bool, value = true); }; -#else // no partial specialization - typedef char yes_type; - typedef double no_type; - - no_type is_ref_tester(...); - - template<typename T> - yes_type is_ref_tester(reference_wrapper<T>*); - - template<typename T> - struct is_ref - { - static T* t; - BOOST_STATIC_CONSTANT(bool, - value = (sizeof(is_ref_tester(t)) == sizeof(yes_type))); - }; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // A slot can be a signal, a reference to a function object, or a // function object. struct signal_tag {}; struct reference_tag {}; struct value_tag {}; // Classify the given slot as a signal, a reference-to-slot, or a // standard slot template<typename S> class get_slot_tag { typedef typename IF<(is_signal<S>::value), signal_tag, value_tag>::type signal_or_value; public: typedef typename IF<(is_ref<S>::value), reference_tag, signal_or_value>::type type; }; // Forward declaration needed in lots of places class signal_base_impl; class bound_objects_visitor; class slot_base; } // end namespace detail } // end namespace BOOST_SIGNALS_NAMESPACE } // end namespace boost #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_SIGNALS_COMMON_HEADER diff --git a/3rdParty/Boost/src/boost/signals/signal_template.hpp b/3rdParty/Boost/src/boost/signals/signal_template.hpp index 6b0b91a..94e1d1a 100644 --- a/3rdParty/Boost/src/boost/signals/signal_template.hpp +++ b/3rdParty/Boost/src/boost/signals/signal_template.hpp @@ -1,54 +1,53 @@ // Boost.Signals library // Copyright Douglas Gregor 2001-2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org // This file intentionally does not have include guards, because it is meant // to be included multiple times (one for each signalN class). The // BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED macro merely serves to // suppress reinclusion of the files that this header depends on. #ifndef BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED #define BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED # include <boost/config.hpp> # include <boost/signals/connection.hpp> -# include <boost/utility.hpp> # include <boost/ref.hpp> # include <boost/signals/slot.hpp> # include <boost/last_value.hpp> # include <boost/signals/detail/signal_base.hpp> # include <boost/signals/detail/slot_call_iterator.hpp> # include <boost/mpl/bool.hpp> # include <boost/type_traits/is_convertible.hpp> # include <cassert> # include <functional> # include <memory> #endif // !BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif // Include the appropriate functionN header #define BOOST_SIGNAL_FUNCTION_N_HEADER BOOST_JOIN(<boost/function/function,BOOST_SIGNALS_NUM_ARGS.hpp>) #include BOOST_SIGNAL_FUNCTION_N_HEADER // Determine if a comma should follow a listing of the arguments/parameters #if BOOST_SIGNALS_NUM_ARGS == 0 # define BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS #else # define BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS , #endif // BOOST_SIGNALS_NUM_ARGS > 0 // Define class names used #define BOOST_SIGNALS_SIGNAL BOOST_JOIN(signal,BOOST_SIGNALS_NUM_ARGS) #define BOOST_SIGNALS_FUNCTION BOOST_JOIN(function,BOOST_SIGNALS_NUM_ARGS) #define BOOST_SIGNALS_ARGS_STRUCT BOOST_JOIN(args,BOOST_SIGNALS_NUM_ARGS) #define BOOST_SIGNALS_CALL_BOUND BOOST_JOIN(call_bound,BOOST_SIGNALS_NUM_ARGS) // Define commonly-used instantiations #define BOOST_SIGNALS_ARGS_STRUCT_INST \ @@ -178,103 +177,95 @@ namespace boost { typedef typename Combiner::result_type result_type; // Combiner type typedef Combiner combiner_type; // Slot type typedef slot<slot_function_type> slot_type; // Slot name type and comparison typedef Group group_type; typedef GroupCompare group_compare_type; typedef BOOST_SIGNALS_NAMESPACE::detail::slot_call_iterator< call_bound_slot, iterator> slot_call_iterator; explicit BOOST_SIGNALS_SIGNAL(const Combiner& c = Combiner(), const GroupCompare& comp = GroupCompare()) : BOOST_SIGNALS_NAMESPACE::detail::signal_base(real_group_compare_type(comp), c) { } // Connect a slot to this signal BOOST_SIGNALS_NAMESPACE::connection connect(const slot_type&, BOOST_SIGNALS_NAMESPACE::connect_position at = BOOST_SIGNALS_NAMESPACE::at_back); BOOST_SIGNALS_NAMESPACE::connection connect(const group_type&, const slot_type&, BOOST_SIGNALS_NAMESPACE::connect_position at = BOOST_SIGNALS_NAMESPACE::at_back); -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - // MSVC 6.0 and 7.0 don't handle the is_convertible test well - void disconnect(const group_type& group) - { - impl->disconnect(group); - } -#else template<typename T> void disconnect(const T& t) { typedef mpl::bool_<(is_convertible<T, group_type>::value)> is_group; this->do_disconnect(t, is_group()); } private: // Disconnect a named slot void do_disconnect(const group_type& group, mpl::bool_<true>) { impl->disconnect(group); } template<typename Function> void do_disconnect(const Function& f, mpl::bool_<false>) { // Notify the slot handling code that we are iterating through the slots BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl); for (iterator i = impl->slots_.begin(); i != impl->slots_.end(); ++i) { slot_function_type& s = *unsafe_any_cast<slot_function_type>(&i->second); if (s == f) i->first.disconnect(); } } -#endif public: // Emit the signal result_type operator()(BOOST_SIGNALS_PARMS); result_type operator()(BOOST_SIGNALS_PARMS) const; Combiner& combiner() { return *unsafe_any_cast<Combiner>(&impl->combiner_); } const Combiner& combiner() const { return *unsafe_any_cast<const Combiner>(&impl->combiner_); } }; template< typename R, BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename Combiner, typename Group, typename GroupCompare, typename SlotFunction > BOOST_SIGNALS_NAMESPACE::connection BOOST_SIGNALS_SIGNAL< R, BOOST_SIGNALS_TEMPLATE_ARGS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS Combiner, Group, GroupCompare, SlotFunction >::connect(const slot_type& in_slot, BOOST_SIGNALS_NAMESPACE::connect_position at) { using boost::BOOST_SIGNALS_NAMESPACE::detail::stored_group; // If the slot has been disconnected, just return a disconnected // connection |