Swiftdiff options
Diffstat (limited to '3rdParty/Boost/boost/signals')
20 files changed, 2023 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/signals/connection.hpp b/3rdParty/Boost/boost/signals/connection.hpp new file mode 100644 index 0000000..48493aa --- /dev/null +++ b/3rdParty/Boost/boost/signals/connection.hpp @@ -0,0 +1,213 @@ +// 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_CONNECTION_HPP +#define BOOST_SIGNALS_CONNECTION_HPP + +#include <boost/signals/detail/signals_common.hpp> +#include <boost/smart_ptr.hpp> +#include <boost/operators.hpp> +#include <boost/any.hpp> +#include <list> +#include <cassert> +#include <utility> + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_PREFIX +#endif + +namespace boost { + namespace BOOST_SIGNALS_NAMESPACE { + class trackable; + + namespace detail { + // Represents an object that has been bound as part of a slot, and how + // to notify that object of a disconnect + struct bound_object { + void* obj; + void* data; + void (*disconnect)(void*, void*); + + bool operator==(const bound_object& other) const + { return obj == other.obj && data == other.data; } + bool operator<(const bound_object& other) const + { return obj < other.obj; } + + // To support intel 80 compiler, 2004/03/18 (Mark Rodgers) + bool operator!=(const bound_object& other) const + { return !(*this==other); } + bool operator>(const bound_object& other) const + { return !(*this < other); } + }; + + // Describes the connection between a signal and the objects that are + // bound for a specific slot. Enables notification of the signal and the + // slots when a disconnect is requested. + struct basic_connection { + void* signal; + void* signal_data; + void (*signal_disconnect)(void*, void*); + bool blocked_; + + std::list<bound_object> bound_objects; + }; + } // end namespace detail + + // The user may freely pass around the "connection" object and terminate + // the connection at any time using disconnect(). + class BOOST_SIGNALS_DECL connection : + private less_than_comparable1<connection>, + private equality_comparable1<connection> + { + public: + connection() : con(), controlling_connection(false) {} + connection(const connection&); + ~connection(); + + // Block he connection: if the connection is still active, there + // will be no notification + void block(bool should_block = true) { con->blocked_ = should_block; } + void unblock() { con->blocked_ = false; } + bool blocked() const { return !connected() || con->blocked_; } + + // Disconnect the signal and slot, if they are connected + void disconnect() const; + + // Returns true if the signal and slot are connected + bool connected() const { return con.get() && con->signal_disconnect; } + + // Comparison of connections + bool operator==(const connection& other) const; + bool operator<(const connection& other) const; + + // Connection assignment + connection& operator=(const connection& other) ; + + // Swap connections + void swap(connection& other); + + public: // TBD: CHANGE THIS + // Set whether this connection object is controlling or not + void set_controlling(bool control = true) + { controlling_connection = control; } + + shared_ptr<BOOST_SIGNALS_NAMESPACE::detail::basic_connection> + get_connection() const + { return con; } + + private: + friend class detail::signal_base_impl; + friend class detail::slot_base; + friend class trackable; + + // Reset this connection to refer to a different actual connection + void reset(BOOST_SIGNALS_NAMESPACE::detail::basic_connection*); + + // Add a bound object to this connection (not for users) + void add_bound_object(const BOOST_SIGNALS_NAMESPACE::detail::bound_object& b); + + friend class BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor; + + // Pointer to the actual contents of the connection + shared_ptr<BOOST_SIGNALS_NAMESPACE::detail::basic_connection> con; + + // True if the destruction of this connection object should disconnect + bool controlling_connection; + }; + + // Similar to connection, but will disconnect the connection when it is + // destroyed unless release() has been called. + class BOOST_SIGNALS_DECL scoped_connection : public connection { + public: + scoped_connection() : connection(), released(false) {} + scoped_connection(const connection&); + scoped_connection(const scoped_connection&); + ~scoped_connection(); + + connection release(); + + inline void swap(scoped_connection&); + + scoped_connection& operator=(const connection&); + scoped_connection& operator=(const scoped_connection&); + + private: + bool released; + }; + + namespace detail { + struct connection_slot_pair { + connection first; + any second; + + connection_slot_pair() {} + + connection_slot_pair(const connection& c, const any& a) + : first(c), second(a) + { + } + + // Dummys to allow explicit instantiation to work + bool operator==(const connection_slot_pair&) const { return false; } + bool operator<(const connection_slot_pair&) const { return false;} + }; + + // Determines if the underlying connection is disconnected + struct is_disconnected { + typedef connection_slot_pair argument_type; + typedef bool result_type; + + inline bool operator()(const argument_type& c) const + { + return !c.first.connected(); + } + }; + + // Determines if the underlying connection is callable, ie if + // it is connected and not blocked + struct is_callable { + typedef connection_slot_pair argument_type; + typedef bool result_type; + + inline bool operator()(const argument_type& c) const + { + return c.first.connected() && !c.first.blocked() ; + } + }; + + // Autodisconnects the bound object when it is destroyed unless the + // release method is invoked. + class auto_disconnect_bound_object { + public: + auto_disconnect_bound_object(const bound_object& b) : + binding(b), auto_disconnect(true) + { + } + + ~auto_disconnect_bound_object() + { + if (auto_disconnect) + binding.disconnect(binding.obj, binding.data); + } + + void release() { auto_disconnect = false; } + + private: + bound_object binding; + bool auto_disconnect; + }; + } // end namespace detail + } // end namespace BOOST_SIGNALS_NAMESPACE +} // end namespace boost + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_SUFFIX +#endif + +#endif // BOOST_SIGNALS_CONNECTION_HPP diff --git a/3rdParty/Boost/boost/signals/detail/config.hpp b/3rdParty/Boost/boost/signals/detail/config.hpp new file mode 100644 index 0000000..bdd6d20 --- /dev/null +++ b/3rdParty/Boost/boost/signals/detail/config.hpp @@ -0,0 +1,54 @@ +/* + * + * Copyright (c) 1998-2002 + * John Maddock + * + * Copyright (c) 2003-2004 + * Douglas Gregor + * + * Distributed under 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) + * + */ + +#ifndef BOOST_SIGNALS_CONFIG_HPP +#define BOOST_SIGNALS_CONFIG_HPP + +#include <boost/config.hpp> + +#ifdef BOOST_HAS_DECLSPEC +# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SIGNALS_DYN_LINK) +# ifdef BOOST_SIGNALS_SOURCE +# define BOOST_SIGNALS_DECL __declspec(dllexport) +# else +# define BOOST_SIGNALS_DECL __declspec(dllimport) +# endif // BOOST_SIGNALS_SOURCE +# endif // DYN_LINK +#endif // BOOST_HAS_DECLSPEC + +#ifndef BOOST_SIGNALS_DECL +# define BOOST_SIGNALS_DECL +#endif + +// Setup autolinking +#if !defined(BOOST_SIGNALS_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SIGNALS_NO_LIB) +# define BOOST_LIB_NAME boost_signals + +# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SIGNALS_DYN_LINK) +# define BOOST_DYN_LINK +# endif + +# include <boost/config/auto_link.hpp> +#endif // autolinking on + +#endif // BOOST_SIGNALS_CONFIG_HPP + + + + + + + + + diff --git a/3rdParty/Boost/boost/signals/detail/named_slot_map.hpp b/3rdParty/Boost/boost/signals/detail/named_slot_map.hpp new file mode 100644 index 0000000..e31d380 --- /dev/null +++ b/3rdParty/Boost/boost/signals/detail/named_slot_map.hpp @@ -0,0 +1,193 @@ +// 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 kind = sk_empty) : kind(kind), group() { } + + template<typename T> + stored_group(const T& group) : kind(sk_group), group(new T(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; + +// This function object bridges from a pair of any objects that hold +// values of type Key to the underlying function object that compares +// values of type Key. +template<typename Compare, typename Key> +class group_bridge_compare { +public: + typedef bool result_type; + typedef const stored_group& first_argument_type; + typedef const stored_group& second_argument_type; + + group_bridge_compare(const Compare& c) : comp(c) + { } + + bool operator()(const stored_group& k1, const stored_group& k2) const + { + if (k1.is_front()) return !k2.is_front(); + if (k1.is_back()) return false; + if (k2.is_front()) return false; + if (k2.is_back()) return true; + + // Neither is empty, so compare their values to order them + return comp(*static_cast<Key*>(k1.get()), *static_cast<Key*>(k2.get())); + } + +private: + Compare comp; +}; + +class BOOST_SIGNALS_DECL named_slot_map_iterator : + public iterator_facade<named_slot_map_iterator, + connection_slot_pair, + forward_traversal_tag> +{ + typedef std::list<connection_slot_pair> group_list; + typedef group_list::iterator slot_pair_iterator; + typedef std::map<stored_group, group_list, compare_type> slot_container_type; + typedef slot_container_type::iterator group_iterator; + typedef slot_container_type::const_iterator const_group_iterator; + + typedef iterator_facade<named_slot_map_iterator, + connection_slot_pair, + forward_traversal_tag> inherited; +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, <= 1500) + void decrement(); + void advance(difference_type); +#endif + +private: + named_slot_map_iterator(group_iterator group, group_iterator last) : + group(group), last_group(last), slot_assigned(false) + { init_next_group(); } + named_slot_map_iterator(group_iterator group, group_iterator last, + slot_pair_iterator slot) : + group(group), 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; + + named_slot_map(const compare_type& compare); + + void clear(); + iterator begin(); + iterator end(); + iterator insert(const stored_group& name, const connection& con, + const any& slot, connect_position at); + void disconnect(const stored_group& name); + void erase(iterator pos); + void remove_disconnected_slots(); + +private: + typedef std::list<connection_slot_pair> group_list; + typedef std::map<stored_group, group_list, compare_type> slot_container_type; + typedef slot_container_type::iterator group_iterator; + typedef slot_container_type::const_iterator const_group_iterator; + + bool empty(const_group_iterator group) const + { + return (group->second.empty() && group != groups.begin() && group != back); + } + slot_container_type groups; + group_iterator back; +}; + +} } } + +#endif // BOOST_SIGNALS_NAMED_SLOT_MAP_HPP diff --git a/3rdParty/Boost/boost/signals/detail/signal_base.hpp b/3rdParty/Boost/boost/signals/detail/signal_base.hpp new file mode 100644 index 0000000..0438cf7 --- /dev/null +++ b/3rdParty/Boost/boost/signals/detail/signal_base.hpp @@ -0,0 +1,159 @@ +// 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/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) + { + base->flags.clearing = true; + } + + ~temporarily_set_clearing() + { + base->flags.clearing = false; + } + + private: + signal_base_impl* base; + }; + + friend class temporarily_set_clearing; + + signal_base_impl(const compare_type&, const any&); + ~signal_base_impl(); + + // Disconnect all slots connected to this signal + void disconnect_all_slots(); + + // Are there any connected slots? + bool empty() const; + + // The number of connected slots + std::size_t num_slots() const; + + // Disconnect all slots in the given group + void disconnect(const stored_group&); + + // We're being notified that a slot has disconnected + static void slot_disconnected(void* obj, void* data); + + connection connect_slot(const any& slot, + const stored_group& name, + shared_ptr<slot_base::data_t> data, + connect_position at); + + private: + // Remove all of the slots that have been marked "disconnected" + void remove_disconnected_slots() const; + + public: + // Our call depth when invoking slots (> 1 when we have a loop) + mutable int call_depth; + + struct { + // True if some slots have disconnected, but we were not able to + // remove them from the list of slots because there are valid + // iterators into the slot list + mutable bool delayed_disconnect:1; + + // True if we are disconnecting all disconnected slots + bool clearing:1; + } flags; + + // Slots + mutable named_slot_map slots_; + any combiner_; + + // Types + typedef named_slot_map::iterator iterator; + }; + + class BOOST_SIGNALS_DECL signal_base : public noncopyable { + public: + typedef signal_base_impl::compare_type compare_type; + + friend class call_notification; + + signal_base(const compare_type& comp, const any& combiner); + ~signal_base(); + + public: + // Disconnect all slots connected to this signal + void disconnect_all_slots() { impl->disconnect_all_slots(); } + + // Are there any connected slots? + bool empty() const { return impl->empty(); } + + // How many slots are connected? + std::size_t num_slots() const { return impl->num_slots(); } + + protected: + connection connect_slot(const any& slot, + const stored_group& name, + shared_ptr<slot_base::data_t> data, + connect_position at) + { + return impl->connect_slot(slot, name, data, at); + } + + typedef named_slot_map::iterator iterator; + + shared_ptr<signal_base_impl> impl; + }; + } // end namespace detail + } // end namespace BOOST_SIGNALS_NAMESPACE +} // end namespace boost + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_SUFFIX +#endif + +#endif // BOOST_SIGNALS_SIGNAL_BASE_HEADER diff --git a/3rdParty/Boost/boost/signals/detail/signals_common.hpp b/3rdParty/Boost/boost/signals/detail/signals_common.hpp new file mode 100644 index 0000000..fe1a5a1 --- /dev/null +++ b/3rdParty/Boost/boost/signals/detail/signals_common.hpp @@ -0,0 +1,162 @@ +// 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_COMMON_HEADER +#define BOOST_SIGNALS_COMMON_HEADER + +#ifndef BOOST_SIGNALS_NAMESPACE +# define BOOST_SIGNALS_NAMESPACE signals +#endif + +#include <boost/type_traits/conversion_traits.hpp> +#include <boost/ref.hpp> +#include <boost/signals/detail/config.hpp> + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_PREFIX +#endif + +namespace boost { + namespace BOOST_SIGNALS_NAMESPACE { + namespace detail { + // The unusable class is a placeholder for unused function arguments + // It is also completely unusable except that it constructable from + // anything. This helps compilers without partial specialization + // handle slots returning void. + struct unusable { + unusable() {} + }; + + // Determine the result type of a slot call + template<typename R> + struct slot_result_type { + typedef R type; + }; + + template<> + struct slot_result_type<void> { + typedef unusable type; + }; + + // Determine if the given type T is a signal + class signal_base; + + template<typename T> + struct is_signal { + BOOST_STATIC_CONSTANT(bool, + value = (is_convertible<T*, signal_base*>::value)); + }; + + /* + * The IF implementation is temporary code. When a Boost metaprogramming + * library is introduced, Boost.Signals will use it instead. + */ + namespace intimate { + struct SelectThen + { + template<typename Then, typename Else> + struct Result + { + 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/boost/signals/detail/slot_call_iterator.hpp b/3rdParty/Boost/boost/signals/detail/slot_call_iterator.hpp new file mode 100644 index 0000000..c6706be --- /dev/null +++ b/3rdParty/Boost/boost/signals/detail/slot_call_iterator.hpp @@ -0,0 +1,95 @@ +// 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_SLOT_CALL_ITERATOR +#define BOOST_SIGNALS_SLOT_CALL_ITERATOR + +#include <memory> +#include <boost/iterator/iterator_facade.hpp> +#include <boost/smart_ptr.hpp> +#include <boost/signals/detail/config.hpp> +#include <boost/signals/connection.hpp> +#include <boost/optional.hpp> + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_PREFIX +#endif + +namespace boost { + namespace BOOST_SIGNALS_NAMESPACE { + namespace detail { + + // Generates a slot call iterator. Essentially, this is an iterator that: + // - skips over disconnected slots in the underlying list + // - calls the connected slots when dereferenced + // - caches the result of calling the slots + template<typename Function, typename Iterator> + class slot_call_iterator + : public iterator_facade<slot_call_iterator<Function, Iterator>, + typename Function::result_type, + single_pass_traversal_tag, + typename Function::result_type const&> + { + typedef iterator_facade<slot_call_iterator<Function, Iterator>, + typename Function::result_type, + single_pass_traversal_tag, + typename Function::result_type const&> + inherited; + + typedef typename Function::result_type result_type; + + friend class iterator_core_access; + + public: + slot_call_iterator(Iterator iter_in, Iterator end_in, Function f, + optional<result_type> &c) + : iter(iter_in), end(end_in), f(f), cache(&c) + { + iter = std::find_if(iter, end, is_callable()); + } + + typename inherited::reference + dereference() const + { + if (!cache->is_initialized()) { + cache->reset(f(*iter)); + } + + return cache->get(); + } + + void increment() + { + iter = std::find_if(++iter, end, is_callable()); + cache->reset(); + } + + bool equal(const slot_call_iterator& other) const + { + iter = std::find_if(iter, end, is_callable()); + other.iter = std::find_if(other.iter, other.end, + is_callable()); + return iter == other.iter; + } + + private: + mutable Iterator iter; + Iterator end; + Function f; + optional<result_type>* cache; + }; + } // end namespace detail + } // end namespace BOOST_SIGNALS_NAMESPACE +} // end namespace boost + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_SUFFIX +#endif + +#endif // BOOST_SIGNALS_SLOT_CALL_ITERATOR diff --git a/3rdParty/Boost/boost/signals/signal0.hpp b/3rdParty/Boost/boost/signals/signal0.hpp new file mode 100644 index 0000000..6a6166c --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal0.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL0_HEADER +#define BOOST_SIGNALS_SIGNAL0_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 0 +#define BOOST_SIGNALS_TEMPLATE_PARMS +#define BOOST_SIGNALS_TEMPLATE_ARGS +#define BOOST_SIGNALS_PARMS +#define BOOST_SIGNALS_ARGS +#define BOOST_SIGNALS_BOUND_ARGS +#define BOOST_SIGNALS_ARGS_AS_MEMBERS +#define BOOST_SIGNALS_COPY_PARMS +#define BOOST_SIGNALS_INIT_ARGS +#define BOOST_SIGNALS_ARG_TYPES + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL0_HEADER diff --git a/3rdParty/Boost/boost/signals/signal1.hpp b/3rdParty/Boost/boost/signals/signal1.hpp new file mode 100644 index 0000000..8363494 --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal1.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL1_HEADER +#define BOOST_SIGNALS_SIGNAL1_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 1 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1 +#define BOOST_SIGNALS_PARMS T1 a1 +#define BOOST_SIGNALS_ARGS a1 +#define BOOST_SIGNALS_BOUND_ARGS args->a1 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL1_HEADER diff --git a/3rdParty/Boost/boost/signals/signal10.hpp b/3rdParty/Boost/boost/signals/signal10.hpp new file mode 100644 index 0000000..0718549 --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal10.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL10_HEADER +#define BOOST_SIGNALS_SIGNAL10_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 10 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9, T10 a10 +#define BOOST_SIGNALS_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2, args->a3, args->a4, args->a5, args->a6, args->a7, args->a8, args->a9, args->a10 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2;T3 a3;T4 a4;T5 a5;T6 a6;T7 a7;T8 a8;T9 a9;T10 a10; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2, T3 ia3, T4 ia4, T5 ia5, T6 ia6, T7 ia7, T8 ia8, T9 ia9, T10 ia10 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2), a3(ia3), a4(ia4), a5(ia5), a6(ia6), a7(ia7), a8(ia8), a9(ia9), a10(ia10) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; typedef T9 arg10_type; typedef T10 arg11_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL10_HEADER diff --git a/3rdParty/Boost/boost/signals/signal2.hpp b/3rdParty/Boost/boost/signals/signal2.hpp new file mode 100644 index 0000000..361014e --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal2.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL2_HEADER +#define BOOST_SIGNALS_SIGNAL2_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 2 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2 +#define BOOST_SIGNALS_ARGS a1, a2 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL2_HEADER diff --git a/3rdParty/Boost/boost/signals/signal3.hpp b/3rdParty/Boost/boost/signals/signal3.hpp new file mode 100644 index 0000000..542a56e --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal3.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL3_HEADER +#define BOOST_SIGNALS_SIGNAL3_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 3 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2, typename T3 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2, T3 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2, T3 a3 +#define BOOST_SIGNALS_ARGS a1, a2, a3 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2, args->a3 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2;T3 a3; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2, T3 ia3 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2), a3(ia3) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL3_HEADER diff --git a/3rdParty/Boost/boost/signals/signal4.hpp b/3rdParty/Boost/boost/signals/signal4.hpp new file mode 100644 index 0000000..695f70f --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal4.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL4_HEADER +#define BOOST_SIGNALS_SIGNAL4_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 4 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2, T3, T4 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2, T3 a3, T4 a4 +#define BOOST_SIGNALS_ARGS a1, a2, a3, a4 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2, args->a3, args->a4 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2;T3 a3;T4 a4; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2, T3 ia3, T4 ia4 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2), a3(ia3), a4(ia4) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL4_HEADER diff --git a/3rdParty/Boost/boost/signals/signal5.hpp b/3rdParty/Boost/boost/signals/signal5.hpp new file mode 100644 index 0000000..ba2f3c2 --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal5.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL5_HEADER +#define BOOST_SIGNALS_SIGNAL5_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 5 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2, T3, T4, T5 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5 +#define BOOST_SIGNALS_ARGS a1, a2, a3, a4, a5 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2, args->a3, args->a4, args->a5 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2;T3 a3;T4 a4;T5 a5; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2, T3 ia3, T4 ia4, T5 ia5 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2), a3(ia3), a4(ia4), a5(ia5) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL5_HEADER diff --git a/3rdParty/Boost/boost/signals/signal6.hpp b/3rdParty/Boost/boost/signals/signal6.hpp new file mode 100644 index 0000000..b46afce --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal6.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL6_HEADER +#define BOOST_SIGNALS_SIGNAL6_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 6 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6 +#define BOOST_SIGNALS_ARGS a1, a2, a3, a4, a5, a6 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2, args->a3, args->a4, args->a5, args->a6 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2;T3 a3;T4 a4;T5 a5;T6 a6; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2, T3 ia3, T4 ia4, T5 ia5, T6 ia6 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2), a3(ia3), a4(ia4), a5(ia5), a6(ia6) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL6_HEADER diff --git a/3rdParty/Boost/boost/signals/signal7.hpp b/3rdParty/Boost/boost/signals/signal7.hpp new file mode 100644 index 0000000..86f1142 --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal7.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL7_HEADER +#define BOOST_SIGNALS_SIGNAL7_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 7 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7 +#define BOOST_SIGNALS_ARGS a1, a2, a3, a4, a5, a6, a7 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2, args->a3, args->a4, args->a5, args->a6, args->a7 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2;T3 a3;T4 a4;T5 a5;T6 a6;T7 a7; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2, T3 ia3, T4 ia4, T5 ia5, T6 ia6, T7 ia7 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2), a3(ia3), a4(ia4), a5(ia5), a6(ia6), a7(ia7) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL7_HEADER diff --git a/3rdParty/Boost/boost/signals/signal8.hpp b/3rdParty/Boost/boost/signals/signal8.hpp new file mode 100644 index 0000000..e2b86ce --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal8.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL8_HEADER +#define BOOST_SIGNALS_SIGNAL8_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 8 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8 +#define BOOST_SIGNALS_ARGS a1, a2, a3, a4, a5, a6, a7, a8 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2, args->a3, args->a4, args->a5, args->a6, args->a7, args->a8 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2;T3 a3;T4 a4;T5 a5;T6 a6;T7 a7;T8 a8; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2, T3 ia3, T4 ia4, T5 ia5, T6 ia6, T7 ia7, T8 ia8 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2), a3(ia3), a4(ia4), a5(ia5), a6(ia6), a7(ia7), a8(ia8) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL8_HEADER diff --git a/3rdParty/Boost/boost/signals/signal9.hpp b/3rdParty/Boost/boost/signals/signal9.hpp new file mode 100644 index 0000000..bb6a57a --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal9.hpp @@ -0,0 +1,37 @@ +// Boost.Signals library + +// Copyright Douglas Gregor 2001-2003. 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_SIGNAL9_HEADER +#define BOOST_SIGNALS_SIGNAL9_HEADER + +#define BOOST_SIGNALS_NUM_ARGS 9 +#define BOOST_SIGNALS_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9 +#define BOOST_SIGNALS_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8, T9 +#define BOOST_SIGNALS_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9 +#define BOOST_SIGNALS_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9 +#define BOOST_SIGNALS_BOUND_ARGS args->a1, args->a2, args->a3, args->a4, args->a5, args->a6, args->a7, args->a8, args->a9 +#define BOOST_SIGNALS_ARGS_AS_MEMBERS T1 a1;T2 a2;T3 a3;T4 a4;T5 a5;T6 a6;T7 a7;T8 a8;T9 a9; +#define BOOST_SIGNALS_COPY_PARMS T1 ia1, T2 ia2, T3 ia3, T4 ia4, T5 ia5, T6 ia6, T7 ia7, T8 ia8, T9 ia9 +#define BOOST_SIGNALS_INIT_ARGS :a1(ia1), a2(ia2), a3(ia3), a4(ia4), a5(ia5), a6(ia6), a7(ia7), a8(ia8), a9(ia9) +#define BOOST_SIGNALS_ARG_TYPES typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; typedef T9 arg10_type; + +#include <boost/signals/signal_template.hpp> + +#undef BOOST_SIGNALS_ARG_TYPES +#undef BOOST_SIGNALS_INIT_ARGS +#undef BOOST_SIGNALS_COPY_PARMS +#undef BOOST_SIGNALS_ARGS_AS_MEMBERS +#undef BOOST_SIGNALS_BOUND_ARGS +#undef BOOST_SIGNALS_ARGS +#undef BOOST_SIGNALS_PARMS +#undef BOOST_SIGNALS_TEMPLATE_ARGS +#undef BOOST_SIGNALS_TEMPLATE_PARMS +#undef BOOST_SIGNALS_NUM_ARGS + +#endif // BOOST_SIGNALS_SIGNAL9_HEADER diff --git a/3rdParty/Boost/boost/signals/signal_template.hpp b/3rdParty/Boost/boost/signals/signal_template.hpp new file mode 100644 index 0000000..a8420b6 --- /dev/null +++ b/3rdParty/Boost/boost/signals/signal_template.hpp @@ -0,0 +1,410 @@ +// 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 \ + BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS> + +namespace boost { + namespace BOOST_SIGNALS_NAMESPACE { + namespace detail { + // Holds the arguments for a bound slot call in a single place + template<BOOST_SIGNALS_TEMPLATE_PARMS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + typename Dummy = int> + struct BOOST_SIGNALS_ARGS_STRUCT { + BOOST_SIGNALS_ARGS_STRUCT(BOOST_SIGNALS_COPY_PARMS) + BOOST_SIGNALS_INIT_ARGS + { + } + + BOOST_SIGNALS_ARGS_AS_MEMBERS + }; + + // Function object that calls the function object given to it, passing + // the bound arguments along to that underlying function object + template<typename R> + struct BOOST_SIGNALS_CALL_BOUND { + template<BOOST_SIGNALS_TEMPLATE_PARMS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + typename F> + struct caller { + typedef BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>* + args_type; + + args_type args; + + typedef R result_type; + + caller() {} + caller(args_type a) : args(a) {} + + template<typename Pair> + R operator()(const Pair& slot) const + { + F* target = const_cast<F*>(unsafe_any_cast<F>(&slot.second)); + return (*target)(BOOST_SIGNALS_BOUND_ARGS); + } + }; + }; + + template<> + struct BOOST_SIGNALS_CALL_BOUND<void> { + template<BOOST_SIGNALS_TEMPLATE_PARMS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + typename F> + struct caller { + typedef BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>* + args_type; + + args_type args; + + typedef unusable result_type; + + caller(args_type a) : args(a) {} + + template<typename Pair> + unusable operator()(const Pair& slot) const + { + F* target = const_cast<F*>(unsafe_any_cast<F>(&slot.second)); + (*target)(BOOST_SIGNALS_BOUND_ARGS); + return unusable(); + } + }; + }; + } // namespace detail + } // namespace BOOST_SIGNALS_NAMESPACE + + // The actual signalN class + template< + typename R, + BOOST_SIGNALS_TEMPLATE_PARMS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + typename Combiner = last_value<R>, + typename Group = int, + typename GroupCompare = std::less<Group>, + typename SlotFunction = BOOST_SIGNALS_FUNCTION< + R BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + BOOST_SIGNALS_TEMPLATE_ARGS> + > + class BOOST_SIGNALS_SIGNAL : + public BOOST_SIGNALS_NAMESPACE::detail::signal_base, // management of slot list + public BOOST_SIGNALS_NAMESPACE::trackable // signals are trackable + { + public: + // The slot function type + typedef SlotFunction slot_function_type; + + // Result type of a slot + typedef typename BOOST_SIGNALS_NAMESPACE::detail::slot_result_type<R>::type + slot_result_type; + + // Argument types + BOOST_SIGNALS_ARG_TYPES + +#if BOOST_SIGNALS_NUM_ARGS == 1 + typedef T1 argument_type; +#elif BOOST_SIGNALS_NUM_ARGS == 2 + typedef T1 first_argument_type; + typedef T2 second_argument_type; +#endif + + private: + // The real slot name comparison object type + typedef BOOST_SIGNALS_NAMESPACE::detail::group_bridge_compare<GroupCompare, Group> + real_group_compare_type; + + // The function object passed to the slot call iterator that will call + // the underlying slot function with its arguments bound + typedef BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_CALL_BOUND<R> + outer_bound_slot_caller; + typedef typename outer_bound_slot_caller::template + caller<BOOST_SIGNALS_TEMPLATE_ARGS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + slot_function_type> + call_bound_slot; + + public: + // Combiner's result type + 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 + if (!in_slot.is_active()) { + return BOOST_SIGNALS_NAMESPACE::connection(); + } + + return impl->connect_slot(in_slot.get_slot_function(), stored_group(), + in_slot.get_data(), at); + } + + 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 group_type& group, + const slot_type& in_slot, + BOOST_SIGNALS_NAMESPACE::connect_position at) + { + // If the slot has been disconnected, just return a disconnected + // connection + if (!in_slot.is_active()) { + return BOOST_SIGNALS_NAMESPACE::connection(); + } + + return impl->connect_slot(in_slot.get_slot_function(), group, + in_slot.get_data(), at); + } + + template< + typename R, + BOOST_SIGNALS_TEMPLATE_PARMS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + typename Combiner, + typename Group, + typename GroupCompare, + typename SlotFunction + > + typename BOOST_SIGNALS_SIGNAL< + R, BOOST_SIGNALS_TEMPLATE_ARGS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + Combiner, Group, GroupCompare, SlotFunction>::result_type + BOOST_SIGNALS_SIGNAL< + R, BOOST_SIGNALS_TEMPLATE_ARGS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + Combiner, Group, GroupCompare, SlotFunction + >::operator()(BOOST_SIGNALS_PARMS) + { + // Notify the slot handling code that we are making a call + BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl); + + // Construct a function object that will call the underlying slots + // with the given arguments. +#if BOOST_SIGNALS_NUM_ARGS == 0 + BOOST_SIGNALS_ARGS_STRUCT_INST args; +#else + BOOST_SIGNALS_ARGS_STRUCT_INST args(BOOST_SIGNALS_ARGS); +#endif // BOOST_SIGNALS_NUM_ARGS > 0 + call_bound_slot f(&args); + + typedef typename call_bound_slot::result_type result_type; + optional<result_type> cache; + // Let the combiner call the slots via a pair of input iterators + return combiner()(slot_call_iterator(notification.impl->slots_.begin(), + impl->slots_.end(), f, cache), + slot_call_iterator(notification.impl->slots_.end(), + impl->slots_.end(), f, cache)); + } + + template< + typename R, + BOOST_SIGNALS_TEMPLATE_PARMS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + typename Combiner, + typename Group, + typename GroupCompare, + typename SlotFunction + > + typename BOOST_SIGNALS_SIGNAL< + R, BOOST_SIGNALS_TEMPLATE_ARGS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + Combiner, Group, GroupCompare, SlotFunction>::result_type + BOOST_SIGNALS_SIGNAL< + R, BOOST_SIGNALS_TEMPLATE_ARGS + BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + Combiner, Group, GroupCompare, SlotFunction + >::operator()(BOOST_SIGNALS_PARMS) const + { + // Notify the slot handling code that we are making a call + BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl); + + // Construct a function object that will call the underlying slots + // with the given arguments. +#if BOOST_SIGNALS_NUM_ARGS == 0 + BOOST_SIGNALS_ARGS_STRUCT_INST args; +#else + BOOST_SIGNALS_ARGS_STRUCT_INST args(BOOST_SIGNALS_ARGS); +#endif // BOOST_SIGNALS_NUM_ARGS > 0 + + call_bound_slot f(&args); + + typedef typename call_bound_slot::result_type result_type; + optional<result_type> cache; + + // Let the combiner call the slots via a pair of input iterators + return combiner()(slot_call_iterator(notification.impl->slots_.begin(), + impl->slots_.end(), f, cache), + slot_call_iterator(notification.impl->slots_.end(), + impl->slots_.end(), f, cache)); + } +} // namespace boost + +#undef BOOST_SIGNAL_FUNCTION_N_HEADER +#undef BOOST_SIGNALS_ARGS_STRUCT_INST +#undef BOOST_SIGNALS_CALL_BOUND +#undef BOOST_SIGNALS_ARGS_STRUCT +#undef BOOST_SIGNALS_FUNCTION +#undef BOOST_SIGNALS_SIGNAL +#undef BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_SUFFIX +#endif diff --git a/3rdParty/Boost/boost/signals/slot.hpp b/3rdParty/Boost/boost/signals/slot.hpp new file mode 100644 index 0000000..bbf1848 --- /dev/null +++ b/3rdParty/Boost/boost/signals/slot.hpp @@ -0,0 +1,157 @@ +// 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_SLOT_HEADER +#define BOOST_SIGNALS_SLOT_HEADER + +#include <boost/signals/detail/signals_common.hpp> +#include <boost/signals/connection.hpp> +#include <boost/signals/trackable.hpp> +#include <boost/visit_each.hpp> +#include <boost/shared_ptr.hpp> +#include <cassert> + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_PREFIX +#endif + +namespace boost { + namespace BOOST_SIGNALS_NAMESPACE { + namespace detail { + class BOOST_SIGNALS_DECL slot_base { + // We would have to enumerate all of the signalN classes here as + // friends to make this private (as it otherwise should be). We can't + // name all of them because we don't know how many there are. + public: + struct data_t { + std::vector<const trackable*> bound_objects; + connection watch_bound_objects; + }; + shared_ptr<data_t> get_data() const { return data; } + + // Get the set of bound objects + std::vector<const trackable*>& get_bound_objects() const + { return data->bound_objects; } + + // Determine if this slot is still "active", i.e., all of the bound + // objects still exist + bool is_active() const + { return data->watch_bound_objects.connected(); } + + protected: + // Create a connection for this slot + void create_connection(); + + shared_ptr<data_t> data; + + private: + static void bound_object_destructed(void*, void*) {} + }; + } // end namespace detail + + // Get the slot so that it can be copied + template<typename F> + reference_wrapper<const F> + get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag) + { return reference_wrapper<const F>(f); } + + template<typename F> + const F& + get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag) + { return f; } + + template<typename F> + const F& + get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag) + { return f; } + + // Get the slot so that it can be inspected for trackable objects + template<typename F> + const F& + get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag) + { return f; } + + template<typename F> + const F& + get_inspectable_slot(const reference_wrapper<F>& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag) + { return f.get(); } + + template<typename F> + const F& + get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag) + { return f; } + + // Determines the type of the slot - is it a signal, a reference to a + // slot or just a normal slot. + template<typename F> + typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type + tag_type(const F&) + { + typedef typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type + the_tag_type; + the_tag_type tag = the_tag_type(); + return tag; + } + + } // end namespace BOOST_SIGNALS_NAMESPACE + + template<typename SlotFunction> + class slot : public BOOST_SIGNALS_NAMESPACE::detail::slot_base { + typedef BOOST_SIGNALS_NAMESPACE::detail::slot_base inherited; + typedef typename inherited::data_t data_t; + + public: + template<typename F> + slot(const F& f) : slot_function(BOOST_SIGNALS_NAMESPACE::get_invocable_slot(f, BOOST_SIGNALS_NAMESPACE::tag_type(f))) + { + this->data.reset(new data_t); + + // Visit each of the bound objects and store them for later use + // An exception thrown here will allow the basic_connection to be + // destroyed when this goes out of scope, and no other connections + // have been made. + BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor + do_bind(this->data->bound_objects); + visit_each(do_bind, + BOOST_SIGNALS_NAMESPACE::get_inspectable_slot + (f, BOOST_SIGNALS_NAMESPACE::tag_type(f))); + create_connection(); + } + +#ifdef __BORLANDC__ + template<typename F> + slot(F* f) : slot_function(f) + { + this->data.reset(new data_t); + create_connection(); + } +#endif // __BORLANDC__ + + // We would have to enumerate all of the signalN classes here as friends + // to make this private (as it otherwise should be). We can't name all of + // them because we don't know how many there are. + public: + // Get the slot function to call the actual slot + const SlotFunction& get_slot_function() const { return slot_function; } + + void release() const { data->watch_bound_objects.set_controlling(false); } + + private: + slot(); // no default constructor + slot& operator=(const slot&); // no assignment operator + + SlotFunction slot_function; + }; +} // end namespace boost + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_SUFFIX +#endif + +#endif // BOOST_SIGNALS_SLOT_HEADER diff --git a/3rdParty/Boost/boost/signals/trackable.hpp b/3rdParty/Boost/boost/signals/trackable.hpp new file mode 100644 index 0000000..047236c --- /dev/null +++ b/3rdParty/Boost/boost/signals/trackable.hpp @@ -0,0 +1,173 @@ +// 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_TRACKABLE_HPP +#define BOOST_SIGNALS_TRACKABLE_HPP + +#include <boost/type_traits.hpp> +#include <boost/signals/connection.hpp> +#include <boost/ref.hpp> +#include <boost/utility/addressof.hpp> +#include <list> +#include <vector> + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_PREFIX +#endif + +namespace boost { + +namespace BOOST_SIGNALS_NAMESPACE { + // Base class for "trackable" objects that can be tracked when they are + // bound in slot target functions. When a trackable object is destroyed, + // the signal/slot connections are disconnected automatically. + class BOOST_SIGNALS_DECL trackable { + private: + static void signal_disconnected(void* obj, void* data); + + friend class detail::signal_base_impl; + friend class detail::slot_base; + void signal_connected(connection, BOOST_SIGNALS_NAMESPACE::detail::bound_object&) const; + + protected: + trackable() : connected_signals(), dying(false) {} + trackable(const trackable&) : connected_signals(), dying(false) {} + ~trackable(); + + trackable& operator=(const trackable&) + { + dying = true; + connected_signals.clear(); + dying = false; + return *this; + } + + private: + typedef std::list<connection> connection_list; + typedef connection_list::iterator connection_iterator; + + // List of connections that this object is part of + mutable connection_list connected_signals; + + // True when the object is being destroyed + mutable bool dying; + }; + + namespace detail { + template<bool Cond> struct truth {}; + + // A visitor that adds each trackable object to a vector + class bound_objects_visitor { + public: + bound_objects_visitor(std::vector<const trackable*>& v) : + bound_objects(v) + { + } + + template<typename T> + void operator()(const T& t) const + { + decode(t, 0); + } + + private: + // decode() decides between a reference wrapper and anything else + template<typename T> + void decode(const reference_wrapper<T>& t, int) const + { + add_if_trackable(t.get_pointer()); + } + + template<typename T> + void decode(const T& t, long) const + { + typedef truth<(is_pointer<T>::value)> is_a_pointer; + maybe_get_pointer(t, is_a_pointer()); + } + + // maybe_get_pointer() decides between a pointer and a non-pointer + template<typename T> + void maybe_get_pointer(const T& t, truth<true>) const + { + add_if_trackable(t); + } + + template<typename T> + void maybe_get_pointer(const T& t, truth<false>) const + { + // Take the address of this object, because the object itself may be + // trackable + add_if_trackable(boost::addressof(t)); + } + + // add_if_trackable() adds trackable objects to the list of bound objects + inline void add_if_trackable(const trackable* b) const + { + if (b) { + bound_objects.push_back(b); + } + } + + inline void add_if_trackable(const void*) const { } + + template<typename R> + inline void add_if_trackable(R (*)()) const { } + + template<typename R, typename T1> + inline void add_if_trackable(R (*)(T1)) const { } + + template<typename R, typename T1, typename T2> + inline void add_if_trackable(R (*)(T1, T2)) const { } + + template<typename R, typename T1, typename T2, typename T3> + inline void add_if_trackable(R (*)(T1, T2, T3)) const { } + + template<typename R, typename T1, typename T2, typename T3, typename T4> + inline void add_if_trackable(R (*)(T1, T2, T3, T4)) const { } + + template<typename R, typename T1, typename T2, typename T3, typename T4, + typename T5> + inline void add_if_trackable(R (*)(T1, T2, T3, T4, T5)) const { } + + template<typename R, typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6> + inline void add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6)) const { } + + template<typename R, typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7> + inline void add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6, T7)) const { } + + template<typename R, typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8> + inline void + add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6, T7, T8)) const { } + + template<typename R, typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8, typename T9> + inline void + add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)) const { } + + template<typename R, typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8, typename T9, + typename T10> + inline void + add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) const { } + + std::vector<const trackable*>& bound_objects; + }; + } // end namespace detail +} // end namespace BOOST_SIGNALS_NAMESPACE + +} // end namespace boost + +#ifdef BOOST_HAS_ABI_HEADERS +# include BOOST_ABI_SUFFIX +#endif + +#endif // BOOST_SIGNALS_TRACKABLE_HPP |