summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src')
-rw-r--r--3rdParty/Boost/src/boost/cstdlib.hpp41
-rw-r--r--3rdParty/Boost/src/boost/detail/binary_search.hpp216
-rw-r--r--3rdParty/Boost/src/boost/detail/is_xxx.hpp27
-rw-r--r--3rdParty/Boost/src/boost/function/function_typeof.hpp45
-rw-r--r--3rdParty/Boost/src/boost/function/gen_function_N.pl26
-rw-r--r--3rdParty/Boost/src/boost/function_output_iterator.hpp56
-rw-r--r--3rdParty/Boost/src/boost/last_value.hpp54
-rw-r--r--3rdParty/Boost/src/boost/make_shared.hpp17
-rw-r--r--3rdParty/Boost/src/boost/mpl/aux_/unwrap.hpp51
-rw-r--r--3rdParty/Boost/src/boost/mpl/for_each.hpp123
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/at_impl.hpp40
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/begin_end_impl.hpp43
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/clear_impl.hpp35
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/empty_impl.hpp34
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/erase_impl.hpp41
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/erase_key_impl.hpp53
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/has_key_impl.hpp60
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/insert_impl.hpp65
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/item.hpp80
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/iterator.hpp98
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/key_type_impl.hpp34
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/set0.hpp69
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/size_impl.hpp33
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/tag.hpp24
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/aux_/value_type_impl.hpp34
-rw-r--r--3rdParty/Boost/src/boost/mpl/set/set0.hpp35
-rw-r--r--3rdParty/Boost/src/boost/multi_index/detail/scope_guard.hpp453
-rwxr-xr-x3rdParty/Boost/src/boost/parameter.hpp21
-rw-r--r--3rdParty/Boost/src/boost/parameter/aux_/arg_list.hpp459
-rw-r--r--3rdParty/Boost/src/boost/parameter/aux_/cast.hpp143
-rw-r--r--3rdParty/Boost/src/boost/parameter/aux_/default.hpp69
-rw-r--r--3rdParty/Boost/src/boost/parameter/aux_/is_maybe.hpp26
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/overloads.hpp88
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/parameter_requirements.hpp25
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/parenthesized_type.hpp119
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/preprocessor/flatten.hpp115
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/preprocessor/for_each.hpp103
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/result_of0.hpp36
-rw-r--r--3rdParty/Boost/src/boost/parameter/aux_/set.hpp67
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/tag.hpp38
-rw-r--r--3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp188
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/template_keyword.hpp47
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/unwrap_cv_reference.hpp97
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/void.hpp29
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/aux_/yesno.hpp26
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/binding.hpp106
-rw-r--r--3rdParty/Boost/src/boost/parameter/config.hpp14
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/keyword.hpp152
-rw-r--r--3rdParty/Boost/src/boost/parameter/macros.hpp99
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/match.hpp55
-rw-r--r--3rdParty/Boost/src/boost/parameter/name.hpp156
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/parameters.hpp931
-rw-r--r--3rdParty/Boost/src/boost/parameter/preprocessor.hpp1178
-rwxr-xr-x3rdParty/Boost/src/boost/parameter/value_type.hpp108
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/arithmetic.hpp25
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/arithmetic/div.hpp39
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/arithmetic/mul.hpp53
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/detail/is_nullary.hpp30
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/for.hpp17
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/iteration.hpp19
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/repetition.hpp32
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/repetition/deduce_r.hpp22
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/repetition/deduce_z.hpp22
-rw-r--r--3rdParty/Boost/src/boost/preprocessor/repetition/enum_shifted_binary_params.hpp51
-rw-r--r--3rdParty/Boost/src/boost/progress.hpp143
-rw-r--r--3rdParty/Boost/src/boost/range/adaptor/reversed.hpp103
-rw-r--r--3rdParty/Boost/src/boost/signal.hpp366
-rw-r--r--3rdParty/Boost/src/boost/signals.hpp10
-rw-r--r--3rdParty/Boost/src/boost/signals/connection.hpp213
-rw-r--r--3rdParty/Boost/src/boost/signals/detail/config.hpp54
-rw-r--r--3rdParty/Boost/src/boost/signals/detail/named_slot_map.hpp192
-rw-r--r--3rdParty/Boost/src/boost/signals/detail/signal_base.hpp159
-rw-r--r--3rdParty/Boost/src/boost/signals/detail/signals_common.hpp144
-rw-r--r--3rdParty/Boost/src/boost/signals/detail/slot_call_iterator.hpp95
-rw-r--r--3rdParty/Boost/src/boost/signals/signal0.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal1.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal10.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal2.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal3.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal4.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal5.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal6.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal7.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal8.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal9.hpp37
-rw-r--r--3rdParty/Boost/src/boost/signals/signal_template.hpp401
-rw-r--r--3rdParty/Boost/src/boost/signals/slot.hpp157
-rw-r--r--3rdParty/Boost/src/boost/signals/trackable.hpp173
-rw-r--r--3rdParty/Boost/src/boost/signals2.hpp23
-rw-r--r--3rdParty/Boost/src/boost/signals2/connection.hpp297
-rw-r--r--3rdParty/Boost/src/boost/signals2/deconstruct.hpp547
-rw-r--r--3rdParty/Boost/src/boost/signals2/deconstruct_ptr.hpp84
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/auto_buffer.hpp1138
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/foreign_ptr.hpp185
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/lwm_nop.hpp38
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/lwm_pthreads.hpp78
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/lwm_win32_cs.hpp120
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/null_output_iterator.hpp34
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/preprocessed_arg_type.hpp34
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/preprocessed_arg_type_template.hpp39
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/replace_slot_function.hpp32
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/result_type_wrapper.hpp72
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/signal_template.hpp859
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/signals_common.hpp77
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/signals_common_macros.hpp212
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/slot_call_iterator.hpp147
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/slot_groups.hpp235
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/slot_template.hpp187
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/tracked_objects_visitor.hpp98
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/unique_lock.hpp42
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/variadic_arg_type.hpp49
-rw-r--r--3rdParty/Boost/src/boost/signals2/detail/variadic_slot_invoker.hpp139
-rw-r--r--3rdParty/Boost/src/boost/signals2/dummy_mutex.hpp28
-rw-r--r--3rdParty/Boost/src/boost/signals2/expired_slot.hpp31
-rw-r--r--3rdParty/Boost/src/boost/signals2/last_value.hpp78
-rw-r--r--3rdParty/Boost/src/boost/signals2/mutex.hpp38
-rw-r--r--3rdParty/Boost/src/boost/signals2/optional_last_value.hpp65
-rw-r--r--3rdParty/Boost/src/boost/signals2/postconstructible.hpp55
-rw-r--r--3rdParty/Boost/src/boost/signals2/predestructible.hpp46
-rw-r--r--3rdParty/Boost/src/boost/signals2/preprocessed_signal.hpp59
-rw-r--r--3rdParty/Boost/src/boost/signals2/preprocessed_slot.hpp72
-rw-r--r--3rdParty/Boost/src/boost/signals2/shared_connection_block.hpp64
-rw-r--r--3rdParty/Boost/src/boost/signals2/signal.hpp62
-rw-r--r--3rdParty/Boost/src/boost/signals2/signal_base.hpp33
-rw-r--r--3rdParty/Boost/src/boost/signals2/signal_type.hpp144
-rw-r--r--3rdParty/Boost/src/boost/signals2/slot.hpp33
-rw-r--r--3rdParty/Boost/src/boost/signals2/slot_base.hpp100
-rw-r--r--3rdParty/Boost/src/boost/signals2/trackable.hpp49
-rw-r--r--3rdParty/Boost/src/boost/signals2/variadic_signal.hpp44
-rw-r--r--3rdParty/Boost/src/boost/signals2/variadic_slot.hpp25
-rw-r--r--3rdParty/Boost/src/boost/smart_ptr.hpp31
-rw-r--r--3rdParty/Boost/src/boost/timer.hpp72
-rw-r--r--3rdParty/Boost/src/libs/atomic/README.md19
-rw-r--r--3rdParty/Boost/src/libs/atomic/doc/Jamfile.v226
-rw-r--r--3rdParty/Boost/src/libs/atomic/doc/atomic.hpp547
-rw-r--r--3rdParty/Boost/src/libs/atomic/doc/atomic.qbk828
-rw-r--r--3rdParty/Boost/src/libs/atomic/doc/examples.qbk398
-rw-r--r--3rdParty/Boost/src/libs/atomic/doc/logo.pngbin0 -> 11094 bytes
-rw-r--r--3rdParty/Boost/src/libs/atomic/doc/logo.svg1053
-rw-r--r--3rdParty/Boost/src/libs/atomic/doc/platform.qbk312
-rw-r--r--3rdParty/Boost/src/libs/atomic/index.html13
-rw-r--r--3rdParty/Boost/src/libs/signals/src/connection.cpp155
-rw-r--r--3rdParty/Boost/src/libs/signals/src/named_slot_map.cpp134
-rw-r--r--3rdParty/Boost/src/libs/signals/src/signal_base.cpp189
-rw-r--r--3rdParty/Boost/src/libs/signals/src/slot.cpp71
-rw-r--r--3rdParty/Boost/src/libs/signals/src/trackable.cpp59
146 files changed, 15856 insertions, 3152 deletions
diff --git a/3rdParty/Boost/src/boost/cstdlib.hpp b/3rdParty/Boost/src/boost/cstdlib.hpp
new file mode 100644
index 0000000..6322146
--- /dev/null
+++ b/3rdParty/Boost/src/boost/cstdlib.hpp
@@ -0,0 +1,41 @@
+// boost/cstdlib.hpp header ------------------------------------------------//
+
+// Copyright Beman Dawes 2001. 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)
+
+// See http://www.boost.org/libs/utility/cstdlib.html for documentation.
+
+// Revision History
+// 26 Feb 01 Initial version (Beman Dawes)
+
+#ifndef BOOST_CSTDLIB_HPP
+#define BOOST_CSTDLIB_HPP
+
+#include <cstdlib>
+
+namespace boost
+{
+ // The intent is to propose the following for addition to namespace std
+ // in the C++ Standard Library, and to then deprecate EXIT_SUCCESS and
+ // EXIT_FAILURE. As an implementation detail, this header defines the
+ // new constants in terms of EXIT_SUCCESS and EXIT_FAILURE. In a new
+ // standard, the constants would be implementation-defined, although it
+ // might be worthwhile to "suggest" (which a standard is allowed to do)
+ // values of 0 and 1 respectively.
+
+ // Rationale for having multiple failure values: some environments may
+ // wish to distinguish between different classes of errors.
+ // Rationale for choice of values: programs often use values < 100 for
+ // their own error reporting. Values > 255 are sometimes reserved for
+ // system detected errors. 200/201 were suggested to minimize conflict.
+
+ const int exit_success = EXIT_SUCCESS; // implementation-defined value
+ const int exit_failure = EXIT_FAILURE; // implementation-defined value
+ const int exit_exception_failure = 200; // otherwise uncaught exception
+ const int exit_test_failure = 201; // report_error or
+ // report_critical_error called.
+}
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/detail/binary_search.hpp b/3rdParty/Boost/src/boost/detail/binary_search.hpp
new file mode 100644
index 0000000..3dca9b6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/detail/binary_search.hpp
@@ -0,0 +1,216 @@
+// Copyright (c) 2000 David Abrahams.
+// 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)
+//
+// Copyright (c) 1994
+// Hewlett-Packard Company
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation. Hewlett-Packard Company makes no
+// representations about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied warranty.
+//
+// Copyright (c) 1996
+// Silicon Graphics Computer Systems, Inc.
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation. Silicon Graphics makes no
+// representations about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied warranty.
+//
+#ifndef BINARY_SEARCH_DWA_122600_H_
+# define BINARY_SEARCH_DWA_122600_H_
+
+# include <boost/detail/iterator.hpp>
+# include <utility>
+
+namespace boost { namespace detail {
+
+template <class ForwardIter, class Tp>
+ForwardIter lower_bound(ForwardIter first, ForwardIter last,
+ const Tp& val)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = boost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (*middle < val) {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ else
+ len = half;
+ }
+ return first;
+}
+
+template <class ForwardIter, class Tp, class Compare>
+ForwardIter lower_bound(ForwardIter first, ForwardIter last,
+ const Tp& val, Compare comp)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = boost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (comp(*middle, val)) {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ else
+ len = half;
+ }
+ return first;
+}
+
+template <class ForwardIter, class Tp>
+ForwardIter upper_bound(ForwardIter first, ForwardIter last,
+ const Tp& val)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = boost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (val < *middle)
+ len = half;
+ else {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ }
+ return first;
+}
+
+template <class ForwardIter, class Tp, class Compare>
+ForwardIter upper_bound(ForwardIter first, ForwardIter last,
+ const Tp& val, Compare comp)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = boost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (comp(val, *middle))
+ len = half;
+ else {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ }
+ return first;
+}
+
+template <class ForwardIter, class Tp>
+std::pair<ForwardIter, ForwardIter>
+equal_range(ForwardIter first, ForwardIter last, const Tp& val)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = boost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle, left, right;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (*middle < val) {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ else if (val < *middle)
+ len = half;
+ else {
+ left = boost::detail::lower_bound(first, middle, val);
+ std::advance(first, len);
+ right = boost::detail::upper_bound(++middle, first, val);
+ return std::pair<ForwardIter, ForwardIter>(left, right);
+ }
+ }
+ return std::pair<ForwardIter, ForwardIter>(first, first);
+}
+
+template <class ForwardIter, class Tp, class Compare>
+std::pair<ForwardIter, ForwardIter>
+equal_range(ForwardIter first, ForwardIter last, const Tp& val,
+ Compare comp)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = boost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle, left, right;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (comp(*middle, val)) {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ else if (comp(val, *middle))
+ len = half;
+ else {
+ left = boost::detail::lower_bound(first, middle, val, comp);
+ std::advance(first, len);
+ right = boost::detail::upper_bound(++middle, first, val, comp);
+ return std::pair<ForwardIter, ForwardIter>(left, right);
+ }
+ }
+ return std::pair<ForwardIter, ForwardIter>(first, first);
+}
+
+template <class ForwardIter, class Tp>
+bool binary_search(ForwardIter first, ForwardIter last,
+ const Tp& val) {
+ ForwardIter i = boost::detail::lower_bound(first, last, val);
+ return i != last && !(val < *i);
+}
+
+template <class ForwardIter, class Tp, class Compare>
+bool binary_search(ForwardIter first, ForwardIter last,
+ const Tp& val,
+ Compare comp) {
+ ForwardIter i = boost::detail::lower_bound(first, last, val, comp);
+ return i != last && !comp(val, *i);
+}
+
+}} // namespace boost::detail
+
+#endif // BINARY_SEARCH_DWA_122600_H_
diff --git a/3rdParty/Boost/src/boost/detail/is_xxx.hpp b/3rdParty/Boost/src/boost/detail/is_xxx.hpp
new file mode 100644
index 0000000..3f9a126
--- /dev/null
+++ b/3rdParty/Boost/src/boost/detail/is_xxx.hpp
@@ -0,0 +1,27 @@
+// Copyright David Abrahams 2005. 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_DETAIL_IS_XXX_DWA20051011_HPP
+# define BOOST_DETAIL_IS_XXX_DWA20051011_HPP
+
+# include <boost/config.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/preprocessor/enum_params.hpp>
+
+
+# define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs) \
+template <class T> \
+struct is_##name : mpl::false_ \
+{ \
+}; \
+ \
+template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class T) > \
+struct is_##name< \
+ qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, T) > \
+> \
+ : mpl::true_ \
+{ \
+};
+
+
+#endif // BOOST_DETAIL_IS_XXX_DWA20051011_HPP
diff --git a/3rdParty/Boost/src/boost/function/function_typeof.hpp b/3rdParty/Boost/src/boost/function/function_typeof.hpp
deleted file mode 100644
index 246dc15..0000000
--- a/3rdParty/Boost/src/boost/function/function_typeof.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// Boost.Function library - Typeof support
-// Copyright (C) Douglas Gregor 2008
-//
-// 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_FUNCTION_TYPEOF_HPP
-#define BOOST_FUNCTION_TYPEOF_HPP
-#include <boost/function/function_fwd.hpp>
-#include <boost/typeof/typeof.hpp>
-
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
-#endif
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3,
- (typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4,
- (typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5,
- (typename)(typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6,
- (typename)(typename)(typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7,
- (typename)(typename)(typename)(typename)(typename)(typename)(typename)
- (typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8,
- (typename)(typename)(typename)(typename)(typename)(typename)(typename)
- (typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9,
- (typename)(typename)(typename)(typename)(typename)(typename)(typename)
- (typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10,
- (typename)(typename)(typename)(typename)(typename)(typename)(typename)
- (typename)(typename)(typename)(typename))
-#endif
diff --git a/3rdParty/Boost/src/boost/function/gen_function_N.pl b/3rdParty/Boost/src/boost/function/gen_function_N.pl
deleted file mode 100644
index d8f1249..0000000
--- a/3rdParty/Boost/src/boost/function/gen_function_N.pl
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/perl -w
-#
-# Boost.Function 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
-use English;
-
-if ($#ARGV < 0) {
- print "Usage: perl gen_function_N <number of arguments>\n";
- exit;
-}
-
-
-$totalNumArgs = $ARGV[0];
-for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) {
- open OUT, ">function$numArgs.hpp";
- print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n";
- print OUT "#include <boost/function/detail/maybe_include.hpp>\n";
- print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n";
- close OUT;
-}
diff --git a/3rdParty/Boost/src/boost/function_output_iterator.hpp b/3rdParty/Boost/src/boost/function_output_iterator.hpp
new file mode 100644
index 0000000..9720f3f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/function_output_iterator.hpp
@@ -0,0 +1,56 @@
+// (C) Copyright Jeremy Siek 2001.
+// 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)
+
+// Revision History:
+
+// 27 Feb 2001 Jeremy Siek
+// Initial checkin.
+
+#ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
+#define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
+
+#include <iterator>
+
+namespace boost {
+
+ template <class UnaryFunction>
+ class function_output_iterator {
+ typedef function_output_iterator self;
+ public:
+ typedef std::output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ explicit function_output_iterator() {}
+
+ explicit function_output_iterator(const UnaryFunction& f)
+ : m_f(f) {}
+
+ struct output_proxy {
+ output_proxy(UnaryFunction& f) : m_f(f) { }
+ template <class T> output_proxy& operator=(const T& value) {
+ m_f(value);
+ return *this;
+ }
+ UnaryFunction& m_f;
+ };
+ output_proxy operator*() { return output_proxy(m_f); }
+ self& operator++() { return *this; }
+ self& operator++(int) { return *this; }
+ private:
+ UnaryFunction m_f;
+ };
+
+ template <class UnaryFunction>
+ inline function_output_iterator<UnaryFunction>
+ make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
+ return function_output_iterator<UnaryFunction>(f);
+ }
+
+} // namespace boost
+
+#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
diff --git a/3rdParty/Boost/src/boost/last_value.hpp b/3rdParty/Boost/src/boost/last_value.hpp
deleted file mode 100644
index 183a739..0000000
--- a/3rdParty/Boost/src/boost/last_value.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-// last_value function object (documented as part of Boost.Signals)
-
-// 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/libs/signals
-
-#ifndef BOOST_LAST_VALUE_HPP
-#define BOOST_LAST_VALUE_HPP
-
-#include <cassert>
-#include <boost/config.hpp>
-
-namespace boost {
- template<typename T>
- struct last_value {
- typedef T result_type;
-
- template<typename InputIterator>
- T operator()(InputIterator first, InputIterator last) const
- {
- assert(first != last);
- T value = *first++;
- while (first != last)
- value = *first++;
- return value;
- }
- };
-
- template<>
- struct last_value<void> {
-#ifdef BOOST_NO_VOID_RETURNS
- struct unusable {};
-
- public:
- typedef unusable result_type;
-#else
- public:
- typedef void result_type;
-#endif // BOOST_NO_VOID_RETURNS
-
- template<typename InputIterator>
- result_type
- operator()(InputIterator first, InputIterator last) const
- {
- while (first != last)
- *first++;
- return result_type();
- }
- };
-}
-#endif // BOOST_SIGNALS_LAST_VALUE_HPP
diff --git a/3rdParty/Boost/src/boost/make_shared.hpp b/3rdParty/Boost/src/boost/make_shared.hpp
deleted file mode 100644
index c04938f..0000000
--- a/3rdParty/Boost/src/boost/make_shared.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef BOOST_MAKE_SHARED_HPP_INCLUDED
-#define BOOST_MAKE_SHARED_HPP_INCLUDED
-
-// make_shared.hpp
-//
-// Copyright (c) 2007, 2008 Peter Dimov
-//
-// 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
-//
-// See http://www.boost.org/libs/smart_ptr/make_shared.html
-// for documentation.
-
-#include <boost/smart_ptr/make_shared.hpp>
-
-#endif // #ifndef BOOST_MAKE_SHARED_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/aux_/unwrap.hpp b/3rdParty/Boost/src/boost/mpl/aux_/unwrap.hpp
new file mode 100644
index 0000000..caeb97d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/aux_/unwrap.hpp
@@ -0,0 +1,51 @@
+
+#ifndef BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED
+#define BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED
+
+// Copyright Peter Dimov and Multi Media Ltd 2001, 2002
+// Copyright David Abrahams 2001
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/ref.hpp>
+#include <boost/mpl/aux_/config/gpu.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename F >
+BOOST_MPL_CFG_GPU_ENABLED
+inline
+F& unwrap(F& f, long)
+{
+ return f;
+}
+
+template< typename F >
+BOOST_MPL_CFG_GPU_ENABLED
+inline
+F&
+unwrap(reference_wrapper<F>& f, int)
+{
+ return f;
+}
+
+template< typename F >
+BOOST_MPL_CFG_GPU_ENABLED
+inline
+F&
+unwrap(reference_wrapper<F> const& f, int)
+{
+ return f;
+}
+
+}}}
+
+#endif // BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/for_each.hpp b/3rdParty/Boost/src/boost/mpl/for_each.hpp
new file mode 100644
index 0000000..6b40ce1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/for_each.hpp
@@ -0,0 +1,123 @@
+
+#ifndef BOOST_MPL_FOR_EACH_HPP_INCLUDED
+#define BOOST_MPL_FOR_EACH_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2008
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/next_prior.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/aux_/config/gpu.hpp>
+#include <boost/mpl/aux_/unwrap.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/value_init.hpp>
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool done = true >
+struct for_each_impl
+{
+ template<
+ typename Iterator
+ , typename LastIterator
+ , typename TransformFunc
+ , typename F
+ >
+ BOOST_MPL_CFG_GPU_ENABLED
+ static void execute(
+ Iterator*
+ , LastIterator*
+ , TransformFunc*
+ , F
+ )
+ {
+ }
+};
+
+template<>
+struct for_each_impl<false>
+{
+ template<
+ typename Iterator
+ , typename LastIterator
+ , typename TransformFunc
+ , typename F
+ >
+ BOOST_MPL_CFG_GPU_ENABLED
+ static void execute(
+ Iterator*
+ , LastIterator*
+ , TransformFunc*
+ , F f
+ )
+ {
+ typedef typename deref<Iterator>::type item;
+ typedef typename apply1<TransformFunc,item>::type arg;
+
+ // dwa 2002/9/10 -- make sure not to invoke undefined behavior
+ // when we pass arg.
+ value_initialized<arg> x;
+ aux::unwrap(f, 0)(boost::get(x));
+
+ typedef typename mpl::next<Iterator>::type iter;
+ for_each_impl<boost::is_same<iter,LastIterator>::value>
+ ::execute( static_cast<iter*>(0), static_cast<LastIterator*>(0), static_cast<TransformFunc*>(0), f);
+ }
+};
+
+} // namespace aux
+
+// agurt, 17/mar/02: pointer default parameters are necessary to workaround
+// MSVC 6.5 function template signature's mangling bug
+template<
+ typename Sequence
+ , typename TransformOp
+ , typename F
+ >
+BOOST_MPL_CFG_GPU_ENABLED
+inline
+void for_each(F f, Sequence* = 0, TransformOp* = 0)
+{
+ BOOST_MPL_ASSERT(( is_sequence<Sequence> ));
+
+ typedef typename begin<Sequence>::type first;
+ typedef typename end<Sequence>::type last;
+
+ aux::for_each_impl< boost::is_same<first,last>::value >
+ ::execute(static_cast<first*>(0), static_cast<last*>(0), static_cast<TransformOp*>(0), f);
+}
+
+template<
+ typename Sequence
+ , typename F
+ >
+BOOST_MPL_CFG_GPU_ENABLED
+inline
+void for_each(F f, Sequence* = 0)
+{
+ // jfalcou: fully qualifying this call so it doesnt clash with phoenix::for_each
+ // ons ome compilers -- done on 02/28/2011
+ boost::mpl::for_each<Sequence, identity<> >(f);
+}
+
+}}
+
+#endif // BOOST_MPL_FOR_EACH_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/at_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/at_impl.hpp
new file mode 100644
index 0000000..89119c4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/at_impl.hpp
@@ -0,0 +1,40 @@
+
+#ifndef BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/at_fwd.hpp>
+#include <boost/mpl/set/aux_/has_key_impl.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/void.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct at_impl< aux::set_tag >
+{
+ template< typename Set, typename T > struct apply
+ {
+ typedef typename if_<
+ has_key_impl<aux::set_tag>::apply<Set,T>
+ , T
+ , void_
+ >::type type;
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/begin_end_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/begin_end_impl.hpp
new file mode 100644
index 0000000..2595280
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/begin_end_impl.hpp
@@ -0,0 +1,43 @@
+
+#ifndef BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2007
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/begin_end_fwd.hpp>
+#include <boost/mpl/set/aux_/iterator.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct begin_impl< aux::set_tag >
+{
+ template< typename Set > struct apply
+ : s_iter_get<Set,typename Set::item_>
+ {
+ };
+};
+
+template<>
+struct end_impl< aux::set_tag >
+{
+ template< typename Set > struct apply
+ {
+ typedef s_iter< Set,set0<> > type;
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/clear_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/clear_impl.hpp
new file mode 100644
index 0000000..9c6c760
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/clear_impl.hpp
@@ -0,0 +1,35 @@
+
+#ifndef BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/clear_fwd.hpp>
+#include <boost/mpl/set/aux_/set0.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct clear_impl< aux::set_tag >
+{
+ template< typename Set > struct apply
+ {
+ typedef set0<> type;
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/empty_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/empty_impl.hpp
new file mode 100644
index 0000000..997ff02
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/empty_impl.hpp
@@ -0,0 +1,34 @@
+
+#ifndef BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/empty_fwd.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct empty_impl< aux::set_tag >
+{
+ template< typename Set > struct apply
+ : not_< typename Set::size >
+ {
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/erase_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/erase_impl.hpp
new file mode 100644
index 0000000..c4a95b4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/erase_impl.hpp
@@ -0,0 +1,41 @@
+
+#ifndef BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/erase_fwd.hpp>
+#include <boost/mpl/set/aux_/erase_key_impl.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct erase_impl< aux::set_tag >
+{
+ template<
+ typename Set
+ , typename Pos
+ , typename unused_
+ >
+ struct apply
+ : erase_key_impl<aux::set_tag>
+ ::apply<Set,typename Pos::type>
+ {
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/erase_key_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/erase_key_impl.hpp
new file mode 100644
index 0000000..f945d4f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/erase_key_impl.hpp
@@ -0,0 +1,53 @@
+
+#ifndef BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2007
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/erase_key_fwd.hpp>
+#include <boost/mpl/set/aux_/has_key_impl.hpp>
+#include <boost/mpl/set/aux_/item.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/base.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct erase_key_impl< aux::set_tag >
+{
+ template<
+ typename Set
+ , typename T
+ >
+ struct apply
+ : eval_if<
+ has_key_impl<aux::set_tag>::apply<Set,T>
+ , eval_if<
+ is_same< T,typename Set::item_type_ >
+ , base<Set>
+ , identity< s_mask<T,typename Set::item_> >
+ >
+ , identity<Set>
+ >
+ {
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/has_key_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/has_key_impl.hpp
new file mode 100644
index 0000000..bdc3273
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/has_key_impl.hpp
@@ -0,0 +1,60 @@
+
+#ifndef BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/set/aux_/tag.hpp>
+#include <boost/mpl/has_key_fwd.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/aux_/overload_names.hpp>
+#include <boost/mpl/aux_/static_cast.hpp>
+#include <boost/mpl/aux_/yes_no.hpp>
+#include <boost/mpl/aux_/type_wrapper.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct has_key_impl< aux::set_tag >
+{
+ template< typename Set, typename T > struct apply
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+ || BOOST_WORKAROUND(__EDG_VERSION__, <= 245)
+ {
+ BOOST_STATIC_CONSTANT(bool, value =
+ ( sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED(
+ Set
+ , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper<T>*, 0)
+ ) ) == sizeof(aux::no_tag) )
+ );
+
+ typedef bool_<value> type;
+
+#else // ISO98 C++
+ : bool_<
+ ( sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED(
+ Set
+ , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper<T>*, 0)
+ ) ) == sizeof(aux::no_tag) )
+ >
+ {
+#endif
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/insert_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/insert_impl.hpp
new file mode 100644
index 0000000..ff180ac
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/insert_impl.hpp
@@ -0,0 +1,65 @@
+
+#ifndef BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2007
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/insert_fwd.hpp>
+#include <boost/mpl/set/aux_/has_key_impl.hpp>
+#include <boost/mpl/set/aux_/item.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/base.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/aux_/na.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace mpl {
+
+namespace aux {
+template< typename Set, typename T > struct set_insert_impl
+ : eval_if<
+ has_key_impl<aux::set_tag>::apply<Set,T>
+ , identity<Set>
+ , eval_if<
+ is_same< T,typename Set::last_masked_ >
+ , base<Set>
+ , identity< s_item<T,typename Set::item_> >
+ >
+ >
+{
+};
+}
+
+template<>
+struct insert_impl< aux::set_tag >
+{
+ template<
+ typename Set
+ , typename PosOrKey
+ , typename KeyOrNA
+ >
+ struct apply
+ : aux::set_insert_impl<
+ Set
+ , typename if_na<KeyOrNA,PosOrKey>::type
+ >
+ {
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/item.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/item.hpp
new file mode 100644
index 0000000..e90e490
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/item.hpp
@@ -0,0 +1,80 @@
+
+#ifndef BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2007
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/long.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/prior.hpp>
+#include <boost/mpl/set/aux_/set0.hpp>
+#include <boost/mpl/aux_/type_wrapper.hpp>
+#include <boost/mpl/aux_/config/arrays.hpp>
+
+namespace boost { namespace mpl {
+
+template< typename T, typename Base >
+struct s_item
+ : Base
+{
+ typedef s_item<T,Base> item_;
+ typedef void_ last_masked_;
+ typedef T item_type_;
+ typedef typename Base::item_ base;
+
+ typedef typename next< typename Base::size >::type size;
+ typedef typename next< typename Base::order >::type order;
+
+#if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES)
+ typedef typename aux::weighted_tag<BOOST_MPL_AUX_MSVC_VALUE_WKND(order)::value>::type order_tag_;
+#else
+ typedef char (&order_tag_)[BOOST_MPL_AUX_MSVC_VALUE_WKND(order)::value];
+#endif
+
+ BOOST_MPL_AUX_SET_OVERLOAD( order_tag_, ORDER_BY_KEY, s_item, aux::type_wrapper<T>* );
+ BOOST_MPL_AUX_SET_OVERLOAD( aux::no_tag, IS_MASKED, s_item, aux::type_wrapper<T>* );
+};
+
+
+template< typename T, typename Base >
+struct s_mask
+ : Base
+{
+ typedef s_mask<T,Base> item_;
+ typedef T last_masked_;
+ typedef void_ item_type_;
+ typedef typename Base::item_ base;
+ typedef typename prior< typename Base::size >::type size;
+
+ BOOST_MPL_AUX_SET_OVERLOAD( aux::yes_tag, IS_MASKED, s_mask, aux::type_wrapper<T>* );
+};
+
+
+template< typename T, typename Base >
+struct s_unmask
+ : Base
+{
+ typedef s_unmask<T,Base> item_;
+ typedef void_ last_masked_;
+ typedef T item_type_;
+ typedef typename Base::item_ base;
+ typedef typename next< typename Base::size >::type size;
+
+ BOOST_MPL_AUX_SET_OVERLOAD( aux::no_tag, IS_MASKED, s_unmask, aux::type_wrapper<T>* );
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/iterator.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/iterator.hpp
new file mode 100644
index 0000000..9a58a25
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/iterator.hpp
@@ -0,0 +1,98 @@
+
+#ifndef BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2007
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/set/aux_/set0.hpp>
+#include <boost/mpl/has_key.hpp>
+#include <boost/mpl/iterator_tags.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+namespace boost { namespace mpl {
+
+// used by 's_iter_get'
+template< typename Set, typename Tail > struct s_iter;
+
+template< typename Set, typename Tail > struct s_iter_get
+ : eval_if<
+ has_key< Set,typename Tail::item_type_ >
+ , identity< s_iter<Set,Tail> >
+ , next< s_iter<Set,Tail> >
+ >
+{
+};
+
+template< typename Set, typename Tail > struct s_iter_impl
+{
+ typedef Tail tail_;
+ typedef forward_iterator_tag category;
+ typedef typename Tail::item_type_ type;
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+ typedef typename s_iter_get< Set,typename Tail::base >::type next;
+#endif
+};
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template< typename Set, typename Tail >
+struct next< s_iter<Set,Tail> >
+ : s_iter_get< Set,typename Tail::base >
+{
+};
+
+template< typename Set >
+struct next< s_iter<Set,set0<> > >
+{
+ typedef s_iter<Set,set0<> > type;
+};
+
+template< typename Set, typename Tail > struct s_iter
+ : s_iter_impl<Set,Tail>
+{
+};
+
+template< typename Set > struct s_iter<Set, set0<> >
+{
+ typedef forward_iterator_tag category;
+};
+
+#else
+
+template< typename Set >
+struct s_end_iter
+{
+ typedef forward_iterator_tag category;
+ typedef s_iter<Set,set0<> > next;
+};
+
+template< typename Set, typename Tail > struct s_iter
+ : if_<
+ is_same< Tail,set0<> >
+ , s_end_iter<Set>
+ , s_iter_impl<Set,Tail>
+ >::type
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/key_type_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/key_type_impl.hpp
new file mode 100644
index 0000000..8e8a090
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/key_type_impl.hpp
@@ -0,0 +1,34 @@
+
+#ifndef BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/key_type_fwd.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct key_type_impl< aux::set_tag >
+{
+ template< typename Set, typename T > struct apply
+ {
+ typedef T type;
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/set0.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/set0.hpp
new file mode 100644
index 0000000..65f52a8
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/set0.hpp
@@ -0,0 +1,69 @@
+
+#ifndef BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/long.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+#include <boost/mpl/aux_/yes_no.hpp>
+#include <boost/mpl/aux_/overload_names.hpp>
+#include <boost/mpl/aux_/config/operators.hpp>
+
+#include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace mpl {
+
+#if defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING)
+
+# define BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \
+ friend R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \
+/**/
+
+# define BOOST_MPL_AUX_SET_OVERLOAD(R, f, X, T) \
+ BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \
+/**/
+
+#else
+
+# define BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \
+ static R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \
+/**/
+
+# define BOOST_MPL_AUX_SET_OVERLOAD(R, f, X, T) \
+ BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T); \
+ using Base::BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f) \
+/**/
+
+#endif
+
+template< typename Dummy = na > struct set0
+{
+ typedef set0<> item_;
+ typedef item_ type;
+ typedef aux::set_tag tag;
+ typedef void_ last_masked_;
+ typedef void_ item_type_;
+ typedef long_<0> size;
+ typedef long_<1> order;
+
+ BOOST_MPL_AUX_SET0_OVERLOAD( aux::no_tag, ORDER_BY_KEY, set0<>, void const volatile* );
+ BOOST_MPL_AUX_SET0_OVERLOAD( aux::yes_tag, IS_MASKED, set0<>, void const volatile* );
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/size_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/size_impl.hpp
new file mode 100644
index 0000000..e865596
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/size_impl.hpp
@@ -0,0 +1,33 @@
+
+#ifndef BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/size_fwd.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct size_impl< aux::set_tag >
+{
+ template< typename Set > struct apply
+ : Set::size
+ {
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/tag.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/tag.hpp
new file mode 100644
index 0000000..f11fc2b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/tag.hpp
@@ -0,0 +1,24 @@
+
+#ifndef BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+namespace boost { namespace mpl { namespace aux {
+
+struct set_tag;
+
+}}}
+
+#endif // BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/aux_/value_type_impl.hpp b/3rdParty/Boost/src/boost/mpl/set/aux_/value_type_impl.hpp
new file mode 100644
index 0000000..91cf0d0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/aux_/value_type_impl.hpp
@@ -0,0 +1,34 @@
+
+#ifndef BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/value_type_fwd.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+
+namespace boost { namespace mpl {
+
+template<>
+struct value_type_impl< aux::set_tag >
+{
+ template< typename Set, typename T > struct apply
+ {
+ typedef T type;
+ };
+};
+
+}}
+
+#endif // BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/mpl/set/set0.hpp b/3rdParty/Boost/src/boost/mpl/set/set0.hpp
new file mode 100644
index 0000000..8403731
--- /dev/null
+++ b/3rdParty/Boost/src/boost/mpl/set/set0.hpp
@@ -0,0 +1,35 @@
+
+#ifndef BOOST_MPL_SET_SET0_HPP_INCLUDED
+#define BOOST_MPL_SET_SET0_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/set/aux_/at_impl.hpp>
+#include <boost/mpl/set/aux_/clear_impl.hpp>
+//#include <boost/mpl/set/aux_/O1_size.hpp>
+#include <boost/mpl/set/aux_/size_impl.hpp>
+#include <boost/mpl/set/aux_/empty_impl.hpp>
+#include <boost/mpl/set/aux_/insert_impl.hpp>
+#include <boost/mpl/set/aux_/erase_impl.hpp>
+#include <boost/mpl/set/aux_/erase_key_impl.hpp>
+#include <boost/mpl/set/aux_/has_key_impl.hpp>
+#include <boost/mpl/set/aux_/key_type_impl.hpp>
+#include <boost/mpl/set/aux_/value_type_impl.hpp>
+#include <boost/mpl/set/aux_/begin_end_impl.hpp>
+#include <boost/mpl/set/aux_/iterator.hpp>
+#include <boost/mpl/set/aux_/item.hpp>
+#include <boost/mpl/set/aux_/set0.hpp>
+#include <boost/mpl/set/aux_/tag.hpp>
+
+#endif // BOOST_MPL_SET_SET0_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/multi_index/detail/scope_guard.hpp b/3rdParty/Boost/src/boost/multi_index/detail/scope_guard.hpp
new file mode 100644
index 0000000..116f8f5
--- /dev/null
+++ b/3rdParty/Boost/src/boost/multi_index/detail/scope_guard.hpp
@@ -0,0 +1,453 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * 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)
+ *
+ * See http://www.boost.org/libs/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
+#define BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Until some official version of the ScopeGuard idiom makes it into Boost,
+ * we locally define our own. This is a merely reformated version of
+ * ScopeGuard.h as defined in:
+ * Alexandrescu, A., Marginean, P.:"Generic<Programming>: Change the Way You
+ * Write Exception-Safe Code - Forever", C/C++ Users Jornal, Dec 2000,
+ * http://www.drdobbs.com/184403758
+ * with the following modifications:
+ * - General pretty formatting (pretty to my taste at least.)
+ * - Naming style changed to standard C++ library requirements.
+ * - Added scope_guard_impl4 and obj_scope_guard_impl3, (Boost.MultiIndex
+ * needs them). A better design would provide guards for many more
+ * arguments through the Boost Preprocessor Library.
+ * - Added scope_guard_impl_base::touch (see below.)
+ * - Removed RefHolder and ByRef, whose functionality is provided
+ * already by Boost.Ref.
+ * - Removed static make_guard's and make_obj_guard's, so that the code
+ * will work even if BOOST_NO_MEMBER_TEMPLATES is defined. This forces
+ * us to move some private ctors to public, though.
+ *
+ * NB: CodeWarrior Pro 8 seems to have problems looking up safe_execute
+ * without an explicit qualification.
+ *
+ * We also define the following variants of the idiom:
+ *
+ * - make_guard_if_c<bool>( ... )
+ * - make_guard_if<IntegralConstant>( ... )
+ * - make_obj_guard_if_c<bool>( ... )
+ * - make_obj_guard_if<IntegralConstant>( ... )
+ * which may be used with a compile-time constant to yield
+ * a "null_guard" if the boolean compile-time parameter is false,
+ * or conversely, the guard is only constructed if the constant is true.
+ * This is useful to avoid extra tagging, because the returned
+ * null_guard can be optimzed comlpetely away by the compiler.
+ */
+
+class scope_guard_impl_base
+{
+public:
+ scope_guard_impl_base():dismissed_(false){}
+ void dismiss()const{dismissed_=true;}
+
+ /* This helps prevent some "unused variable" warnings under, for instance,
+ * GCC 3.2.
+ */
+ void touch()const{}
+
+protected:
+ ~scope_guard_impl_base(){}
+
+ scope_guard_impl_base(const scope_guard_impl_base& other):
+ dismissed_(other.dismissed_)
+ {
+ other.dismiss();
+ }
+
+ template<typename J>
+ static void safe_execute(J& j){
+ BOOST_TRY{
+ if(!j.dismissed_)j.execute();
+ }
+ BOOST_CATCH(...){}
+ BOOST_CATCH_END
+ }
+
+ mutable bool dismissed_;
+
+private:
+ scope_guard_impl_base& operator=(const scope_guard_impl_base&);
+};
+
+typedef const scope_guard_impl_base& scope_guard;
+
+struct null_guard : public scope_guard_impl_base
+{
+ template< class T1 >
+ null_guard( const T1& )
+ { }
+
+ template< class T1, class T2 >
+ null_guard( const T1&, const T2& )
+ { }
+
+ template< class T1, class T2, class T3 >
+ null_guard( const T1&, const T2&, const T3& )
+ { }
+
+ template< class T1, class T2, class T3, class T4 >
+ null_guard( const T1&, const T2&, const T3&, const T4& )
+ { }
+
+ template< class T1, class T2, class T3, class T4, class T5 >
+ null_guard( const T1&, const T2&, const T3&, const T4&, const T5& )
+ { }
+};
+
+template< bool cond, class T >
+struct null_guard_return
+{
+ typedef typename boost::mpl::if_c<cond,T,null_guard>::type type;
+};
+
+template<typename F>
+class scope_guard_impl0:public scope_guard_impl_base
+{
+public:
+ scope_guard_impl0(F fun):fun_(fun){}
+ ~scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){fun_();}
+
+protected:
+
+ F fun_;
+};
+
+template<typename F>
+inline scope_guard_impl0<F> make_guard(F fun)
+{
+ return scope_guard_impl0<F>(fun);
+}
+
+template<bool cond, typename F>
+inline typename null_guard_return<cond,scope_guard_impl0<F> >::type
+make_guard_if_c(F fun)
+{
+ return typename null_guard_return<cond,scope_guard_impl0<F> >::type(fun);
+}
+
+template<typename C, typename F>
+inline typename null_guard_return<C::value,scope_guard_impl0<F> >::type
+make_guard_if(F fun)
+{
+ return make_guard_if<C::value>(fun);
+}
+
+template<typename F,typename P1>
+class scope_guard_impl1:public scope_guard_impl_base
+{
+public:
+ scope_guard_impl1(F fun,P1 p1):fun_(fun),p1_(p1){}
+ ~scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){fun_(p1_);}
+
+protected:
+ F fun_;
+ const P1 p1_;
+};
+
+template<typename F,typename P1>
+inline scope_guard_impl1<F,P1> make_guard(F fun,P1 p1)
+{
+ return scope_guard_impl1<F,P1>(fun,p1);
+}
+
+template<bool cond, typename F,typename P1>
+inline typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type
+make_guard_if_c(F fun,P1 p1)
+{
+ return typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type(fun,p1);
+}
+
+template<typename C, typename F,typename P1>
+inline typename null_guard_return<C::value,scope_guard_impl1<F,P1> >::type
+make_guard_if(F fun,P1 p1)
+{
+ return make_guard_if_c<C::value>(fun,p1);
+}
+
+template<typename F,typename P1,typename P2>
+class scope_guard_impl2:public scope_guard_impl_base
+{
+public:
+ scope_guard_impl2(F fun,P1 p1,P2 p2):fun_(fun),p1_(p1),p2_(p2){}
+ ~scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){fun_(p1_,p2_);}
+
+protected:
+ F fun_;
+ const P1 p1_;
+ const P2 p2_;
+};
+
+template<typename F,typename P1,typename P2>
+inline scope_guard_impl2<F,P1,P2> make_guard(F fun,P1 p1,P2 p2)
+{
+ return scope_guard_impl2<F,P1,P2>(fun,p1,p2);
+}
+
+template<bool cond, typename F,typename P1,typename P2>
+inline typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type
+make_guard_if_c(F fun,P1 p1,P2 p2)
+{
+ return typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type(fun,p1,p2);
+}
+
+template<typename C, typename F,typename P1,typename P2>
+inline typename null_guard_return<C::value,scope_guard_impl2<F,P1,P2> >::type
+make_guard_if(F fun,P1 p1,P2 p2)
+{
+ return make_guard_if_c<C::value>(fun,p1,p2);
+}
+
+template<typename F,typename P1,typename P2,typename P3>
+class scope_guard_impl3:public scope_guard_impl_base
+{
+public:
+ scope_guard_impl3(F fun,P1 p1,P2 p2,P3 p3):fun_(fun),p1_(p1),p2_(p2),p3_(p3){}
+ ~scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){fun_(p1_,p2_,p3_);}
+
+protected:
+ F fun_;
+ const P1 p1_;
+ const P2 p2_;
+ const P3 p3_;
+};
+
+template<typename F,typename P1,typename P2,typename P3>
+inline scope_guard_impl3<F,P1,P2,P3> make_guard(F fun,P1 p1,P2 p2,P3 p3)
+{
+ return scope_guard_impl3<F,P1,P2,P3>(fun,p1,p2,p3);
+}
+
+template<bool cond,typename F,typename P1,typename P2,typename P3>
+inline typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type
+make_guard_if_c(F fun,P1 p1,P2 p2,P3 p3)
+{
+ return typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type(fun,p1,p2,p3);
+}
+
+template<typename C,typename F,typename P1,typename P2,typename P3>
+inline typename null_guard_return< C::value,scope_guard_impl3<F,P1,P2,P3> >::type
+make_guard_if(F fun,P1 p1,P2 p2,P3 p3)
+{
+ return make_guard_if_c<C::value>(fun,p1,p2,p3);
+}
+
+template<typename F,typename P1,typename P2,typename P3,typename P4>
+class scope_guard_impl4:public scope_guard_impl_base
+{
+public:
+ scope_guard_impl4(F fun,P1 p1,P2 p2,P3 p3,P4 p4):
+ fun_(fun),p1_(p1),p2_(p2),p3_(p3),p4_(p4){}
+ ~scope_guard_impl4(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){fun_(p1_,p2_,p3_,p4_);}
+
+protected:
+ F fun_;
+ const P1 p1_;
+ const P2 p2_;
+ const P3 p3_;
+ const P4 p4_;
+};
+
+template<typename F,typename P1,typename P2,typename P3,typename P4>
+inline scope_guard_impl4<F,P1,P2,P3,P4> make_guard(
+ F fun,P1 p1,P2 p2,P3 p3,P4 p4)
+{
+ return scope_guard_impl4<F,P1,P2,P3,P4>(fun,p1,p2,p3,p4);
+}
+
+template<bool cond, typename F,typename P1,typename P2,typename P3,typename P4>
+inline typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type
+make_guard_if_c(
+ F fun,P1 p1,P2 p2,P3 p3,P4 p4)
+{
+ return typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type(fun,p1,p2,p3,p4);
+}
+
+template<typename C, typename F,typename P1,typename P2,typename P3,typename P4>
+inline typename null_guard_return<C::value,scope_guard_impl4<F,P1,P2,P3,P4> >::type
+make_guard_if(
+ F fun,P1 p1,P2 p2,P3 p3,P4 p4)
+{
+ return make_guard_if_c<C::value>(fun,p1,p2,p3,p4);
+}
+
+template<class Obj,typename MemFun>
+class obj_scope_guard_impl0:public scope_guard_impl_base
+{
+public:
+ obj_scope_guard_impl0(Obj& obj,MemFun mem_fun):obj_(obj),mem_fun_(mem_fun){}
+ ~obj_scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){(obj_.*mem_fun_)();}
+
+protected:
+ Obj& obj_;
+ MemFun mem_fun_;
+};
+
+template<class Obj,typename MemFun>
+inline obj_scope_guard_impl0<Obj,MemFun> make_obj_guard(Obj& obj,MemFun mem_fun)
+{
+ return obj_scope_guard_impl0<Obj,MemFun>(obj,mem_fun);
+}
+
+template<bool cond, class Obj,typename MemFun>
+inline typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type
+make_obj_guard_if_c(Obj& obj,MemFun mem_fun)
+{
+ return typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type(obj,mem_fun);
+}
+
+template<typename C, class Obj,typename MemFun>
+inline typename null_guard_return<C::value,obj_scope_guard_impl0<Obj,MemFun> >::type
+make_obj_guard_if(Obj& obj,MemFun mem_fun)
+{
+ return make_obj_guard_if_c<C::value>(obj,mem_fun);
+}
+
+template<class Obj,typename MemFun,typename P1>
+class obj_scope_guard_impl1:public scope_guard_impl_base
+{
+public:
+ obj_scope_guard_impl1(Obj& obj,MemFun mem_fun,P1 p1):
+ obj_(obj),mem_fun_(mem_fun),p1_(p1){}
+ ~obj_scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){(obj_.*mem_fun_)(p1_);}
+
+protected:
+ Obj& obj_;
+ MemFun mem_fun_;
+ const P1 p1_;
+};
+
+template<class Obj,typename MemFun,typename P1>
+inline obj_scope_guard_impl1<Obj,MemFun,P1> make_obj_guard(
+ Obj& obj,MemFun mem_fun,P1 p1)
+{
+ return obj_scope_guard_impl1<Obj,MemFun,P1>(obj,mem_fun,p1);
+}
+
+template<bool cond, class Obj,typename MemFun,typename P1>
+inline typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type
+make_obj_guard_if_c( Obj& obj,MemFun mem_fun,P1 p1)
+{
+ return typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type(obj,mem_fun,p1);
+}
+
+template<typename C, class Obj,typename MemFun,typename P1>
+inline typename null_guard_return<C::value,obj_scope_guard_impl1<Obj,MemFun,P1> >::type
+make_obj_guard_if( Obj& obj,MemFun mem_fun,P1 p1)
+{
+ return make_obj_guard_if_c<C::value>(obj,mem_fun,p1);
+}
+
+template<class Obj,typename MemFun,typename P1,typename P2>
+class obj_scope_guard_impl2:public scope_guard_impl_base
+{
+public:
+ obj_scope_guard_impl2(Obj& obj,MemFun mem_fun,P1 p1,P2 p2):
+ obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2)
+ {}
+ ~obj_scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){(obj_.*mem_fun_)(p1_,p2_);}
+
+protected:
+ Obj& obj_;
+ MemFun mem_fun_;
+ const P1 p1_;
+ const P2 p2_;
+};
+
+template<class Obj,typename MemFun,typename P1,typename P2>
+inline obj_scope_guard_impl2<Obj,MemFun,P1,P2>
+make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
+{
+ return obj_scope_guard_impl2<Obj,MemFun,P1,P2>(obj,mem_fun,p1,p2);
+}
+
+template<bool cond, class Obj,typename MemFun,typename P1,typename P2>
+inline typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
+make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
+{
+ return typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type(obj,mem_fun,p1,p2);
+}
+
+template<typename C, class Obj,typename MemFun,typename P1,typename P2>
+inline typename null_guard_return<C::value,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
+make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
+{
+ return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2);
+}
+
+template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
+class obj_scope_guard_impl3:public scope_guard_impl_base
+{
+public:
+ obj_scope_guard_impl3(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3):
+ obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2),p3_(p3)
+ {}
+ ~obj_scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
+ void execute(){(obj_.*mem_fun_)(p1_,p2_,p3_);}
+
+protected:
+ Obj& obj_;
+ MemFun mem_fun_;
+ const P1 p1_;
+ const P2 p2_;
+ const P3 p3_;
+};
+
+template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
+inline obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>
+make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
+{
+ return obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>(obj,mem_fun,p1,p2,p3);
+}
+
+template<bool cond, class Obj,typename MemFun,typename P1,typename P2,typename P3>
+inline typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
+make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
+{
+ return typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type(obj,mem_fun,p1,p2,p3);
+}
+
+template<typename C, class Obj,typename MemFun,typename P1,typename P2,typename P3>
+inline typename null_guard_return<C::value,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
+make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
+{
+ return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2,p3);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/3rdParty/Boost/src/boost/parameter.hpp b/3rdParty/Boost/src/boost/parameter.hpp
new file mode 100755
index 0000000..3cc70cb
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter.hpp
@@ -0,0 +1,21 @@
+// Copyright David Abrahams, Daniel Wallin 2005. 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)
+
+// See www.boost.org/libs/parameter for documentation.
+
+#ifndef BOOST_PARAMETER_050401_HPP
+#define BOOST_PARAMETER_050401_HPP
+
+#include <boost/parameter/parameters.hpp>
+#include <boost/parameter/keyword.hpp>
+#include <boost/parameter/binding.hpp>
+#include <boost/parameter/value_type.hpp>
+#include <boost/parameter/macros.hpp>
+#include <boost/parameter/match.hpp>
+#include <boost/parameter/name.hpp>
+#include <boost/parameter/preprocessor.hpp>
+
+#endif // BOOST_PARAMETER_050401_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/arg_list.hpp b/3rdParty/Boost/src/boost/parameter/aux_/arg_list.hpp
new file mode 100644
index 0000000..ed3929d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/arg_list.hpp
@@ -0,0 +1,459 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef ARG_LIST_050329_HPP
+#define ARG_LIST_050329_HPP
+
+#include <boost/parameter/aux_/void.hpp>
+#include <boost/parameter/aux_/result_of0.hpp>
+#include <boost/parameter/aux_/default.hpp>
+#include <boost/parameter/aux_/parameter_requirements.hpp>
+#include <boost/parameter/aux_/yesno.hpp>
+#include <boost/parameter/aux_/is_maybe.hpp>
+#include <boost/parameter/config.hpp>
+
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/iterator_tags.hpp>
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+
+namespace boost { namespace parameter {
+
+// Forward declaration for aux::arg_list, below.
+template<class T> struct keyword;
+
+namespace aux {
+
+// Tag type passed to MPL lambda.
+struct lambda_tag;
+
+//
+// Structures used to build the tuple of actual arguments. The
+// tuple is a nested cons-style list of arg_list specializations
+// terminated by an empty_arg_list.
+//
+// Each specialization of arg_list is derived from its successor in
+// the list type. This feature is used along with using
+// declarations to build member function overload sets that can
+// match against keywords.
+//
+
+// MPL sequence support
+struct arg_list_tag;
+
+// Terminates arg_list<> and represents an empty list. Since this
+// is just the terminating case you might want to look at arg_list
+// first, to get a feel for what's really happening here.
+
+struct empty_arg_list
+{
+ empty_arg_list() {}
+
+ // Constructor taking BOOST_PARAMETER_MAX_ARITY empty_arg_list
+ // arguments; this makes initialization
+ empty_arg_list(
+ BOOST_PP_ENUM_PARAMS(
+ BOOST_PARAMETER_MAX_ARITY, void_ BOOST_PP_INTERCEPT
+ ))
+ {}
+
+ // A metafunction class that, given a keyword and a default
+ // type, returns the appropriate result type for a keyword
+ // lookup given that default
+ struct binding
+ {
+ template<class KW, class Default, class Reference>
+ struct apply
+ {
+ typedef Default type;
+ };
+ };
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ // Terminator for has_key, indicating that the keyword is unique
+ template <class KW>
+ static no_tag has_key(KW*);
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+ || (BOOST_WORKAROUND(__GNUC__, < 3)) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+ // The overload set technique doesn't work with these older
+ // compilers, so they need some explicit handholding.
+
+ // A metafunction class that, given a keyword, returns the type
+ // of the base sublist whose get() function can produce the
+ // value for that key
+ struct key_owner
+ {
+ template<class KW>
+ struct apply
+ {
+ typedef empty_arg_list type;
+ };
+ };
+
+ template <class K, class T>
+ T& get(default_<K,T> x) const
+ {
+ return x.value;
+ }
+
+ template <class K, class F>
+ typename result_of0<F>::type
+ get(lazy_default<K,F> x) const
+ {
+ return x.compute_default();
+ }
+#endif
+
+ // If this function is called, it means there is no argument
+ // in the list that matches the supplied keyword. Just return
+ // the default value.
+ template <class K, class Default>
+ Default& operator[](default_<K, Default> x) const
+ {
+ return x.value;
+ }
+
+ // If this function is called, it means there is no argument
+ // in the list that matches the supplied keyword. Just evaluate
+ // and return the default value.
+ template <class K, class F>
+ typename result_of0<F>::type
+ operator[](
+ BOOST_PARAMETER_lazy_default_fallback<K,F> x) const
+ {
+ return x.compute_default();
+ }
+
+ // No argument corresponding to ParameterRequirements::key_type
+ // was found if we match this overload, so unless that parameter
+ // has a default, we indicate that the actual arguments don't
+ // match the function's requirements.
+ template <class ParameterRequirements, class ArgPack>
+ static typename ParameterRequirements::has_default
+ satisfies(ParameterRequirements*, ArgPack*);
+
+ // MPL sequence support
+ typedef empty_arg_list type; // convenience
+ typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+};
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+template<class KW>
+no_tag operator*(empty_arg_list, KW*);
+#endif
+
+// Forward declaration for arg_list::operator,
+template <class KW, class T>
+struct tagged_argument;
+
+template <class T>
+struct get_reference
+{
+ typedef typename T::reference type;
+};
+
+// A tuple of tagged arguments, terminated with empty_arg_list.
+// Every TaggedArg is an instance of tagged_argument<>.
+template <class TaggedArg, class Next = empty_arg_list>
+struct arg_list : Next
+{
+ typedef arg_list<TaggedArg,Next> self;
+ typedef typename TaggedArg::key_type key_type;
+
+ typedef typename is_maybe<typename TaggedArg::value_type>::type holds_maybe;
+
+ typedef typename mpl::eval_if<
+ holds_maybe
+ , get_reference<typename TaggedArg::value_type>
+ , get_reference<TaggedArg>
+ >::type reference;
+
+ typedef typename mpl::if_<
+ holds_maybe
+ , reference
+ , typename TaggedArg::value_type
+ >::type value_type;
+
+ TaggedArg arg; // Stores the argument
+
+ // Store the arguments in successive nodes of this list
+ template< // class A0, class A1, ...
+ BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
+ >
+ arg_list( // A0& a0, A1& a1, ...
+ BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PARAMETER_MAX_ARITY, A, & a)
+ )
+ : Next( // a1, a2, ...
+ BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PARAMETER_MAX_ARITY, a)
+ , void_reference()
+ )
+ , arg(a0)
+ {}
+
+ // Create a new list by prepending arg to a copy of tail. Used
+ // when incrementally building this structure with the comma
+ // operator.
+ arg_list(TaggedArg head, Next const& tail)
+ : Next(tail)
+ , arg(head)
+ {}
+
+ // A metafunction class that, given a keyword and a default
+ // type, returns the appropriate result type for a keyword
+ // lookup given that default
+ struct binding
+ {
+ template <class KW, class Default, class Reference>
+ struct apply
+ {
+ typedef typename mpl::eval_if<
+ boost::is_same<KW, key_type>
+ , mpl::if_<Reference, reference, value_type>
+ , mpl::apply_wrap3<typename Next::binding, KW, Default, Reference>
+ >::type type;
+ };
+ };
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && !BOOST_WORKAROUND(__GNUC__, == 2)
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ friend yes_tag operator*(arg_list, key_type*);
+# define BOOST_PARAMETER_CALL_HAS_KEY(next, key) (*(next*)0 * (key*)0)
+# else
+ // Overload for key_type, so the assert below will fire if the
+ // same keyword is used again
+ static yes_tag has_key(key_type*);
+ using Next::has_key;
+
+# define BOOST_PARAMETER_CALL_HAS_KEY(next, key) next::has_key((key*)0)
+# endif
+
+ BOOST_MPL_ASSERT_MSG(
+ sizeof(BOOST_PARAMETER_CALL_HAS_KEY(Next,key_type)) == sizeof(no_tag)
+ , duplicate_keyword, (key_type)
+ );
+
+# undef BOOST_PARAMETER_CALL_HAS_KEY
+#endif
+ //
+ // Begin implementation of indexing operators for looking up
+ // specific arguments by name
+ //
+
+ // Helpers that handle the case when TaggedArg is
+ // empty<T>.
+ template <class D>
+ reference get_default(D const&, mpl::false_) const
+ {
+ return arg.value;
+ }
+
+ template <class D>
+ reference get_default(D const& d, mpl::true_) const
+ {
+ return arg.value ? arg.value.get() : arg.value.construct(d.value);
+ }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+ || BOOST_WORKAROUND(__GNUC__, < 3) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ // These older compilers don't support the overload set creation
+ // idiom well, so we need to do all the return type calculation
+ // for the compiler and dispatch through an outer function template
+
+ // A metafunction class that, given a keyword, returns the base
+ // sublist whose get() function can produce the value for that
+ // key.
+ struct key_owner
+ {
+ template<class KW>
+ struct apply
+ {
+ typedef typename mpl::eval_if<
+ boost::is_same<KW, key_type>
+ , mpl::identity<arg_list<TaggedArg,Next> >
+ , mpl::apply_wrap1<typename Next::key_owner,KW>
+ >::type type;
+ };
+ };
+
+ // Outer indexing operators that dispatch to the right node's
+ // get() function.
+ template <class KW>
+ typename mpl::apply_wrap3<binding, KW, void_, mpl::true_>::type
+ operator[](keyword<KW> const& x) const
+ {
+ typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
+ return sublist.get(x);
+ }
+
+ template <class KW, class Default>
+ typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type
+ operator[](default_<KW, Default> x) const
+ {
+ typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
+ return sublist.get(x);
+ }
+
+ template <class KW, class F>
+ typename mpl::apply_wrap3<
+ binding,KW
+ , typename result_of0<F>::type
+ , mpl::true_
+ >::type
+ operator[](lazy_default<KW,F> x) const
+ {
+ typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
+ return sublist.get(x);
+ }
+
+ // These just return the stored value; when empty_arg_list is
+ // reached, indicating no matching argument was passed, the
+ // default is returned, or if no default_ or lazy_default was
+ // passed, compilation fails.
+ reference get(keyword<key_type> const&) const
+ {
+ BOOST_MPL_ASSERT_NOT((holds_maybe));
+ return arg.value;
+ }
+
+ template <class Default>
+ reference get(default_<key_type,Default> const& d) const
+ {
+ return get_default(d, holds_maybe());
+ }
+
+ template <class Default>
+ reference get(lazy_default<key_type, Default>) const
+ {
+ return arg.value;
+ }
+
+#else
+
+ reference operator[](keyword<key_type> const&) const
+ {
+ BOOST_MPL_ASSERT_NOT((holds_maybe));
+ return arg.value;
+ }
+
+ template <class Default>
+ reference operator[](default_<key_type, Default> const& d) const
+ {
+ return get_default(d, holds_maybe());
+ }
+
+ template <class Default>
+ reference operator[](lazy_default<key_type, Default>) const
+ {
+ return arg.value;
+ }
+
+ // Builds an overload set including operator[]s defined in base
+ // classes.
+ using Next::operator[];
+
+ //
+ // End of indexing support
+ //
+
+
+ //
+ // For parameter_requirements matching this node's key_type,
+ // return a bool constant wrapper indicating whether the
+ // requirements are satisfied by TaggedArg. Used only for
+ // compile-time computation and never really called, so a
+ // declaration is enough.
+ //
+ template <class HasDefault, class Predicate, class ArgPack>
+ static typename mpl::apply_wrap2<
+ typename mpl::lambda<Predicate, lambda_tag>::type
+ , value_type, ArgPack
+ >::type
+ satisfies(
+ parameter_requirements<key_type,Predicate,HasDefault>*
+ , ArgPack*
+ );
+
+ // Builds an overload set including satisfies functions defined
+ // in base classes.
+ using Next::satisfies;
+#endif
+
+ // Comma operator to compose argument list without using parameters<>.
+ // Useful for argument lists with undetermined length.
+ template <class KW, class T2>
+ arg_list<tagged_argument<KW, T2>, self>
+ operator,(tagged_argument<KW,T2> x) const
+ {
+ return arg_list<tagged_argument<KW,T2>, self>(x, *this);
+ }
+
+ // MPL sequence support
+ typedef self type; // Convenience for users
+ typedef Next tail_type; // For the benefit of iterators
+ typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+};
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) // ETI workaround
+template <> struct arg_list<int,int> {};
+#endif
+
+// MPL sequence support
+template <class ArgumentPack>
+struct arg_list_iterator
+{
+ typedef mpl::forward_iterator_tag category;
+
+ // The incremented iterator
+ typedef arg_list_iterator<typename ArgumentPack::tail_type> next;
+
+ // dereferencing yields the key type
+ typedef typename ArgumentPack::key_type type;
+};
+
+template <>
+struct arg_list_iterator<empty_arg_list> {};
+
+}} // namespace parameter::aux
+
+// MPL sequence support
+namespace mpl
+{
+ template <>
+ struct begin_impl<parameter::aux::arg_list_tag>
+ {
+ template <class S>
+ struct apply
+ {
+ typedef parameter::aux::arg_list_iterator<S> type;
+ };
+ };
+
+ template <>
+ struct end_impl<parameter::aux::arg_list_tag>
+ {
+ template <class>
+ struct apply
+ {
+ typedef parameter::aux::arg_list_iterator<parameter::aux::empty_arg_list> type;
+ };
+ };
+}
+
+} // namespace boost
+
+#endif // ARG_LIST_050329_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/cast.hpp b/3rdParty/Boost/src/boost/parameter/aux_/cast.hpp
new file mode 100644
index 0000000..b94c764
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/cast.hpp
@@ -0,0 +1,143 @@
+// Copyright Daniel Wallin 2006. 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)
+
+#ifndef BOOST_PARAMETER_CAST_060902_HPP
+# define BOOST_PARAMETER_CAST_060902_HPP
+
+# include <boost/detail/workaround.hpp>
+
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+ && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/type_traits/remove_const.hpp>
+# endif
+
+namespace boost { namespace parameter { namespace aux {
+
+struct use_default_tag {};
+
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+# define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) value
+
+# else
+
+// Handles possible implicit casts. Used by preprocessor.hpp to
+// normalize user input.
+//
+// cast<void*>::execute() is identity
+// cast<void*(X)>::execute() is identity
+// cast<void(X)>::execute() casts to X
+//
+// preprocessor.hpp uses this like this:
+//
+// #define X(value, predicate)
+// cast<void predicate>::execute(value)
+//
+// X(something, *)
+// X(something, *(predicate))
+// X(something, (int))
+
+template <class T, class Args>
+struct cast;
+
+template <class Args>
+struct cast<void*, Args>
+{
+ static use_default_tag execute(use_default_tag)
+ {
+ return use_default_tag();
+ }
+
+ static use_default_tag remove_const(use_default_tag)
+ {
+ return use_default_tag();
+ }
+
+ template <class U>
+ static U& execute(U& value)
+ {
+ return value;
+ }
+
+ template <class U>
+ static U& remove_const(U& x)
+ {
+ return x;
+ }
+};
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
+
+typedef void* voidstar;
+
+template <class T, class Args>
+struct cast<voidstar(T), Args>
+ : cast<void*, Args>
+{
+};
+
+#else
+
+template <class T, class Args>
+struct cast<void*(T), Args>
+ : cast<void*, Args>
+{
+};
+
+#endif
+
+// This is a hack used in cast<> to turn the user supplied type,
+// which may or may not be a placeholder expression into one, so
+// that it will be properly evaluated by mpl::apply.
+template <class T, class Dummy = mpl::_1>
+struct as_placeholder_expr
+{
+ typedef T type;
+};
+
+template <class T, class Args>
+struct cast<void(T), Args>
+{
+ typedef typename mpl::apply2<
+ as_placeholder_expr<T>, Args, Args>::type type0;
+
+ typedef typename boost::add_reference<
+ typename boost::remove_const<type0>::type
+ >::type reference;
+
+ static use_default_tag execute(use_default_tag)
+ {
+ return use_default_tag();
+ }
+
+ static use_default_tag remove_const(use_default_tag)
+ {
+ return use_default_tag();
+ }
+
+ static type0 execute(type0 value)
+ {
+ return value;
+ }
+
+ template <class U>
+ static reference remove_const(U const& x)
+ {
+ return const_cast<reference>(x);
+ }
+};
+
+# define BOOST_PARAMETER_FUNCTION_CAST(value, predicate, args) \
+ boost::parameter::aux::cast<void predicate, args>::remove_const( \
+ boost::parameter::aux::cast<void predicate, args>::execute(value) \
+ )
+
+# endif
+
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_CAST_060902_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/default.hpp b/3rdParty/Boost/src/boost/parameter/aux_/default.hpp
new file mode 100644
index 0000000..604da61
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/default.hpp
@@ -0,0 +1,69 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef DEFAULT_050329_HPP
+# define DEFAULT_050329_HPP
+
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+// A wrapper for the default value passed by the user when resolving
+// the value of the parameter with the given Keyword
+template <class Keyword, class Value>
+struct default_
+{
+ default_(Value& x)
+ : value(x)
+ {}
+
+ Value& value;
+};
+
+//
+// lazy_default --
+//
+// A wrapper for the default value computation function passed by
+// the user when resolving the value of the parameter with the
+// given keyword
+//
+# if BOOST_WORKAROUND(__EDG_VERSION__, <= 300)
+// These compilers need a little extra help with overload
+// resolution; we have empty_arg_list's operator[] accept a base
+// class to make that overload less preferable.
+template <class KW, class DefaultComputer>
+struct lazy_default_base
+{
+ lazy_default_base(DefaultComputer const& x)
+ : compute_default(x)
+ {}
+ DefaultComputer const& compute_default;
+};
+
+template <class KW, class DefaultComputer>
+struct lazy_default
+ : lazy_default_base<KW,DefaultComputer>
+ {
+ lazy_default(DefaultComputer const & x)
+ : lazy_default_base<KW,DefaultComputer>(x)
+ {}
+ };
+# define BOOST_PARAMETER_lazy_default_fallback lazy_default_base
+# else
+template <class KW, class DefaultComputer>
+struct lazy_default
+{
+ lazy_default(const DefaultComputer& x)
+ : compute_default(x)
+ {}
+ DefaultComputer const& compute_default;
+};
+# define BOOST_PARAMETER_lazy_default_fallback lazy_default
+# endif
+
+}}} // namespace boost::parameter::aux
+
+#endif // DEFAULT_050329_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/is_maybe.hpp b/3rdParty/Boost/src/boost/parameter/aux_/is_maybe.hpp
new file mode 100644
index 0000000..b875852
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/is_maybe.hpp
@@ -0,0 +1,26 @@
+// Copyright Daniel Wallin, David Abrahams 2010. 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)
+
+#ifndef BOOST_PARAMETER_IS_MAYBE_050329_HPP
+#define BOOST_PARAMETER_IS_MAYBE_050329_HPP
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+namespace boost {
+namespace parameter {
+namespace aux {
+
+struct maybe_base {};
+
+template <class T>
+struct is_maybe
+ : is_base_and_derived<maybe_base, T>
+{};
+
+} // namespace aux
+} // namespace parameter
+} // namespace boost
+
+#endif // BOOST_PARAMETER_IS_MAYBE_050329_HPP
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/overloads.hpp b/3rdParty/Boost/src/boost/parameter/aux_/overloads.hpp
new file mode 100755
index 0000000..dcc92d4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/overloads.hpp
@@ -0,0 +1,88 @@
+// Copyright David Abrahams, Daniel Wallin 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)
+
+// This file generates overloads in this format:
+//
+// template<class A0, class A1>
+// typename mpl::apply_wrap1<
+// aux::make_arg_list<
+// PS0,A0
+// , aux::make_arg_list<
+// PS1,A1
+// , mpl::identity<aux::empty_arg_list>
+// >
+// >
+// , unnamed_list
+// >::type
+// operator()(A0 const& a0, A1 const& a1) const
+// {
+// typedef typename mpl::apply_wrap1<
+// aux::make_arg_list<
+// PS0,A0
+// , aux::make_arg_list<
+// PS1,A1
+// , mpl::identity<aux::empty_arg_list>
+// >
+// >
+// >::type arg_tuple;
+//
+// return arg_tuple(
+// a0
+// , a1
+// , aux::void_()
+// ...
+// );
+// }
+//
+
+#if !defined(BOOST_PP_IS_ITERATING)
+# error Boost.Parameters - do not include this file!
+#endif
+
+#define N BOOST_PP_ITERATION()
+
+#define BOOST_PARAMETER_open_list(z, n, text) \
+ aux::item< \
+ BOOST_PP_CAT(PS, n), BOOST_PP_CAT(A, n)
+
+#define BOOST_PARAMETER_close_list(z, n, text) >
+
+#define BOOST_PARAMETER_arg_list(n) \
+ aux::make_arg_list< \
+ BOOST_PP_ENUM(N, BOOST_PARAMETER_open_list, _) \
+ , void_ \
+ BOOST_PP_REPEAT(N, BOOST_PARAMETER_close_list, _) \
+ , deduced_list \
+ , aux::tag_keyword_arg \
+ >
+
+#define BOOST_PARAMETER_arg_pack_init(z, n, limit) \
+ BOOST_PP_CAT(a, BOOST_PP_SUB(limit,n))
+
+template<BOOST_PP_ENUM_PARAMS(N, class A)>
+typename mpl::first<
+ typename BOOST_PARAMETER_arg_list(N)::type
+>::type
+operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, & a)) const
+{
+ typedef typename BOOST_PARAMETER_arg_list(N)::type result;
+
+ typedef typename mpl::first<result>::type result_type;
+ typedef typename mpl::second<result>::type error;
+ error();
+
+ return result_type(
+ BOOST_PP_ENUM(N, BOOST_PARAMETER_arg_pack_init, BOOST_PP_DEC(N))
+ BOOST_PP_ENUM_TRAILING_PARAMS(
+ BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, N)
+ , aux::void_reference() BOOST_PP_INTERCEPT
+ ));
+}
+
+#undef BOOST_PARAMETER_arg_list
+#undef BOOST_PARAMETER_open_list
+#undef BOOST_PARAMETER_close_list
+#undef N
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/parameter_requirements.hpp b/3rdParty/Boost/src/boost/parameter/aux_/parameter_requirements.hpp
new file mode 100755
index 0000000..ad7a129
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/parameter_requirements.hpp
@@ -0,0 +1,25 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef PARAMETER_REQUIREMENTS_050331_HPP
+#define PARAMETER_REQUIREMENTS_050331_HPP
+
+namespace boost { namespace parameter { namespace aux {
+
+// Used to pass static information about parameter requirements
+// through the satisfies() overload set (below). The
+// matched function is never invoked, but its type indicates whether
+// a parameter matches at compile-time
+template <class Keyword, class Predicate, class HasDefault>
+struct parameter_requirements
+{
+ typedef Keyword keyword;
+ typedef Predicate predicate;
+ typedef HasDefault has_default;
+};
+
+}}} // namespace boost::parameter::aux
+
+#endif // PARAMETER_REQUIREMENTS_050331_HPP
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/parenthesized_type.hpp b/3rdParty/Boost/src/boost/parameter/aux_/parenthesized_type.hpp
new file mode 100755
index 0000000..c6ddd77
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/parenthesized_type.hpp
@@ -0,0 +1,119 @@
+// Copyright David Abrahams 2006. 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_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP
+# define BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP
+
+# include <boost/config.hpp>
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+// A macro that takes a parenthesized C++ type name (T) and transforms
+// it into an un-parenthesized type expression equivalent to T.
+# define BOOST_PARAMETER_PARENTHESIZED_TYPE(x) \
+ boost::parameter::aux::unaryfunptr_arg_type< void(*)x >::type
+
+// A metafunction that transforms void(*)(T) -> T
+template <class UnaryFunctionPointer>
+struct unaryfunptr_arg_type;
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+template <class Arg>
+struct unaryfunptr_arg_type<void(*)(Arg)>
+{
+ typedef Arg type;
+};
+
+# else
+
+// Use the "native typeof" bugfeatures of older versions of MSVC to
+// accomplish what we'd normally do with partial specialization. This
+// capability was discovered by Igor Chesnokov.
+
+# if BOOST_WORKAROUND(BOOST_MSVC, != 1300)
+
+// This version applies to VC6.5 and VC7.1 (except that we can just
+// use partial specialization for the latter in this case).
+
+// This gets used as a base class.
+template<typename Address>
+struct msvc_type_memory
+{
+ // A nullary metafunction that will yield the Value type "stored"
+ // at this Address.
+ struct storage;
+};
+
+template<typename Value, typename Address>
+struct msvc_store_type : msvc_type_memory<Address>
+{
+ // VC++ somehow lets us define the base's nested storage
+ // metafunction here, where we have the Value type we'd like to
+ // "store" in it. Later we can come back to the base class and
+ // extract the "stored type."
+ typedef msvc_type_memory<Address> location;
+ struct location::storage
+ {
+ typedef Value type;
+ };
+};
+
+# else
+
+// This slightly more complicated version of the same thing is
+// required for msvc-7.0
+template<typename Address>
+struct msvc_type_memory
+{
+ template<bool>
+ struct storage_impl;
+
+ typedef storage_impl<true> storage;
+};
+
+template<typename Value, typename Address>
+struct msvc_store_type : msvc_type_memory<Address>
+{
+ // Rather than supplying a definition for the base class' nested
+ // class, we specialize the base class' nested template
+ template<>
+ struct storage_impl<true>
+ {
+ typedef Value type;
+ };
+};
+
+# endif
+
+// Function template argument deduction does many of the same things
+// as type matching during partial specialization, so we call a
+// function template to "store" T into the type memory addressed by
+// void(*)(T).
+template <class T>
+msvc_store_type<T,void(*)(T)>
+msvc_store_argument_type(void(*)(T));
+
+template <class FunctionPointer>
+struct unaryfunptr_arg_type
+{
+ // We don't want the function to be evaluated, just instantiated,
+ // so protect it inside of sizeof.
+ enum { dummy = sizeof(msvc_store_argument_type((FunctionPointer)0)) };
+
+ // Now pull the type out of the instantiated base class
+ typedef typename msvc_type_memory<FunctionPointer>::storage::type type;
+};
+
+# endif
+
+template <>
+struct unaryfunptr_arg_type<void(*)(void)>
+{
+ typedef void type;
+};
+
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/preprocessor/flatten.hpp b/3rdParty/Boost/src/boost/parameter/aux_/preprocessor/flatten.hpp
new file mode 100755
index 0000000..5d7615e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/preprocessor/flatten.hpp
@@ -0,0 +1,115 @@
+// Copyright Daniel Wallin 2005. 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)
+
+#ifndef BOOST_PARAMETER_FLATTEN_051217_HPP
+# define BOOST_PARAMETER_FLATTEN_051217_HPP
+
+# include <boost/preprocessor/tuple/elem.hpp>
+# include <boost/preprocessor/tuple/rem.hpp>
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/seq/for_each.hpp>
+# include <boost/preprocessor/seq/for_each_i.hpp>
+# include <boost/preprocessor/identity.hpp>
+# include <boost/preprocessor/selection/max.hpp>
+# include <boost/preprocessor/arithmetic/sub.hpp>
+# include <boost/preprocessor/repetition/enum_trailing.hpp>
+# include <boost/parameter/aux_/preprocessor/for_each.hpp>
+
+# define BOOST_PARAMETER_FLATTEN_SPLIT_required required,
+# define BOOST_PARAMETER_FLATTEN_SPLIT_optional optional,
+# define BOOST_PARAMETER_FLATTEN_SPLIT_deduced deduced,
+
+# define BOOST_PARAMETER_FLATTEN_SPLIT(sub) \
+ BOOST_PP_CAT(BOOST_PARAMETER_FLATTEN_SPLIT_, sub)
+
+# define BOOST_PARAMETER_FLATTEN_QUALIFIER(sub) \
+ BOOST_PP_SPLIT(0, BOOST_PARAMETER_FLATTEN_SPLIT(sub))
+
+# define BOOST_PARAMETER_FLATTEN_ARGS(sub) \
+ BOOST_PP_SPLIT(1, BOOST_PARAMETER_FLATTEN_SPLIT(sub))
+
+# define BOOST_PARAMETER_FLATTEN_ARITY_optional(arities) \
+ BOOST_PP_TUPLE_ELEM(3,0,arities)
+
+# define BOOST_PARAMETER_FLATTEN_ARITY_required(arities) \
+ BOOST_PP_TUPLE_ELEM(3,1,arities)
+
+# define BOOST_PARAMETER_FLATTEN_SPEC0_DUMMY_ELEM(z, n, data) ~
+# define BOOST_PARAMETER_FLATTEN_SPEC0(r, n, elem, data) \
+ (( \
+ BOOST_PP_TUPLE_ELEM(3,2,data) \
+ , BOOST_PP_TUPLE_REM(BOOST_PP_TUPLE_ELEM(3,0,data)) elem \
+ BOOST_PP_ENUM_TRAILING( \
+ BOOST_PP_SUB( \
+ BOOST_PP_TUPLE_ELEM(3,1,data) \
+ , BOOST_PP_TUPLE_ELEM(3,0,data) \
+ ) \
+ , BOOST_PARAMETER_FLATTEN_SPEC0_DUMMY_ELEM \
+ , ~ \
+ ) \
+ ))
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_AUX(r, arity, max_arity, spec, transform) \
+ BOOST_PARAMETER_FOR_EACH_R( \
+ r \
+ , arity \
+ , BOOST_PARAMETER_FLATTEN_ARGS(spec) \
+ , (arity, max_arity, transform(BOOST_PARAMETER_FLATTEN_QUALIFIER(spec))) \
+ , BOOST_PARAMETER_FLATTEN_SPEC0 \
+ )
+
+# define BOOST_PARAMETER_FLATTEN_IDENTITY(x) x
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_optional(r, arities, spec) \
+ BOOST_PARAMETER_FLATTEN_SPEC_AUX( \
+ r \
+ , BOOST_PP_CAT( \
+ BOOST_PARAMETER_FLATTEN_ARITY_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
+ )(arities) \
+ , BOOST_PP_TUPLE_ELEM(3,2,arities) \
+ , spec \
+ , BOOST_PARAMETER_FLATTEN_IDENTITY \
+ )
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_required(r, arities, spec) \
+ BOOST_PARAMETER_FLATTEN_SPEC_optional(r, arities, spec)
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_AS_DEDUCED(x) BOOST_PP_CAT(deduced_,x)
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_deduced_M(r, arities, n, spec) \
+ BOOST_PARAMETER_FLATTEN_SPEC_AUX( \
+ r \
+ , BOOST_PP_CAT( \
+ BOOST_PARAMETER_FLATTEN_ARITY_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
+ )(arities) \
+ , BOOST_PP_TUPLE_ELEM(3,2,arities) \
+ , spec \
+ , BOOST_PARAMETER_FLATTEN_SPEC_AS_DEDUCED \
+ )
+
+# define BOOST_PARAMETER_FLATTEN_SPEC_deduced(r, arities, spec) \
+ BOOST_PP_SEQ_FOR_EACH_I_R( \
+ r \
+ , BOOST_PARAMETER_FLATTEN_SPEC_deduced_M \
+ , arities \
+ , BOOST_PARAMETER_FLATTEN_ARGS(spec) \
+ )
+
+# define BOOST_PARAMETER_FLATTEN_SPEC(r, arities, spec) \
+ BOOST_PP_CAT( \
+ BOOST_PARAMETER_FLATTEN_SPEC_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
+ )(r, arities, spec)
+
+# define BOOST_PARAMETER_FLATTEN(optional_arity, required_arity, wanted_arity, specs) \
+ BOOST_PP_SEQ_FOR_EACH( \
+ BOOST_PARAMETER_FLATTEN_SPEC \
+ , ( \
+ optional_arity, required_arity \
+ , wanted_arity \
+ ) \
+ , specs \
+ )
+
+#endif // BOOST_PARAMETER_FLATTEN_051217_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/preprocessor/for_each.hpp b/3rdParty/Boost/src/boost/parameter/aux_/preprocessor/for_each.hpp
new file mode 100755
index 0000000..0eb1f70
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/preprocessor/for_each.hpp
@@ -0,0 +1,103 @@
+// Copyright Daniel Wallin 2005. 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)
+
+#ifndef BOOST_PARAMETER_FOR_EACH_051217_HPP
+# define BOOST_PARAMETER_FOR_EACH_051217_HPP
+
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/detail/split.hpp>
+# include <boost/preprocessor/logical/not.hpp>
+# include <boost/preprocessor/facilities/is_empty.hpp>
+# include <boost/preprocessor/tuple/eat.hpp>
+# include <boost/preprocessor/arithmetic/inc.hpp>
+# include <boost/preprocessor/repeat.hpp>
+# include <boost/preprocessor/punctuation/comma_if.hpp>
+# include <boost/preprocessor/for.hpp>
+# include <boost/preprocessor/repetition/deduce_r.hpp>
+
+# define BOOST_PARAMETER_FOR_EACH_head_aux2(x,y) (x,y), ~
+# define BOOST_PARAMETER_FOR_EACH_head_aux3(x,y,z) (x,y,z), ~
+# define BOOST_PARAMETER_FOR_EACH_head_aux4(x,y,z,u) (x,y,z,u), ~
+# define BOOST_PARAMETER_FOR_EACH_head(n,x) \
+ BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_head_aux,n) x)
+
+# define BOOST_PARAMETER_FOR_EACH_pred_aux_BOOST_PARAMETER_FOR_EACH_END_SENTINEL
+# define BOOST_PARAMETER_FOR_EACH_pred_aux_check(x) \
+ BOOST_PP_NOT(BOOST_PP_IS_EMPTY( \
+ BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_pred_aux_, x) \
+ )), ~
+
+# define BOOST_PARAMETER_FOR_EACH_pred_aux2(x,y) \
+ BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
+# define BOOST_PARAMETER_FOR_EACH_pred_aux3(x,y,z) \
+ BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
+# define BOOST_PARAMETER_FOR_EACH_pred_aux4(x,y,z,u) \
+ BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
+
+# define BOOST_PARAMETER_FOR_EACH_pred_aux0(n,x) \
+ BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_pred_aux,n) x
+
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
+# define BOOST_PARAMETER_FOR_EACH_pred_SPLIT_FIRST(x) \
+ BOOST_PP_SPLIT(0, x)
+
+# define BOOST_PARAMETER_FOR_EACH_pred(r, state) \
+ BOOST_PARAMETER_FOR_EACH_pred_SPLIT_FIRST( \
+ BOOST_PARAMETER_FOR_EACH_pred_aux0( \
+ BOOST_PP_TUPLE_ELEM(5,3,state) \
+ , BOOST_PP_TUPLE_ELEM(5,0,state) \
+ ) \
+ )
+# else
+# define BOOST_PARAMETER_FOR_EACH_pred(r, state) \
+ BOOST_PP_SPLIT( \
+ 0 \
+ , BOOST_PARAMETER_FOR_EACH_pred_aux0( \
+ BOOST_PP_TUPLE_ELEM(5,3,state) \
+ , BOOST_PP_TUPLE_ELEM(5,0,state) \
+ ) \
+ )
+# endif
+
+# define BOOST_PARAMETER_FOR_EACH_op(r, state) \
+ ( \
+ BOOST_PP_TUPLE_EAT(BOOST_PP_TUPLE_ELEM(5,3,state)) \
+ BOOST_PP_TUPLE_ELEM(5,0,state) \
+ , BOOST_PP_TUPLE_ELEM(5,1,state) \
+ , BOOST_PP_TUPLE_ELEM(5,2,state) \
+ , BOOST_PP_TUPLE_ELEM(5,3,state) \
+ , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(5,4,state)) \
+ )
+
+# define BOOST_PARAMETER_FOR_EACH_macro(r, state) \
+ BOOST_PP_TUPLE_ELEM(5,2,state)( \
+ r \
+ , BOOST_PP_TUPLE_ELEM(5,4,state) \
+ , BOOST_PARAMETER_FOR_EACH_head( \
+ BOOST_PP_TUPLE_ELEM(5,3,state) \
+ , BOOST_PP_TUPLE_ELEM(5,0,state) \
+ ) \
+ , BOOST_PP_TUPLE_ELEM(5,1,state) \
+ )
+
+# define BOOST_PARAMETER_FOR_EACH_build_end_sentinel(z,n,text) \
+ BOOST_PP_COMMA_IF(n) BOOST_PARAMETER_FOR_EACH_END_SENTINEL
+# define BOOST_PARAMETER_FOR_EACH_build_end_sentinel_tuple(arity) \
+ ( \
+ BOOST_PP_REPEAT(arity, BOOST_PARAMETER_FOR_EACH_build_end_sentinel, _) \
+ )
+
+# define BOOST_PARAMETER_FOR_EACH_R(r, arity, list, data, macro) \
+ BOOST_PP_CAT(BOOST_PP_FOR_, r)( \
+ (list BOOST_PARAMETER_FOR_EACH_build_end_sentinel_tuple(arity), data, macro, arity, 0) \
+ , BOOST_PARAMETER_FOR_EACH_pred \
+ , BOOST_PARAMETER_FOR_EACH_op \
+ , BOOST_PARAMETER_FOR_EACH_macro \
+ )
+
+# define BOOST_PARAMETER_FOR_EACH(arity, list, data, macro) \
+ BOOST_PARAMETER_FOR_EACH_R(BOOST_PP_DEDUCE_R(), arity, list, data, macro)
+
+#endif // BOOST_PARAMETER_FOR_EACH_051217_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/result_of0.hpp b/3rdParty/Boost/src/boost/parameter/aux_/result_of0.hpp
new file mode 100755
index 0000000..e009614
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/result_of0.hpp
@@ -0,0 +1,36 @@
+// Copyright David Abrahams 2005. 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_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP
+# define BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP
+
+# include <boost/utility/result_of.hpp>
+
+// A metafunction returning the result of invoking a nullary function
+// object of the given type.
+
+#ifndef BOOST_NO_RESULT_OF
+
+# include <boost/utility/result_of.hpp>
+namespace boost { namespace parameter { namespace aux {
+template <class F>
+struct result_of0 : result_of<F()>
+{};
+
+}}} // namespace boost::parameter::aux_
+
+#else
+
+namespace boost { namespace parameter { namespace aux {
+template <class F>
+struct result_of0
+{
+ typedef typename F::result_type type;
+};
+
+}}} // namespace boost::parameter::aux_
+
+#endif
+
+
+#endif // BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/set.hpp b/3rdParty/Boost/src/boost/parameter/aux_/set.hpp
new file mode 100644
index 0000000..1c4ccf5
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/set.hpp
@@ -0,0 +1,67 @@
+// Copyright Daniel Wallin 2006. 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)
+
+#ifndef BOOST_PARAMETER_SET_060912_HPP
+# define BOOST_PARAMETER_SET_060912_HPP
+
+# include <boost/detail/workaround.hpp>
+
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
+ && !BOOST_WORKAROUND(__GNUC__, < 3)
+# include <boost/mpl/insert.hpp>
+# include <boost/mpl/set/set0.hpp>
+# include <boost/mpl/has_key.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+typedef mpl::set0<> set0;
+
+template <class Set, class K>
+struct insert_
+{
+ typedef typename mpl::insert<Set, K>::type type;
+};
+
+template <class Set, class K>
+struct has_key_
+{
+ typedef typename mpl::has_key<Set, K>::type type;
+};
+
+}}} // namespace boost::parameter::aux
+
+# else
+
+# include <boost/mpl/list.hpp>
+# include <boost/mpl/end.hpp>
+# include <boost/mpl/find.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/mpl/push_front.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+typedef mpl::list0<> set0;
+
+template <class Set, class K>
+struct insert_
+{
+ typedef typename mpl::push_front<Set, K>::type type;
+};
+
+template <class Set, class K>
+struct has_key_
+{
+ typedef typename mpl::find<Set, K>::type iter;
+ typedef mpl::not_<
+ is_same<iter, typename mpl::end<Set>::type>
+ > type;
+};
+
+}}} // namespace boost::parameter::aux
+
+# endif
+
+
+#endif // BOOST_PARAMETER_SET_060912_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/tag.hpp b/3rdParty/Boost/src/boost/parameter/aux_/tag.hpp
new file mode 100755
index 0000000..475efb9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/tag.hpp
@@ -0,0 +1,38 @@
+// Copyright David Abrahams 2005. 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_PARAMETER_AUX_TAG_DWA2005610_HPP
+# define BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP
+
+# include <boost/parameter/aux_/unwrap_cv_reference.hpp>
+# include <boost/parameter/aux_/tagged_argument.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+template <class Keyword, class ActualArg
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ , class = typename is_cv_reference_wrapper<ActualArg>::type
+#endif
+ >
+struct tag
+{
+ typedef tagged_argument<
+ Keyword
+ , typename unwrap_cv_reference<ActualArg>::type
+ > type;
+};
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <class Keyword, class ActualArg>
+struct tag<Keyword,ActualArg,mpl::false_>
+{
+ typedef tagged_argument<
+ Keyword
+ , ActualArg
+ > type;
+};
+#endif
+
+}}} // namespace boost::parameter::aux_
+
+#endif // BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp b/3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp
new file mode 100644
index 0000000..6248be2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp
@@ -0,0 +1,188 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
+# define BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
+
+# include <boost/parameter/aux_/void.hpp>
+# include <boost/parameter/aux_/arg_list.hpp>
+# include <boost/parameter/aux_/result_of0.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/apply_wrap.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_reference.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+struct empty_arg_list;
+struct arg_list_tag;
+
+struct tagged_argument_base {};
+
+// Holds a reference to an argument of type Arg associated with
+// keyword Keyword
+
+template <class Keyword, class Arg>
+struct tagged_argument : tagged_argument_base
+{
+ typedef Keyword key_type;
+ typedef Arg value_type;
+ typedef Arg& reference;
+
+ tagged_argument(reference x) : value(x) {}
+
+ // A metafunction class that, given a keyword and a default
+ // type, returns the appropriate result type for a keyword
+ // lookup given that default
+ struct binding
+ {
+ template <class KW, class Default, class Reference>
+ struct apply
+ {
+ typedef typename mpl::eval_if<
+ boost::is_same<KW, key_type>
+ , mpl::if_<Reference, reference, value_type>
+ , mpl::identity<Default>
+ >::type type;
+ };
+ };
+
+ // Comma operator to compose argument list without using parameters<>.
+ // Useful for argument lists with undetermined length.
+ template <class Keyword2, class Arg2>
+ arg_list<
+ tagged_argument<Keyword, Arg>
+ , arg_list<tagged_argument<Keyword2, Arg2> >
+ >
+ operator,(tagged_argument<Keyword2, Arg2> x) const
+ {
+ return arg_list<
+ tagged_argument<Keyword, Arg>
+ , arg_list<tagged_argument<Keyword2, Arg2> >
+ >(
+ *this
+ , arg_list<tagged_argument<Keyword2, Arg2> >(x, empty_arg_list())
+ );
+ }
+
+ reference operator[](keyword<Keyword> const&) const
+ {
+ return value;
+ }
+
+# if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ template <class KW, class Default>
+ Default& get_with_default(default_<KW,Default> const& x, int) const
+ {
+ return x.value;
+ }
+
+ template <class Default>
+ reference get_with_default(default_<key_type,Default> const&, long) const
+ {
+ return value;
+ }
+
+ template <class KW, class Default>
+ typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type
+ operator[](default_<KW,Default> const& x) const
+ {
+ return get_with_default(x, 0L);
+ }
+
+ template <class KW, class F>
+ typename result_of0<F>::type
+ get_with_lazy_default(lazy_default<KW,F> const& x, int) const
+ {
+ return x.compute_default();
+ }
+
+ template <class F>
+ reference get_with_lazy_default(lazy_default<key_type,F> const&, long) const
+ {
+ return value;
+ }
+
+ template <class KW, class F>
+ typename mpl::apply_wrap3<
+ binding,KW
+ , typename result_of0<F>::type
+ , mpl::true_
+ >::type
+ operator[](lazy_default<KW,F> const& x) const
+ {
+ return get_with_lazy_default(x, 0L);
+ }
+# else
+ template <class Default>
+ reference operator[](default_<key_type,Default> const& x) const
+ {
+ return value;
+ }
+
+ template <class F>
+ reference operator[](lazy_default<key_type,F> const& x) const
+ {
+ return value;
+ }
+
+ template <class KW, class Default>
+ Default& operator[](default_<KW,Default> const& x) const
+ {
+ return x.value;
+ }
+
+ template <class KW, class F>
+ typename result_of0<F>::type operator[](lazy_default<KW,F> const& x) const
+ {
+ return x.compute_default();
+ }
+
+ template <class ParameterRequirements>
+ static typename ParameterRequirements::has_default
+ satisfies(ParameterRequirements*);
+
+ template <class HasDefault, class Predicate>
+ static typename mpl::apply1<Predicate, value_type>::type
+ satisfies(
+ parameter_requirements<key_type,Predicate,HasDefault>*
+ );
+# endif
+
+ reference value;
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+ // warning suppression
+ private:
+ void operator=(tagged_argument const&);
+ public:
+# endif
+ // MPL sequence support
+ typedef tagged_argument type; // Convenience for users
+ typedef empty_arg_list tail_type; // For the benefit of iterators
+ typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+};
+
+// Defines a metafunction, is_tagged_argument, that identifies
+// tagged_argument specializations and their derived classes.
+template <class T>
+struct is_tagged_argument_aux
+ : is_convertible<T*,tagged_argument_base const*>
+{};
+
+template <class T>
+struct is_tagged_argument
+ : mpl::and_<
+ mpl::not_<is_reference<T> >
+ , is_tagged_argument_aux<T>
+ >
+{};
+
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/template_keyword.hpp b/3rdParty/Boost/src/boost/parameter/aux_/template_keyword.hpp
new file mode 100755
index 0000000..5a02f00
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/template_keyword.hpp
@@ -0,0 +1,47 @@
+// Copyright Daniel Wallin 2006. 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)
+
+#ifndef BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP
+# define BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP
+
+# include <boost/mpl/and.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_reference.hpp>
+
+namespace boost { namespace parameter {
+
+namespace aux
+{
+
+ struct template_keyword_tag {};
+
+ template <class T, class U>
+ struct is_pointer_convertible
+ : is_convertible<T*, U*>
+ {};
+
+ template <class T>
+ struct is_template_keyword
+ : mpl::and_<
+ mpl::not_<is_reference<T> >
+ , is_pointer_convertible<T, template_keyword_tag>
+ >
+ {};
+
+} // namespace aux
+
+template <class Tag, class T>
+struct template_keyword
+ : aux::template_keyword_tag
+{
+ typedef Tag key_type;
+ typedef T value_type;
+ typedef value_type reference;
+};
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/unwrap_cv_reference.hpp b/3rdParty/Boost/src/boost/parameter/aux_/unwrap_cv_reference.hpp
new file mode 100755
index 0000000..e7aa0c1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/unwrap_cv_reference.hpp
@@ -0,0 +1,97 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef UNWRAP_CV_REFERENCE_050328_HPP
+#define UNWRAP_CV_REFERENCE_050328_HPP
+
+#include <boost/parameter/aux_/yesno.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+namespace boost { template<class T> class reference_wrapper; }
+
+namespace boost { namespace parameter { namespace aux {
+
+//
+// reference_wrapper support -- because of the forwarding problem,
+// when passing arguments positionally by non-const reference, we
+// ask users of named parameter interfaces to use ref(x) to wrap
+// them.
+//
+
+// is_cv_reference_wrapper returns mpl::true_ if T is of type
+// reference_wrapper<U> cv
+template <class U>
+yes_tag is_cv_reference_wrapper_check(reference_wrapper<U> const volatile*);
+no_tag is_cv_reference_wrapper_check(...);
+
+template <class T>
+struct is_cv_reference_wrapper
+{
+ BOOST_STATIC_CONSTANT(
+ bool, value = (
+ sizeof(is_cv_reference_wrapper_check((T*)0)) == sizeof(yes_tag)
+ )
+ );
+
+ typedef mpl::bool_<
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ is_cv_reference_wrapper::
+#endif
+ value> type;
+};
+
+#if BOOST_WORKAROUND(MSVC, == 1200)
+template <>
+struct is_cv_reference_wrapper<int>
+ : mpl::false_ {};
+#endif
+
+// Needed for unwrap_cv_reference below. T might be const, so
+// eval_if might fail because of deriving from T const on EDG.
+template <class T>
+struct get_type
+{
+ typedef typename T::type type;
+};
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <class T, class is_reference_wrapper = typename is_cv_reference_wrapper<T>::type>
+struct unwrap_cv_reference
+{
+ typedef T type;
+};
+
+template <class T>
+struct unwrap_cv_reference<T const, mpl::false_>
+{
+ typedef T const type;
+};
+
+template <class T>
+struct unwrap_cv_reference<T, mpl::true_>
+ : T
+{};
+
+#else
+// Produces the unwrapped type to hold a reference to in named<>
+// Can't use boost::unwrap_reference<> here because it
+// doesn't handle the case where T = reference_wrapper<U> cv
+template <class T>
+struct unwrap_cv_reference
+{
+ typedef typename mpl::eval_if<
+ is_cv_reference_wrapper<T>
+ , get_type<T>
+ , mpl::identity<T>
+ >::type type;
+};
+#endif
+
+}}} // namespace boost::parameter::aux
+
+#endif // UNWRAP_CV_REFERENCE_050328_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/void.hpp b/3rdParty/Boost/src/boost/parameter/aux_/void.hpp
new file mode 100755
index 0000000..7061a7d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/void.hpp
@@ -0,0 +1,29 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef BOOST_PARAMETER_VOID_050329_HPP
+#define BOOST_PARAMETER_VOID_050329_HPP
+
+namespace boost { namespace parameter {
+
+// A placemarker for "no argument passed."
+// MAINTAINER NOTE: Do not make this into a metafunction
+struct void_ {};
+
+namespace aux
+{
+
+ inline void_& void_reference()
+ {
+ static void_ instance;
+ return instance;
+ }
+
+} // namespace aux
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_VOID_050329_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/yesno.hpp b/3rdParty/Boost/src/boost/parameter/aux_/yesno.hpp
new file mode 100755
index 0000000..13fa545
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/aux_/yesno.hpp
@@ -0,0 +1,26 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef YESNO_050328_HPP
+#define YESNO_050328_HPP
+
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+// types used with the "sizeof trick" to capture the results of
+// overload resolution at compile-time.
+typedef char yes_tag;
+typedef char (&no_tag)[2];
+
+// mpl::true_ and mpl::false_ are not distinguishable by sizeof(),
+// so we pass them through these functions to get a type that is.
+yes_tag to_yesno(mpl::true_);
+no_tag to_yesno(mpl::false_);
+
+}}} // namespace boost::parameter::aux
+
+#endif // YESNO_050328_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/binding.hpp b/3rdParty/Boost/src/boost/parameter/binding.hpp
new file mode 100755
index 0000000..632f0fd
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/binding.hpp
@@ -0,0 +1,106 @@
+// Copyright David Abrahams 2005. 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_PARAMETER_BINDING_DWA200558_HPP
+# define BOOST_PARAMETER_BINDING_DWA200558_HPP
+
+# include <boost/mpl/apply.hpp>
+# include <boost/mpl/assert.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/parameter/aux_/result_of0.hpp>
+# include <boost/parameter/aux_/void.hpp>
+# include <boost/type_traits/is_same.hpp>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# include <boost/mpl/eval_if.hpp>
+# endif
+
+namespace boost { namespace parameter {
+
+// A metafunction that, given an argument pack, returns the type of
+// the parameter identified by the given keyword. If no such
+// parameter has been specified, returns Default
+
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <class Parameters, class Keyword, class Default>
+struct binding0
+{
+ typedef typename mpl::apply_wrap3<
+ typename Parameters::binding,Keyword,Default,mpl::true_
+ >::type type;
+
+ BOOST_MPL_ASSERT_NOT((
+ mpl::and_<
+ is_same<Default, void_>
+ , is_same<type, void_>
+ >
+ ));
+};
+# endif
+
+template <class Parameters, class Keyword, class Default = void_>
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+struct binding
+# else
+struct binding_eti
+# endif
+{
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ typedef typename mpl::eval_if<
+ mpl::is_placeholder<Parameters>
+ , mpl::identity<int>
+ , binding0<Parameters,Keyword,Default>
+ >::type type;
+# else
+ typedef typename mpl::apply_wrap3<
+ typename Parameters::binding,Keyword,Default,mpl::true_
+ >::type type;
+
+ BOOST_MPL_ASSERT_NOT((
+ mpl::and_<
+ is_same<Default, void_>
+ , is_same<type, void_>
+ >
+ ));
+# endif
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
+# endif
+};
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+template <class Parameters, class Keyword, class Default = void_>
+struct binding
+{
+ typedef typename mpl::eval_if<
+ is_same<Parameters, int>
+ , mpl::identity<int>
+ , binding_eti<Parameters, Keyword, Default>
+ >::type type;
+
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
+};
+# endif
+
+// A metafunction that, given an argument pack, returns the type of
+// the parameter identified by the given keyword. If no such
+// parameter has been specified, returns the type returned by invoking
+// DefaultFn
+template <class Parameters, class Keyword, class DefaultFn>
+struct lazy_binding
+{
+ typedef typename mpl::apply_wrap3<
+ typename Parameters::binding
+ , Keyword
+ , typename aux::result_of0<DefaultFn>::type
+ , mpl::true_
+ >::type type;
+};
+
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_BINDING_DWA200558_HPP
diff --git a/3rdParty/Boost/src/boost/parameter/config.hpp b/3rdParty/Boost/src/boost/parameter/config.hpp
new file mode 100644
index 0000000..5710c92
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/config.hpp
@@ -0,0 +1,14 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef BOOST_PARAMETER_CONFIG_050403_HPP
+#define BOOST_PARAMETER_CONFIG_050403_HPP
+
+#ifndef BOOST_PARAMETER_MAX_ARITY
+# define BOOST_PARAMETER_MAX_ARITY 8
+#endif
+
+#endif // BOOST_PARAMETER_CONFIG_050403_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/keyword.hpp b/3rdParty/Boost/src/boost/parameter/keyword.hpp
new file mode 100755
index 0000000..cfb4bfd
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/keyword.hpp
@@ -0,0 +1,152 @@
+// Copyright Daniel Wallin, David Abrahams 2005. 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)
+
+#ifndef KEYWORD_050328_HPP
+#define KEYWORD_050328_HPP
+
+#include <boost/parameter/aux_/unwrap_cv_reference.hpp>
+#include <boost/parameter/aux_/tag.hpp>
+#include <boost/parameter/aux_/default.hpp>
+
+namespace boost { namespace parameter {
+
+// Instances of unique specializations of keyword<...> serve to
+// associate arguments with parameter names. For example:
+//
+// struct rate_; // parameter names
+// struct skew_;
+// namespace
+// {
+// keyword<rate_> rate; // keywords
+// keyword<skew_> skew;
+// }
+//
+// ...
+//
+// f(rate = 1, skew = 2.4);
+//
+template <class Tag>
+struct keyword
+{
+ template <class T>
+ typename aux::tag<Tag, T>::type const
+ operator=(T& x) const
+ {
+ typedef typename aux::tag<Tag, T>::type result;
+ return result(x);
+ }
+
+ template <class Default>
+ aux::default_<Tag, Default>
+ operator|(Default& default_) const
+ {
+ return aux::default_<Tag, Default>(default_);
+ }
+
+ template <class Default>
+ aux::lazy_default<Tag, Default>
+ operator||(Default& default_) const
+ {
+ return aux::lazy_default<Tag, Default>(default_);
+ }
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) // avoid partial ordering bugs
+ template <class T>
+ typename aux::tag<Tag, T const>::type const
+ operator=(T const& x) const
+ {
+ typedef typename aux::tag<Tag, T const>::type result;
+ return result(x);
+ }
+#endif
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) // avoid partial ordering bugs
+ template <class Default>
+ aux::default_<Tag, const Default>
+ operator|(const Default& default_) const
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+ volatile
+#endif
+ {
+ return aux::default_<Tag, const Default>(default_);
+ }
+
+ template <class Default>
+ aux::lazy_default<Tag, Default>
+ operator||(Default const& default_) const
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+ volatile
+#endif
+ {
+ return aux::lazy_default<Tag, Default>(default_);
+ }
+#endif
+
+ public: // Insurance against ODR violations
+
+ // People will need to define these keywords in header files. To
+ // prevent ODR violations, it's important that the keyword used in
+ // every instantiation of a function template is the same object.
+ // We provide a reference to a common instance of each keyword
+ // object and prevent construction by users.
+ static keyword<Tag> const instance;
+
+ // This interface is deprecated
+ static keyword<Tag>& get()
+ {
+ return const_cast<keyword<Tag>&>(instance);
+ }
+};
+
+template <class Tag>
+keyword<Tag> const keyword<Tag>::instance = {};
+
+// Reduces boilerplate required to declare and initialize keywords
+// without violating ODR. Declares a keyword tag type with the given
+// name in namespace tag_namespace, and declares and initializes a
+// reference in an anonymous namespace to a singleton instance of that
+// type.
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+# define BOOST_PARAMETER_KEYWORD(tag_namespace,name) \
+ namespace tag_namespace \
+ { \
+ struct name \
+ { \
+ static char const* keyword_name() \
+ { \
+ return #name; \
+ } \
+ }; \
+ } \
+ static ::boost::parameter::keyword<tag_namespace::name> const& name \
+ = ::boost::parameter::keyword<tag_namespace::name>::instance;
+
+#else
+
+#define BOOST_PARAMETER_KEYWORD(tag_namespace,name) \
+ namespace tag_namespace \
+ { \
+ struct name \
+ { \
+ static char const* keyword_name() \
+ { \
+ return #name; \
+ } \
+ }; \
+ } \
+ namespace \
+ { \
+ ::boost::parameter::keyword<tag_namespace::name> const& name \
+ = ::boost::parameter::keyword<tag_namespace::name>::instance;\
+ }
+
+#endif
+
+}} // namespace boost::parameter
+
+#endif // KEYWORD_050328_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/macros.hpp b/3rdParty/Boost/src/boost/parameter/macros.hpp
new file mode 100644
index 0000000..83fbfb5
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/macros.hpp
@@ -0,0 +1,99 @@
+// Copyright David Abrahams, Daniel Wallin 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)
+
+#ifndef BOOST_PARAMETER_MACROS_050412_HPP
+#define BOOST_PARAMETER_MACROS_050412_HPP
+
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/logical/bool.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/control/expr_if.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/detail/workaround.hpp>
+
+#define BOOST_PARAMETER_FUN_TEMPLATE_HEAD1(n) \
+ template<BOOST_PP_ENUM_PARAMS(n, class T)>
+
+#define BOOST_PARAMETER_FUN_TEMPLATE_HEAD0(n)
+
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+
+# define BOOST_PARAMETER_MATCH_TYPE(n, param) \
+ BOOST_PP_EXPR_IF(n, typename) param::match \
+ < \
+ BOOST_PP_ENUM_PARAMS(n, T) \
+ >::type
+
+#else
+
+# define BOOST_PARAMETER_MATCH_TYPE(n, param) param
+
+#endif
+
+#define BOOST_PARAMETER_FUN_DECL(z, n, params) \
+ \
+ BOOST_PP_CAT(BOOST_PARAMETER_FUN_TEMPLATE_HEAD, BOOST_PP_BOOL(n))(n) \
+ \
+ BOOST_PP_TUPLE_ELEM(3, 0, params) \
+ BOOST_PP_TUPLE_ELEM(3, 1, params)( \
+ BOOST_PP_ENUM_BINARY_PARAMS(n, T, const& p) \
+ BOOST_PP_COMMA_IF(n) \
+ BOOST_PARAMETER_MATCH_TYPE(n,BOOST_PP_TUPLE_ELEM(3, 2, params)) \
+ kw = BOOST_PP_TUPLE_ELEM(3, 2, params)() \
+ ) \
+ { \
+ return BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, params), _with_named_params)( \
+ kw(BOOST_PP_ENUM_PARAMS(n, p)) \
+ ); \
+ }
+
+// Generates:
+//
+// template<class Params>
+// ret name ## _with_named_params(Params const&);
+//
+// template<class T0>
+// ret name(T0 const& p0, typename parameters::match<T0>::type kw = parameters())
+// {
+// return name ## _with_named_params(kw(p0));
+// }
+//
+// template<class T0, ..., class TN>
+// ret name(T0 const& p0, ..., TN const& PN
+// , typename parameters::match<T0, ..., TN>::type kw = parameters())
+// {
+// return name ## _with_named_params(kw(p0, ..., pN));
+// }
+//
+// template<class Params>
+// ret name ## _with_named_params(Params const&)
+//
+// lo and hi determines the min and max arity of the generated functions.
+
+#define BOOST_PARAMETER_FUN(ret, name, lo, hi, parameters) \
+ \
+ template<class Params> \
+ ret BOOST_PP_CAT(name, _with_named_params)(Params const& p); \
+ \
+ BOOST_PP_REPEAT_FROM_TO( \
+ lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL, (ret, name, parameters)) \
+ \
+ template<class Params> \
+ ret BOOST_PP_CAT(name, _with_named_params)(Params const& p)
+
+#define BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters) \
+ \
+ BOOST_PP_REPEAT_FROM_TO( \
+ lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL, (ret, name, parameters)) \
+ \
+ template<class Params> \
+ ret BOOST_PP_CAT(name, _with_named_params)(Params const& p)
+
+#endif // BOOST_PARAMETER_MACROS_050412_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/match.hpp b/3rdParty/Boost/src/boost/parameter/match.hpp
new file mode 100755
index 0000000..2fa3f17
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/match.hpp
@@ -0,0 +1,55 @@
+// Copyright David Abrahams 2005. 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_PARAMETER_MATCH_DWA2005714_HPP
+# define BOOST_PARAMETER_MATCH_DWA2005714_HPP
+
+# include <boost/detail/workaround.hpp>
+# include <boost/preprocessor/seq/enum.hpp>
+
+# if BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
+// Temporary version of BOOST_PP_SEQ_ENUM until Paul M. integrates the workaround.
+# define BOOST_PARAMETER_SEQ_ENUM_I(size,seq) BOOST_PP_CAT(BOOST_PP_SEQ_ENUM_, size) seq
+# define BOOST_PARAMETER_SEQ_ENUM(seq) BOOST_PARAMETER_SEQ_ENUM_I(BOOST_PP_SEQ_SIZE(seq), seq)
+# else
+# define BOOST_PARAMETER_SEQ_ENUM(seq) BOOST_PP_SEQ_ENUM(seq)
+# endif
+
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+# include <boost/parameter/config.hpp>
+# include <boost/parameter/aux_/void.hpp>
+# include <boost/preprocessor/arithmetic/sub.hpp>
+# include <boost/preprocessor/facilities/intercept.hpp>
+# include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+
+# define BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes) \
+ BOOST_PP_ENUM_TRAILING_PARAMS( \
+ BOOST_PP_SUB( \
+ BOOST_PARAMETER_MAX_ARITY \
+ , BOOST_PP_SEQ_SIZE(ArgTypes) \
+ ) \
+ , ::boost::parameter::void_ BOOST_PP_INTERCEPT \
+ )
+
+# else
+
+# define BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes)
+
+# endif
+
+//
+// Generates, e.g.
+//
+// typename dfs_params::match<A1,A2>::type name = dfs_params()
+//
+// with workarounds for Borland compatibility.
+//
+
+# define BOOST_PARAMETER_MATCH(ParameterSpec, ArgTypes, name) \
+ typename ParameterSpec ::match< \
+ BOOST_PARAMETER_SEQ_ENUM(ArgTypes) \
+ BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes) \
+ >::type name = ParameterSpec ()
+
+#endif // BOOST_PARAMETER_MATCH_DWA2005714_HPP
diff --git a/3rdParty/Boost/src/boost/parameter/name.hpp b/3rdParty/Boost/src/boost/parameter/name.hpp
new file mode 100644
index 0000000..7352616
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/name.hpp
@@ -0,0 +1,156 @@
+// Copyright Daniel Wallin 2006. 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)
+
+#ifndef BOOST_PARAMETER_NAME_060806_HPP
+# define BOOST_PARAMETER_NAME_060806_HPP
+
+# include <boost/parameter/keyword.hpp>
+# include <boost/parameter/value_type.hpp>
+# include <boost/detail/workaround.hpp>
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/stringize.hpp>
+# include <boost/preprocessor/control/iif.hpp>
+# include <boost/preprocessor/tuple/eat.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
+# include <boost/mpl/placeholders.hpp>
+
+# if !defined(BOOST_NO_SFINAE) \
+ && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+ && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+
+# include <boost/utility/enable_if.hpp>
+# include <boost/mpl/lambda.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+// Tag type passed to MPL lambda.
+struct lambda_tag;
+
+struct name_tag_base
+{};
+
+template <class Tag>
+struct name_tag
+{};
+
+template <class T>
+struct is_name_tag
+ : mpl::false_
+{};
+
+}}} // namespace boost::parameter::aux
+
+namespace boost { namespace mpl {
+
+template <class T>
+struct lambda<
+ T
+ , typename boost::enable_if<
+ parameter::aux::is_name_tag<T>, parameter::aux::lambda_tag
+ >::type
+>
+{
+ typedef true_ is_le;
+ typedef bind3< quote3<parameter::value_type>, arg<2>, T, void> result_;
+ typedef result_ type;
+};
+
+}} // namespace boost::mpl
+
+# endif
+
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# include <boost/preprocessor/detail/split.hpp>
+// From Paul Mensonides
+# define BOOST_PARAMETER_IS_BINARY(x) \
+ BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_BINARY_C x BOOST_PP_COMMA() 0) \
+ /**/
+# define BOOST_PARAMETER_IS_BINARY_C(x,y) \
+ ~, 1 BOOST_PP_RPAREN() \
+ BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \
+ /**/
+# else
+# include <boost/preprocessor/detail/is_binary.hpp>
+# define BOOST_PARAMETER_IS_BINARY(x) BOOST_PP_IS_BINARY(x)
+# endif
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# define BOOST_PARAMETER_NAME_OBJECT(tag, name) \
+ static ::boost::parameter::keyword<tag> const& name \
+ = ::boost::parameter::keyword<tag>::instance;
+# else
+# define BOOST_PARAMETER_NAME_OBJECT(tag, name) \
+ namespace \
+ { \
+ ::boost::parameter::keyword<tag> const& name \
+ = ::boost::parameter::keyword<tag>::instance; \
+ }
+# endif
+
+# define BOOST_PARAMETER_BASIC_NAME(tag_namespace, tag, name) \
+ namespace tag_namespace \
+ { \
+ struct tag \
+ { \
+ static char const* keyword_name() \
+ { \
+ return BOOST_PP_STRINGIZE(tag); \
+ } \
+ \
+ typedef boost::parameter::value_type< \
+ boost::mpl::_2, tag, boost::parameter::void_ \
+ > _; \
+ \
+ typedef boost::parameter::value_type< \
+ boost::mpl::_2, tag, boost::parameter::void_ \
+ > _1; \
+ }; \
+ } \
+ BOOST_PARAMETER_NAME_OBJECT(tag_namespace::tag, name)
+
+# define BOOST_PARAMETER_COMPLEX_NAME_TUPLE1(tag,namespace) \
+ (tag, namespace), ~
+
+# define BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name) \
+ BOOST_PP_TUPLE_ELEM(2, 0, (BOOST_PARAMETER_COMPLEX_NAME_TUPLE1 name))
+
+# define BOOST_PARAMETER_COMPLEX_NAME_TAG(name) \
+ BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name))
+
+# define BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name) \
+ BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name))
+
+# define BOOST_PARAMETER_COMPLEX_NAME(name) \
+ BOOST_PARAMETER_BASIC_NAME( \
+ BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name) \
+ , BOOST_PP_TUPLE_EAT(2) name \
+ , BOOST_PARAMETER_COMPLEX_NAME_TAG(name) \
+ ) \
+/**/
+
+# define BOOST_PARAMETER_SIMPLE_NAME(name) \
+ BOOST_PARAMETER_BASIC_NAME(tag, name, BOOST_PP_CAT(_, name))
+
+# define BOOST_PARAMETER_NAME(name) \
+ BOOST_PP_IIF( \
+ BOOST_PARAMETER_IS_BINARY(name) \
+ , BOOST_PARAMETER_COMPLEX_NAME \
+ , BOOST_PARAMETER_SIMPLE_NAME \
+ )(name) \
+/**/
+
+
+# define BOOST_PARAMETER_TEMPLATE_KEYWORD(name) \
+ namespace tag \
+ { \
+ struct name; \
+ } \
+ template <class T> \
+ struct name \
+ : boost::parameter::template_keyword<tag::name, T> \
+ {}; \
+/**/
+
+#endif // BOOST_PARAMETER_NAME_060806_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/parameters.hpp b/3rdParty/Boost/src/boost/parameter/parameters.hpp
new file mode 100755
index 0000000..97e1024
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/parameters.hpp
@@ -0,0 +1,931 @@
+// Copyright David Abrahams, Daniel Wallin 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)
+
+#ifndef BOOST_PARAMETERS_031014_HPP
+#define BOOST_PARAMETERS_031014_HPP
+
+#include <boost/detail/is_xxx.hpp>
+
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/mpl/lambda.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/pair.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/enum_shifted.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/preprocessor/seq/elem.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+#include <boost/parameter/aux_/arg_list.hpp>
+#include <boost/parameter/aux_/yesno.hpp>
+#include <boost/parameter/aux_/void.hpp>
+#include <boost/parameter/aux_/default.hpp>
+#include <boost/parameter/aux_/unwrap_cv_reference.hpp>
+#include <boost/parameter/aux_/tagged_argument.hpp>
+#include <boost/parameter/aux_/tag.hpp>
+#include <boost/parameter/aux_/template_keyword.hpp>
+#include <boost/parameter/aux_/set.hpp>
+#include <boost/parameter/config.hpp>
+
+namespace parameter_
+{
+ template <class T>
+ struct unmatched_argument
+ {
+ BOOST_MPL_ASSERT((boost::is_same<T,void>));
+ typedef int type;
+ };
+} // namespace parameter_
+
+namespace boost {
+
+template<class T> class reference_wrapper;
+
+namespace parameter {
+
+namespace aux { struct use_default {}; }
+
+// These templates can be used to describe the treatment of particular
+// named parameters for the purposes of overload elimination with
+// SFINAE, by placing specializations in the parameters<...> list. In
+// order for a treated function to participate in overload resolution:
+//
+// - all keyword tags wrapped in required<...> must have a matching
+// actual argument
+//
+// - The actual argument type matched by every keyword tag
+// associated with a predicate must satisfy that predicate
+//
+// If a keyword k is specified without an optional<...> or
+// required<...>, wrapper, it is treated as though optional<k> were
+// specified.
+//
+// If a keyword k is specified with deduced<...>, that keyword
+// will be automatically deduced from the argument list.
+//
+template <class Tag, class Predicate = aux::use_default>
+struct required
+{
+ typedef Tag key_type;
+ typedef Predicate predicate;
+};
+
+template <class Tag, class Predicate = aux::use_default>
+struct optional
+{
+ typedef Tag key_type;
+ typedef Predicate predicate;
+};
+
+template <class Tag>
+struct deduced
+{
+ typedef Tag key_type;
+};
+
+namespace aux
+{
+ // Defines metafunctions, is_required and is_optional, that
+ // identify required<...>, optional<...> and deduced<...> specializations.
+ BOOST_DETAIL_IS_XXX_DEF(required, required, 2)
+ BOOST_DETAIL_IS_XXX_DEF(optional, optional, 2)
+ BOOST_DETAIL_IS_XXX_DEF(deduced_aux, deduced, 1)
+
+ template <class S>
+ struct is_deduced0
+ : is_deduced_aux<
+ typename S::key_type
+ >::type
+ {};
+
+ template <class S>
+ struct is_deduced
+ : mpl::eval_if<
+ mpl::or_<
+ is_optional<S>, is_required<S>
+ >
+ , is_deduced0<S>
+ , mpl::false_
+ >::type
+ {};
+
+ //
+ // key_type, has_default, and predicate --
+ //
+ // These metafunctions accept a ParameterSpec and extract the
+ // keyword tag, whether or not a default is supplied for the
+ // parameter, and the predicate that the corresponding actual
+ // argument type is required match.
+ //
+ // a ParameterSpec is a specialization of either keyword<...>,
+ // required<...>, optional<...>
+ //
+
+ // helper for key_type<...>, below.
+ template <class T>
+ struct get_tag_type0
+ {
+ typedef typename T::key_type type;
+ };
+
+ template <class T>
+ struct get_tag_type
+ : mpl::eval_if<
+ is_deduced_aux<typename T::key_type>
+ , get_tag_type0<typename T::key_type>
+ , mpl::identity<typename T::key_type>
+ >
+ {};
+
+ template <class T>
+ struct tag_type
+ : mpl::eval_if<
+ mpl::or_<
+ is_optional<T>
+ , is_required<T>
+ >
+ , get_tag_type<T>
+ , mpl::identity<T>
+ >
+ {};
+
+ template <class T>
+ struct has_default
+ : mpl::not_<is_required<T> >
+ {};
+
+ // helper for get_predicate<...>, below
+ template <class T>
+ struct get_predicate_or_default
+ {
+ typedef T type;
+ };
+
+ template <>
+ struct get_predicate_or_default<use_default>
+ {
+ typedef mpl::always<mpl::true_> type;
+ };
+
+ // helper for predicate<...>, below
+ template <class T>
+ struct get_predicate
+ {
+ typedef typename
+ get_predicate_or_default<typename T::predicate>::type
+ type;
+ };
+
+ template <class T>
+ struct predicate
+ : mpl::eval_if<
+ mpl::or_<
+ is_optional<T>
+ , is_required<T>
+ >
+ , get_predicate<T>
+ , mpl::identity<mpl::always<mpl::true_> >
+ >
+ {
+ };
+
+
+ // Converts a ParameterSpec into a specialization of
+ // parameter_requirements. We need to do this in order to get the
+ // tag_type into the type in a way that can be conveniently matched
+ // by a satisfies(...) member function in arg_list.
+ template <class ParameterSpec>
+ struct as_parameter_requirements
+ {
+ typedef parameter_requirements<
+ typename tag_type<ParameterSpec>::type
+ , typename predicate<ParameterSpec>::type
+ , typename has_default<ParameterSpec>::type
+ > type;
+ };
+
+ template <class T>
+ struct is_named_argument
+ : mpl::or_<
+ is_template_keyword<T>
+ , is_tagged_argument<T>
+ >
+ {};
+
+ // Returns mpl::true_ iff the given ParameterRequirements are
+ // satisfied by ArgList.
+ template <class ArgList, class ParameterRequirements>
+ struct satisfies
+ {
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+ // VC7.1 can't handle the sizeof() implementation below,
+ // so we use this instead.
+ typedef typename mpl::apply_wrap3<
+ typename ArgList::binding
+ , typename ParameterRequirements::keyword
+ , void_
+ , mpl::false_
+ >::type bound;
+
+ typedef typename mpl::eval_if<
+ is_same<bound, void_>
+ , typename ParameterRequirements::has_default
+ , mpl::apply_wrap2<
+ typename mpl::lambda<
+ typename ParameterRequirements::predicate, lambda_tag
+ >::type
+ , bound
+ , ArgList
+ >
+ >::type type;
+#else
+ BOOST_STATIC_CONSTANT(
+ bool, value = (
+ sizeof(
+ aux::to_yesno(
+ ArgList::satisfies((ParameterRequirements*)0, (ArgList*)0)
+ )
+ ) == sizeof(yes_tag)
+ )
+ );
+
+ typedef mpl::bool_<satisfies::value> type;
+#endif
+ };
+
+ // Returns mpl::true_ if the requirements of the given ParameterSpec
+ // are satisfied by ArgList.
+ template <class ArgList, class ParameterSpec>
+ struct satisfies_requirements_of
+ : satisfies<
+ ArgList
+ , typename as_parameter_requirements<ParameterSpec>::type
+ >
+ {};
+
+ // Tags a deduced argument Arg with the keyword tag of Spec using TagFn.
+ // Returns the tagged argument and the mpl::set<> UsedArgs with the
+ // tag of Spec inserted.
+ template <class UsedArgs, class Spec, class Arg, class TagFn>
+ struct tag_deduced
+ {
+ typedef mpl::pair<
+ typename mpl::apply_wrap2<TagFn, typename tag_type<Spec>::type, Arg>::type
+ , typename aux::insert_<UsedArgs, typename tag_type<Spec>::type>::type
+ > type;
+ };
+
+ template <
+ class Argument
+ , class ArgumentPack
+ , class DeducedArgs
+ , class UsedArgs
+ , class TagFn
+ >
+ struct deduce_tag;
+
+ // Tag type passed to MPL lambda.
+ struct lambda_tag;
+
+ // Helper for deduce_tag<> below.
+ template <
+ class Argument
+ , class ArgumentPack
+ , class DeducedArgs
+ , class UsedArgs
+ , class TagFn
+ >
+ struct deduce_tag0
+ {
+ typedef typename DeducedArgs::spec spec;
+
+ typedef typename mpl::apply_wrap2<
+ typename mpl::lambda<
+ typename spec::predicate, lambda_tag
+ >::type
+ , Argument
+ , ArgumentPack
+ >::type condition;
+
+ // Deduced parameter matches several arguments.
+
+ BOOST_MPL_ASSERT((
+ mpl::not_<mpl::and_<
+ condition
+ , aux::has_key_<UsedArgs, typename tag_type<spec>::type>
+ > >
+ ));
+
+ typedef typename mpl::eval_if<
+ condition
+ , tag_deduced<UsedArgs, spec, Argument, TagFn>
+ , deduce_tag<Argument, ArgumentPack, typename DeducedArgs::tail, UsedArgs, TagFn>
+ >::type type;
+ };
+
+ // Tries to deduced a keyword tag for a given Argument.
+ // Returns an mpl::pair<> consisting of the tagged_argument<>,
+ // and an mpl::set<> where the new tag has been inserted.
+ //
+ // Argument: The argument type to be tagged.
+ //
+ // ArgumentPack: The ArgumentPack built so far.
+ //
+ // DeducedArgs: A specialization of deduced_item<> (see below).
+ // A list containing only the deduced ParameterSpecs.
+ //
+ // UsedArgs: An mpl::set<> containing the keyword tags used so far.
+ //
+ // TagFn: A metafunction class used to tag positional or deduced
+ // arguments with a keyword tag.
+
+ template <
+ class Argument
+ , class ArgumentPack
+ , class DeducedArgs
+ , class UsedArgs
+ , class TagFn
+ >
+ struct deduce_tag
+ {
+ typedef typename mpl::eval_if<
+ is_same<DeducedArgs, void_>
+ , mpl::pair<void_, UsedArgs>
+ , deduce_tag0<Argument, ArgumentPack, DeducedArgs, UsedArgs, TagFn>
+ >::type type;
+ };
+
+ template <
+ class List
+ , class DeducedArgs
+ , class TagFn
+ , class Positional
+ , class UsedArgs
+ , class ArgumentPack
+ , class Error
+ >
+ struct make_arg_list_aux;
+
+ // Inserts Tagged::key_type into the UserArgs set.
+ // Extra indirection to lazily evaluate Tagged::key_type.
+ template <class UsedArgs, class Tagged>
+ struct insert_tagged
+ {
+ typedef typename aux::insert_<
+ UsedArgs, typename Tagged::key_type
+ >::type type;
+ };
+
+ // Borland needs the insane extra-indirection workaround below
+ // so that it doesn't magically drop the const qualifier from
+ // the argument type.
+
+ template <
+ class List
+ , class DeducedArgs
+ , class TagFn
+ , class Positional
+ , class UsedArgs
+ , class ArgumentPack
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ , class argument
+#endif
+ , class Error
+ >
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ struct make_arg_list00
+#else
+ struct make_arg_list0
+#endif
+ {
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ typedef typename List::arg argument;
+#endif
+ typedef typename List::spec parameter_spec;
+ typedef typename tag_type<parameter_spec>::type tag_;
+
+ typedef is_named_argument<argument> is_tagged;
+
+ // If this argument is either explicitly tagged or a deduced
+ // parameter, we turn off positional matching.
+ typedef mpl::and_<
+ mpl::not_<
+ mpl::or_<is_deduced<parameter_spec>, is_tagged>
+ >
+ , Positional
+ > positional;
+
+ // If this parameter is explicitly tagged we add it to the
+ // used-parmeters set. We only really need to add parameters
+ // that are deduced, but we would need a way to check if
+ // a given tag corresponds to a deduced parameter spec.
+ typedef typename mpl::eval_if<
+ is_tagged
+ , insert_tagged<UsedArgs, argument>
+ , mpl::identity<UsedArgs>
+ >::type used_args;
+
+ // If this parameter is neither explicitly tagged, nor
+ // positionally matched; deduce the tag from the deduced
+ // parameter specs.
+ typedef typename mpl::eval_if<
+ mpl::or_<is_tagged, positional>
+ , mpl::pair<void_, used_args>
+ , deduce_tag<argument, ArgumentPack, DeducedArgs, used_args, TagFn>
+ >::type deduced_data;
+
+ // If this parameter is explicitly tagged..
+ typedef typename mpl::eval_if<
+ is_tagged
+ , mpl::identity<argument> // .. just use it
+ , mpl::eval_if< // .. else, if positional matching is turned on..
+ positional
+ , mpl::apply_wrap2<TagFn, tag_, argument> // .. tag it positionally
+ , mpl::first<deduced_data> // .. else, use the deduced tag
+ >
+ >::type tagged;
+
+ // We build the arg_list incrementally as we go, prepending new
+ // nodes.
+
+ typedef typename mpl::if_<
+ mpl::and_<
+ is_same<Error, void_>
+ , is_same<tagged, void_>
+ >
+ , parameter_::unmatched_argument<argument>
+ , void_
+ >::type error;
+
+ typedef typename mpl::if_<
+ is_same<tagged, void_>
+ , ArgumentPack
+ , arg_list<tagged, ArgumentPack>
+ >::type argument_pack;
+
+ typedef typename make_arg_list_aux<
+ typename List::tail
+ , DeducedArgs
+ , TagFn
+ , positional
+ , typename deduced_data::second
+ , argument_pack
+ , error
+ >::type type;
+ };
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ template <
+ class List
+ , class DeducedArgs
+ , class TagFn
+ , class Positional
+ , class UsedArgs
+ , class ArgumentPack
+ , class Error
+ >
+ struct make_arg_list0
+ {
+ typedef typename mpl::eval_if<
+ typename List::is_arg_const
+ , make_arg_list00<
+ List
+ , DeducedArgs
+ , TagFn
+ , Positional
+ , UsedArgs
+ , ArgumentPack
+ , typename List::arg const
+ , Error
+ >
+ , make_arg_list00<
+ List
+ , DeducedArgs
+ , TagFn
+ , Positional
+ , UsedArgs
+ , ArgumentPack
+ , typename List::arg
+ , Error
+ >
+ >::type type;
+ };
+#endif
+
+ // Returns an ArgumentPack where the list of arguments has
+ // been tagged with keyword tags.
+ //
+ // List: A specialization of item<> (see below). Contains
+ // both the ordered ParameterSpecs, and the given arguments.
+ //
+ // DeducedArgs: A specialization of deduced_item<> (see below).
+ // A list containing only the deduced ParameterSpecs.
+ //
+ // TagFn: A metafunction class used to tag positional or deduced
+ // arguments with a keyword tag.
+ //
+ // Position: An mpl::bool_<> specialization indicating if positional
+ // matching is to be performed.
+ //
+ // DeducedSet: An mpl::set<> containing the keyword tags used so far.
+ //
+ // ArgumentPack: The ArgumentPack built so far. This is initially an
+ // empty_arg_list and is built incrementally.
+ //
+
+ template <
+ class List
+ , class DeducedArgs
+ , class TagFn
+ , class Positional
+ , class DeducedSet
+ , class ArgumentPack
+ , class Error
+ >
+ struct make_arg_list_aux
+ {
+ typedef typename mpl::eval_if<
+ is_same<List, void_>
+ , mpl::identity<mpl::pair<ArgumentPack, Error> >
+ , make_arg_list0<List, DeducedArgs, TagFn, Positional, DeducedSet, ArgumentPack, Error>
+ >::type type;
+ };
+
+ // VC6.5 was choking on the default parameters for make_arg_list_aux, so
+ // this just forwards to that adding in the defaults.
+ template <
+ class List
+ , class DeducedArgs
+ , class TagFn
+ , class EmitErrors = mpl::true_
+ >
+ struct make_arg_list
+ {
+ typedef typename make_arg_list_aux<
+ List, DeducedArgs, TagFn, mpl::true_, aux::set0, empty_arg_list, void_
+ >::type type;
+ };
+
+ // A parameter spec item typelist.
+ template <class Spec, class Arg, class Tail = void_>
+ struct item
+ {
+ typedef Spec spec;
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ typedef is_const<Arg> is_arg_const;
+#endif
+
+ typedef Arg arg;
+ typedef Tail tail;
+ };
+
+ template <class Spec, class Arg, class Tail>
+ struct make_item
+ {
+ typedef item<Spec, Arg, typename Tail::type> type;
+ };
+
+ // Creates a item typelist.
+ template <class Spec, class Arg, class Tail>
+ struct make_items
+ {
+ typedef typename mpl::eval_if<
+ is_same<Arg, void_>
+ , mpl::identity<void_>
+ , make_item<Spec, Arg, Tail>
+ >::type type;
+ };
+
+ // A typelist that stored deduced parameter specs.
+ template <class ParameterSpec, class Tail = void_>
+ struct deduced_item
+ {
+ typedef ParameterSpec spec;
+ typedef Tail tail;
+ };
+
+ // Evaluate Tail and construct deduced_item list.
+ template <class Spec, class Tail>
+ struct make_deduced_item
+ {
+ typedef deduced_item<Spec, typename Tail::type> type;
+ };
+
+ template <class Spec, class Tail>
+ struct make_deduced_items
+ {
+ typedef typename mpl::eval_if<
+ is_same<Spec, void_>
+ , mpl::identity<void_>
+ , mpl::eval_if<
+ is_deduced<Spec>
+ , make_deduced_item<Spec, Tail>
+ , Tail
+ >
+ >::type type;
+ };
+
+ // Generates:
+ //
+ // make<
+ // parameter_spec#0, argument_type#0
+ // , make<
+ // parameter_spec#1, argument_type#1
+ // , ... mpl::identity<aux::empty_arg_list>
+ // ...>
+ // >
+#define BOOST_PARAMETER_make_arg_list(z, n, names) \
+ BOOST_PP_SEQ_ELEM(0,names)< \
+ BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n), \
+ BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2,names), n),
+
+#define BOOST_PARAMETER_right_angle(z, n, text) >
+
+#define BOOST_PARAMETER_build_arg_list(n, make, parameter_spec, argument_type) \
+ BOOST_PP_REPEAT( \
+ n, BOOST_PARAMETER_make_arg_list, (make)(parameter_spec)(argument_type)) \
+ mpl::identity<void_> \
+ BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)
+
+#define BOOST_PARAMETER_make_deduced_list(z, n, names) \
+ BOOST_PP_SEQ_ELEM(0,names)< \
+ BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n),
+
+#define BOOST_PARAMETER_build_deduced_list(n, make, parameter_spec) \
+ BOOST_PP_REPEAT( \
+ n, BOOST_PARAMETER_make_deduced_list, (make)(parameter_spec)) \
+ mpl::identity<void_> \
+ BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)
+
+ struct tag_keyword_arg
+ {
+ template <class K, class T>
+ struct apply
+ : tag<K,T>
+ {};
+ };
+
+ struct tag_template_keyword_arg
+ {
+ template <class K, class T>
+ struct apply
+ {
+ typedef template_keyword<K,T> type;
+ };
+ };
+
+} // namespace aux
+
+#define BOOST_PARAMETER_FORWARD_TYPEDEF(z, i, names) \
+ typedef BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0,names),i) BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names),i);
+
+#define BOOST_PARAMETER_FORWARD_TYPEDEFS(n, src, dest) \
+ BOOST_PP_REPEAT(n, BOOST_PARAMETER_FORWARD_TYPEDEF, (src)(dest))
+
+
+#define BOOST_PARAMETER_TEMPLATE_ARGS(z, n, text) class BOOST_PP_CAT(PS, n) = void_
+
+template<
+ class PS0
+ , BOOST_PP_ENUM_SHIFTED(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_TEMPLATE_ARGS, _)
+>
+struct parameters
+{
+#undef BOOST_PARAMETER_TEMPLATE_ARGS
+
+ typedef typename BOOST_PARAMETER_build_deduced_list(
+ BOOST_PARAMETER_MAX_ARITY, aux::make_deduced_items, PS
+ )::type deduced_list;
+
+ // if the elements of NamedList match the criteria of overload
+ // resolution, returns a type which can be constructed from
+ // parameters. Otherwise, this is not a valid metafunction (no nested
+ // ::type).
+
+
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+ // If NamedList satisfies the PS0, PS1, ..., this is a
+ // metafunction returning parameters. Otherwise it
+ // has no nested ::type.
+ template <class ArgumentPackAndError>
+ struct match_base
+ : mpl::if_<
+ // mpl::and_<
+ // aux::satisfies_requirements_of<NamedList,PS0>
+ // , mpl::and_<
+ // aux::satisfies_requirements_of<NamedList,PS1>...
+ // ..., mpl::true_
+ // ...> >
+
+# define BOOST_PARAMETER_satisfies(z, n, text) \
+ mpl::and_< \
+ aux::satisfies_requirements_of< \
+ typename mpl::first<ArgumentPackAndError>::type \
+ , BOOST_PP_CAT(PS, n)> \
+ ,
+ mpl::and_<
+ is_same<typename mpl::second<ArgumentPackAndError>::type, void_>
+ , BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_satisfies, _)
+ mpl::true_
+ BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_right_angle, _)
+ >
+
+# undef BOOST_PARAMETER_satisfies
+
+ , mpl::identity<parameters>
+ , void_
+ >
+ {};
+#endif
+
+ // Specializations are to be used as an optional argument to
+ // eliminate overloads via SFINAE
+ template<
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ // Borland simply can't handle default arguments in member
+ // class templates. People wishing to write portable code can
+ // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments
+ BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
+#else
+ BOOST_PP_ENUM_BINARY_PARAMS(
+ BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT
+ )
+#endif
+ >
+ struct match
+# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+ : match_base<
+ typename aux::make_arg_list<
+ typename BOOST_PARAMETER_build_arg_list(
+ BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A
+ )::type
+ , deduced_list
+ , aux::tag_keyword_arg
+ , mpl::false_ // Don't emit errors when doing SFINAE
+ >::type
+ >::type
+ {};
+# else
+ {
+ typedef parameters<
+ BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS)
+ > type;
+ };
+# endif
+
+ // Metafunction that returns an ArgumentPack.
+
+ // TODO, bind has to instantiate the error type in the result
+ // of make_arg_list.
+
+ template <
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ // Borland simply can't handle default arguments in member
+ // class templates. People wishing to write portable code can
+ // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments
+ BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
+#else
+ BOOST_PP_ENUM_BINARY_PARAMS(
+ BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT
+ )
+#endif
+ >
+ struct bind
+ {
+ typedef typename aux::make_arg_list<
+ typename BOOST_PARAMETER_build_arg_list(
+ BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A
+ )::type
+ , deduced_list
+ , aux::tag_template_keyword_arg
+ >::type result;
+
+ typedef typename mpl::first<result>::type type;
+ };
+
+ BOOST_PARAMETER_FORWARD_TYPEDEFS(BOOST_PARAMETER_MAX_ARITY, PS, parameter_spec)
+
+ //
+ // The function call operator is used to build an arg_list that
+ // labels the positional parameters and maintains whatever other
+ // tags may have been specified by the caller.
+ //
+ // !!!NOTE!!!
+ //
+ // The make_arg_list<> produces a reversed arg_list, so
+ // we need to pass the arguments to its constructor
+ // reversed.
+ //
+ aux::empty_arg_list operator()() const
+ {
+ return aux::empty_arg_list();
+ }
+
+ template<class A0>
+ typename mpl::first<
+ typename aux::make_arg_list<
+ aux::item<
+ PS0,A0
+ >
+ , deduced_list
+ , aux::tag_keyword_arg
+ >::type
+ >::type
+ operator()(A0& a0) const
+ {
+ typedef typename aux::make_arg_list<
+ aux::item<
+ PS0,A0
+ >
+ , deduced_list
+ , aux::tag_keyword_arg
+ >::type result;
+
+ typedef typename mpl::first<result>::type result_type;
+ typedef typename mpl::second<result>::type error;
+ error();
+
+ return result_type(
+ a0
+ // , void_(), void_(), void_() ...
+ BOOST_PP_ENUM_TRAILING_PARAMS(
+ BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 1)
+ , aux::void_reference() BOOST_PP_INTERCEPT)
+ );
+ }
+
+ template<class A0, class A1>
+ typename mpl::first<
+ typename aux::make_arg_list<
+ aux::item<
+ PS0,A0
+ , aux::item<
+ PS1,A1
+ >
+ >
+ , deduced_list
+ , aux::tag_keyword_arg
+ >::type
+ >::type
+ operator()(A0& a0, A1& a1) const
+ {
+ typedef typename aux::make_arg_list<
+ aux::item<
+ PS0,A0
+ , aux::item<
+ PS1,A1
+ >
+ >
+ , deduced_list
+ , aux::tag_keyword_arg
+ >::type result;
+
+ typedef typename mpl::first<result>::type result_type;
+ typedef typename mpl::second<result>::type error;
+ error();
+
+ return result_type(
+ a1,a0
+ // , void_(), void_() ...
+ BOOST_PP_ENUM_TRAILING_PARAMS(
+ BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 2)
+ , aux::void_reference() BOOST_PP_INTERCEPT)
+ );
+ }
+
+ // Higher arities are handled by the preprocessor
+#define BOOST_PP_ITERATION_PARAMS_1 (3,( \
+ 3,BOOST_PARAMETER_MAX_ARITY,<boost/parameter/aux_/overloads.hpp> \
+ ))
+#include BOOST_PP_ITERATE()
+
+};
+
+} // namespace parameter
+
+} // namespace boost
+
+#endif // BOOST_PARAMETERS_031014_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/preprocessor.hpp b/3rdParty/Boost/src/boost/parameter/preprocessor.hpp
new file mode 100644
index 0000000..f1bda87
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/preprocessor.hpp
@@ -0,0 +1,1178 @@
+// Copyright Daniel Wallin 2006. 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)
+
+#ifndef BOOST_PARAMETER_PREPROCESSOR_060206_HPP
+# define BOOST_PARAMETER_PREPROCESSOR_060206_HPP
+
+# include <boost/parameter/parameters.hpp>
+# include <boost/parameter/binding.hpp>
+# include <boost/parameter/match.hpp>
+
+# include <boost/parameter/aux_/parenthesized_type.hpp>
+# include <boost/parameter/aux_/cast.hpp>
+# include <boost/parameter/aux_/preprocessor/flatten.hpp>
+
+# include <boost/preprocessor/repetition/repeat_from_to.hpp>
+# include <boost/preprocessor/comparison/equal.hpp>
+# include <boost/preprocessor/control/if.hpp>
+# include <boost/preprocessor/control/iif.hpp>
+# include <boost/preprocessor/control/expr_if.hpp>
+# include <boost/preprocessor/repetition/enum_params.hpp>
+# include <boost/preprocessor/repetition/enum_binary_params.hpp>
+# include <boost/preprocessor/repetition/enum_trailing.hpp>
+# include <boost/preprocessor/seq/first_n.hpp>
+# include <boost/preprocessor/seq/for_each_product.hpp>
+# include <boost/preprocessor/seq/for_each_i.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
+# include <boost/preprocessor/tuple/eat.hpp>
+# include <boost/preprocessor/seq/fold_left.hpp>
+# include <boost/preprocessor/seq/push_back.hpp>
+# include <boost/preprocessor/seq/size.hpp>
+# include <boost/preprocessor/seq/enum.hpp>
+# include <boost/preprocessor/seq/push_back.hpp>
+
+# include <boost/preprocessor/detail/is_nullary.hpp>
+
+# include <boost/mpl/always.hpp>
+# include <boost/mpl/apply_wrap.hpp>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+# include <boost/type.hpp>
+# endif
+
+namespace boost { namespace parameter { namespace aux {
+
+# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+
+// Given Match, which is "void x" where x is an argument matching
+// criterion, extract a corresponding MPL predicate.
+template <class Match>
+struct unwrap_predicate;
+
+// Match anything
+template <>
+struct unwrap_predicate<void*>
+{
+ typedef mpl::always<mpl::true_> type;
+};
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
+
+typedef void* voidstar;
+
+// A matching predicate is explicitly specified
+template <class Predicate>
+struct unwrap_predicate<voidstar (Predicate)>
+{
+ typedef Predicate type;
+};
+
+#else
+
+// A matching predicate is explicitly specified
+template <class Predicate>
+struct unwrap_predicate<void *(Predicate)>
+{
+ typedef Predicate type;
+};
+
+#endif
+
+
+// A type to which the argument is supposed to be convertible is
+// specified
+template <class Target>
+struct unwrap_predicate<void (Target)>
+{
+ typedef is_convertible<mpl::_, Target> type;
+};
+
+// Recast the ParameterSpec's nested match metafunction as a free metafunction
+template <
+ class Parameters
+ , BOOST_PP_ENUM_BINARY_PARAMS(
+ BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT
+ )
+>
+struct match
+ : Parameters::template match<
+ BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, A)
+ >
+{};
+# endif
+
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+
+// Function template argument deduction does many of the same things
+// as type matching during partial specialization, so we call a
+// function template to "store" T into the type memory addressed by
+// void(*)(T).
+template <class T>
+msvc_store_type<T,void*(*)(void**(T))>
+msvc_store_predicate_type(void*(*)(void**(T)));
+
+template <class T>
+msvc_store_type<boost::is_convertible<mpl::_,T>,void*(*)(void*(T))>
+msvc_store_predicate_type(void*(*)(void*(T)));
+
+template <class FunctionType>
+struct unwrap_predicate
+{
+ static FunctionType f;
+
+ // We don't want the function to be evaluated, just instantiated,
+ // so protect it inside of sizeof.
+ enum { dummy = sizeof(msvc_store_predicate_type(f)) };
+
+ // Now pull the type out of the instantiated base class
+ typedef typename msvc_type_memory<FunctionType>::storage::type type;
+};
+
+template <>
+struct unwrap_predicate<void*(*)(void**)>
+{
+ typedef mpl::always<mpl::true_> type;
+};
+
+# endif
+
+# undef false_
+
+template <
+ class Parameters
+ , BOOST_PP_ENUM_BINARY_PARAMS(
+ BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT
+ )
+>
+struct argument_pack
+{
+ typedef typename make_arg_list<
+ typename BOOST_PARAMETER_build_arg_list(
+ BOOST_PARAMETER_MAX_ARITY, make_items, typename Parameters::parameter_spec, A
+ )::type
+ , typename Parameters::deduced_list
+ , tag_keyword_arg
+ , mpl::false_
+ >::type result;
+ typedef typename mpl::first<result>::type type;
+};
+
+# if 1 //BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+// Works around VC6 problem where it won't accept rvalues.
+template <class T>
+T& as_lvalue(T& value, long)
+{
+ return value;
+}
+
+template <class T>
+T const& as_lvalue(T const& value, int)
+{
+ return value;
+}
+# endif
+
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+template <class Predicate, class T, class Args>
+struct apply_predicate
+{
+ BOOST_MPL_ASSERT((
+ mpl::and_<mpl::false_,T>
+ ));
+
+ typedef typename mpl::if_<
+ typename mpl::apply2<Predicate,T,Args>::type
+ , char
+ , int
+ >::type type;
+};
+
+template <class P>
+struct funptr_predicate
+{
+ static P p;
+
+ template <class T, class Args, class P0>
+ static typename apply_predicate<P0,T,Args>::type
+ check_predicate(type<T>, Args*, void**(*)(P0));
+
+ template <class T, class Args, class P0>
+ static typename mpl::if_<
+ is_convertible<T,P0>
+ , char
+ , int
+ >::type check_predicate(type<T>, Args*, void*(*)(P0));
+
+ template <class T, class Args>
+ struct apply
+ {
+ BOOST_STATIC_CONSTANT(bool, result =
+ sizeof(check_predicate(boost::type<T>(), (Args*)0, &p)) == 1
+ );
+
+ typedef mpl::bool_<apply<T,Args>::result> type;
+ };
+};
+
+template <>
+struct funptr_predicate<void**>
+ : mpl::always<mpl::true_>
+{};
+
+# endif
+
+}}} // namespace boost::parameter::aux
+
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+// From Paul Mensonides
+# define BOOST_PARAMETER_IS_NULLARY(x) \
+ BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_NULLARY_C x BOOST_PP_COMMA() 0) \
+ /**/
+# define BOOST_PARAMETER_IS_NULLARY_C() \
+ ~, 1 BOOST_PP_RPAREN() \
+ BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \
+ /**/
+# else
+# define BOOST_PARAMETER_IS_NULLARY(x) BOOST_PP_IS_NULLARY(x)
+# endif
+
+# define BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_static ()
+# define BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \
+ BOOST_PARAMETER_IS_NULLARY( \
+ BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_,name) \
+ )
+
+# if !defined(BOOST_MSVC)
+# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static
+# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \
+ BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name)
+# else
+// Workaround for MSVC preprocessor.
+//
+// When stripping static from "static f", msvc will produce
+// " f". The leading whitespace doesn't go away when pasting
+// the token with something else, so this thing is a hack to
+// strip the whitespace.
+# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static (
+# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \
+ BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name))
+# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \
+ BOOST_PP_SEQ_HEAD( \
+ BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \
+ )
+# endif
+
+# define BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
+ BOOST_PP_EXPR_IF( \
+ BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \
+ , static \
+ )
+
+# define BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name) \
+ BOOST_PP_IF( \
+ BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \
+ , BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC \
+ , name BOOST_PP_TUPLE_EAT(1) \
+ )(name)
+
+// Calculates [begin, end) arity range.
+
+# define BOOST_PARAMETER_ARITY_RANGE_M_optional(state) state
+# define BOOST_PARAMETER_ARITY_RANGE_M_deduced_optional(state) state
+# define BOOST_PARAMETER_ARITY_RANGE_M_required(state) BOOST_PP_INC(state)
+# define BOOST_PARAMETER_ARITY_RANGE_M_deduced_required(state) BOOST_PP_INC(state)
+
+# define BOOST_PARAMETER_ARITY_RANGE_M(s, state, x) \
+ BOOST_PP_CAT( \
+ BOOST_PARAMETER_ARITY_RANGE_M_ \
+ , BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \
+ )(state)
+/**/
+
+# define BOOST_PARAMETER_ARITY_RANGE(args) \
+ ( \
+ BOOST_PP_SEQ_FOLD_LEFT(BOOST_PARAMETER_ARITY_RANGE_M, 0, args) \
+ , BOOST_PP_INC(BOOST_PP_SEQ_SIZE(args)) \
+ )
+/**/
+
+// Accessor macros for the argument specs tuple.
+# define BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \
+ BOOST_PP_TUPLE_ELEM(4,0,x)
+/**/
+
+# define BOOST_PARAMETER_FN_ARG_NAME(x) \
+ BOOST_PP_TUPLE_ELEM(4,1,x)
+/**/
+
+# define BOOST_PARAMETER_FN_ARG_PRED(x) \
+ BOOST_PP_TUPLE_ELEM(4,2,x)
+/**/
+
+# define BOOST_PARAMETER_FN_ARG_DEFAULT(x) \
+ BOOST_PP_TUPLE_ELEM(4,3,x)
+/**/
+
+# define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_out(x)
+# define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_in_out(x)
+
+// Returns 1 if x is either "out(k)" or "in_out(k)".
+# define BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \
+ BOOST_PP_IS_EMPTY( \
+ BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_, x) \
+ ) \
+/**/
+
+# define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_out(x) x
+# define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_in_out(x) x
+# define BOOST_PARAMETER_FUNCTION_KEYWORD_GET(x) \
+ BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_, x)
+/**/
+
+// Returns the keyword of x, where x is either a keyword qualifier
+// or a keyword.
+//
+// k => k
+// out(k) => k
+// in_out(k) => k
+//
+# define BOOST_PARAMETER_FUNCTION_KEYWORD(x) \
+ BOOST_PP_IF( \
+ BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \
+ , BOOST_PARAMETER_FUNCTION_KEYWORD_GET \
+ , x BOOST_PP_TUPLE_EAT(1) \
+ )(x)
+/**/
+
+# define BOOST_PARAMETER_FN_ARG_KEYWORD(x) \
+ BOOST_PARAMETER_FUNCTION_KEYWORD( \
+ BOOST_PARAMETER_FN_ARG_NAME(x) \
+ )
+
+// Builds forwarding functions.
+
+# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z(z, n) \
+ template<BOOST_PP_ENUM_PARAMS_Z(z, n, class ParameterArgumentType)>
+/**/
+
+# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+# define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) \
+ , typename boost::parameter::aux::match< \
+ parameters, BOOST_PP_ENUM_PARAMS(n, ParameterArgumentType) \
+ >::type = parameters()
+# else
+# define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n)
+# endif
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(base) \
+ BOOST_PP_CAT( \
+ boost_param_parameters_ \
+ , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \
+ )
+
+// Produce a name for a result type metafunction for the function
+// named base
+# define BOOST_PARAMETER_FUNCTION_RESULT_NAME(base) \
+ BOOST_PP_CAT( \
+ boost_param_result_ \
+ , BOOST_PP_CAT(__LINE__,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \
+ )
+
+// Can't do boost_param_impl_ ## basee because base might start with an underscore
+// daniel: what? how is that relevant? the reason for using CAT() is to make sure
+// base is expanded. i'm not sure we need to here, but it's more stable to do it.
+# define BOOST_PARAMETER_IMPL(base) \
+ BOOST_PP_CAT(boost_param_impl,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base))
+
+# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00(z, n, r, data, elem) \
+ BOOST_PP_IF( \
+ n \
+ , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \
+ )(z,n) \
+ BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(7,3,data)) \
+ inline \
+ BOOST_PP_EXPR_IF(n, typename) \
+ BOOST_PARAMETER_FUNCTION_RESULT_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))< \
+ BOOST_PP_EXPR_IF(n, typename) \
+ boost::parameter::aux::argument_pack< \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \
+ BOOST_PP_COMMA_IF(n) \
+ BOOST_PP_IF( \
+ n, BOOST_PP_SEQ_ENUM, BOOST_PP_TUPLE_EAT(1) \
+ )(elem) \
+ >::type \
+ >::type \
+ BOOST_PARAMETER_MEMBER_FUNCTION_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))( \
+ BOOST_PP_IF( \
+ n \
+ , BOOST_PP_SEQ_FOR_EACH_I_R \
+ , BOOST_PP_TUPLE_EAT(4) \
+ )( \
+ r \
+ , BOOST_PARAMETER_FUNCTION_ARGUMENT \
+ , ~ \
+ , elem \
+ ) \
+ BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \
+ z \
+ , BOOST_PP_TUPLE_ELEM(7,3,data) \
+ , BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \
+ , n \
+ ) \
+ ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(7,4,data), const) \
+ { \
+ return BOOST_PARAMETER_IMPL(BOOST_PP_TUPLE_ELEM(7,3,data))( \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))()( \
+ BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
+ ) \
+ ); \
+ }
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0(r, data, elem) \
+ BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \
+ BOOST_PP_TUPLE_ELEM(7,0,data) \
+ , BOOST_PP_TUPLE_ELEM(7,1,data) \
+ , r \
+ , data \
+ , elem \
+ )
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0(z, n, data) \
+ BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \
+ z, n, BOOST_PP_DEDUCE_R() \
+ , (z, n, BOOST_PP_TUPLE_REM(5) data) \
+ , ~ \
+ )
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N(z, n, data) \
+ BOOST_PP_SEQ_FOR_EACH( \
+ BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0 \
+ , (z, n, BOOST_PP_TUPLE_REM(5) data) \
+ , BOOST_PP_SEQ_FOR_EACH_PRODUCT( \
+ BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \
+ , BOOST_PP_SEQ_FIRST_N( \
+ n, BOOST_PP_TUPLE_ELEM(5,3,data) \
+ ) \
+ ) \
+ )
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION(z, n, data) \
+ BOOST_PP_IF( \
+ n \
+ , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N \
+ , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0 \
+ )(z,n,data) \
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \
+ result,name,args,const_,combinations,range \
+) \
+ BOOST_PP_REPEAT_FROM_TO( \
+ BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \
+ , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION \
+ , (result,name,const_,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \
+ )
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(result,name,args, const_, combinations) \
+ BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \
+ result, name, args, const_, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \
+ )
+/**/
+
+// Builds boost::parameter::parameters<> specialization
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_optional(tag) \
+ optional<tag
+
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_required(tag) \
+ required<tag
+
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_optional(tag) \
+ optional<boost::parameter::deduced<tag>
+
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_required(tag) \
+ required<boost::parameter::deduced<tag>
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+# define BOOST_PARAMETER_PREDICATE_TYPE(p) void*(*) (void* p)
+# else
+# define BOOST_PARAMETER_PREDICATE_TYPE(p) void p
+# endif
+
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
+ BOOST_PP_COMMA_IF(i) \
+ boost::parameter::BOOST_PP_CAT( \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \
+ , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \
+ )( \
+ tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \
+ BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \
+ ) \
+ ) \
+ , typename boost::parameter::aux::unwrap_predicate< \
+ BOOST_PARAMETER_PREDICATE_TYPE(BOOST_PARAMETER_FN_ARG_PRED(elem)) \
+ >::type \
+ >
+# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
+ BOOST_PP_COMMA_IF(i) \
+ boost::parameter::BOOST_PP_CAT( \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \
+ , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \
+ )( \
+ tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \
+ BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \
+ ) \
+ ) \
+ , boost::parameter::aux::funptr_predicate< \
+ void* BOOST_PARAMETER_FN_ARG_PRED(elem) \
+ > \
+ >
+# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
+ BOOST_PP_COMMA_IF(i) \
+ boost::parameter::BOOST_PP_CAT( \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \
+ , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \
+ )( \
+ tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \
+ BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \
+ ) \
+ ) \
+ , boost::mpl::always<boost::mpl::true_> \
+ >
+# endif
+
+# define BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, base, args) \
+ template <class BoostParameterDummy> \
+ struct BOOST_PP_CAT( \
+ BOOST_PP_CAT(boost_param_params_, __LINE__) \
+ , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \
+ ) : boost::parameter::parameters< \
+ BOOST_PP_SEQ_FOR_EACH_I( \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS_M, tag_namespace, args \
+ ) \
+ > \
+ {}; \
+ \
+ typedef BOOST_PP_CAT( \
+ BOOST_PP_CAT(boost_param_params_, __LINE__) \
+ , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \
+ )<int>
+
+// Defines result type metafunction
+# define BOOST_PARAMETER_FUNCTION_RESULT_ARG(z, _, i, x) \
+ BOOST_PP_COMMA_IF(i) class BOOST_PP_TUPLE_ELEM(3,1,x)
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \
+ template <class Args> \
+ struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name) \
+ { \
+ typedef typename BOOST_PARAMETER_PARENTHESIZED_TYPE(result) type; \
+ };
+
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+# define BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \
+ BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \
+ template <> \
+ struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<int> \
+ { typedef int type; };
+
+# else
+
+# define BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \
+ BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)
+
+# endif
+
+// Defines implementation function
+# define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) \
+ template <class Args> \
+ typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)< \
+ Args \
+ >::type BOOST_PARAMETER_IMPL(name)(Args const& args)
+
+# define BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \
+ BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name);
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg) \
+ ( \
+ BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 0, state)) \
+ , BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 1, state), arg) \
+ , BOOST_PP_TUPLE_ELEM(4, 2, state) \
+ , BOOST_PP_TUPLE_ELEM(4, 3, state) \
+ )
+
+# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_required(state, arg) \
+ BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg)
+
+# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg) \
+ ( \
+ BOOST_PP_TUPLE_ELEM(4, 0, state) \
+ , BOOST_PP_TUPLE_ELEM(4, 1, state) \
+ , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, state)) \
+ , BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 3, state), arg) \
+ )
+
+# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_optional(state, arg) \
+ BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg)
+
+# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG(s, state, arg) \
+ BOOST_PP_CAT( \
+ BOOST_PARAMETER_FUNCTION_SPLIT_ARG_ \
+ , BOOST_PARAMETER_FN_ARG_QUALIFIER(arg) \
+ )(state, arg)
+
+// Returns (required_count, required, optional_count, optionals) tuple
+# define BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args) \
+ BOOST_PP_SEQ_FOLD_LEFT( \
+ BOOST_PARAMETER_FUNCTION_SPLIT_ARG \
+ , (0,BOOST_PP_SEQ_NIL, 0,BOOST_PP_SEQ_NIL) \
+ , args \
+ )
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME(keyword) \
+ BOOST_PP_CAT(BOOST_PP_CAT(keyword,_),type)
+
+// Helpers used as parameters to BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS.
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG(r, _, arg) \
+ , class BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \
+ BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
+ )
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG(r, _, arg) \
+ , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \
+ BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
+ )& BOOST_PARAMETER_FN_ARG_KEYWORD(arg)
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER(r, _, arg) \
+ , BOOST_PARAMETER_FN_ARG_KEYWORD(arg)
+
+// Produces a name for the dispatch functions.
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name) \
+ BOOST_PP_CAT( \
+ boost_param_default_ \
+ , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name)) \
+ )
+
+// Helper macro used below to produce lists based on the keyword argument
+// names. macro is applied to every element. n is the number of
+// optional arguments that should be included.
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS(macro, n, split_args) \
+ BOOST_PP_SEQ_FOR_EACH( \
+ macro \
+ , ~ \
+ , BOOST_PP_TUPLE_ELEM(4,1,split_args) \
+ ) \
+ BOOST_PP_SEQ_FOR_EACH( \
+ macro \
+ , ~ \
+ , BOOST_PP_SEQ_FIRST_N( \
+ BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \
+ , BOOST_PP_TUPLE_ELEM(4,3,split_args) \
+ ) \
+ )
+
+// Generates a keyword | default expression.
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT(arg, tag_namespace) \
+ boost::parameter::keyword< \
+ tag_namespace::BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
+ >::instance | boost::parameter::aux::use_default_tag()
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG(arg, tag_ns) \
+ BOOST_PARAMETER_FUNCTION_CAST( \
+ args[ \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT( \
+ arg, tag_ns \
+ ) \
+ ] \
+ , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+ , Args \
+ )
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace) \
+ { \
+ return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
+ (ResultType(*)())0 \
+ , args \
+ , 0L \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \
+ , n \
+ , split_args \
+ ) \
+ , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG( \
+ BOOST_PP_SEQ_ELEM( \
+ BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \
+ , BOOST_PP_TUPLE_ELEM(4,3,split_args) \
+ ) \
+ , tag_namespace \
+ ) \
+ ); \
+ }
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT(arg) \
+ BOOST_PARAMETER_FUNCTION_CAST( \
+ boost::parameter::aux::as_lvalue(BOOST_PARAMETER_FN_ARG_DEFAULT(arg), 0L) \
+ , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+ , Args \
+ )
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY(name, n, split_args, tag_ns, const_) \
+ template < \
+ class ResultType \
+ , class Args \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \
+ , BOOST_PP_INC(n) \
+ , split_args \
+ ) \
+ > \
+ BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
+ ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
+ ResultType(*)() \
+ , Args const& args \
+ , long \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
+ , BOOST_PP_INC(n) \
+ , split_args \
+ ) \
+ , boost::parameter::aux::use_default_tag \
+ ) BOOST_PP_EXPR_IF(const_, const) \
+ { \
+ return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
+ (ResultType(*)())0 \
+ , args \
+ , 0L \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \
+ , BOOST_PP_INC(n) \
+ , split_args \
+ ) \
+ , BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT( \
+ BOOST_PP_SEQ_ELEM( \
+ BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), BOOST_PP_INC(n)) \
+ , BOOST_PP_TUPLE_ELEM(4,3,split_args) \
+ ) \
+ ) \
+ ); \
+ }
+
+// Produces a forwarding layer in the default evaluation machine.
+//
+// data is a tuple:
+//
+// (name, split_args)
+//
+// Where name is the base name of the function, and split_args is a tuple:
+//
+// (required_count, required_args, optional_count, required_args)
+//
+
+
+// defines the actual function body for BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION below.
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0(z, n, data) \
+ template < \
+ class ResultType \
+ , class Args \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \
+ , n \
+ , BOOST_PP_TUPLE_ELEM(5,1,data) \
+ ) \
+ > \
+ BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(5,0,data)) \
+ ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(BOOST_PP_TUPLE_ELEM(5,0,data))( \
+ ResultType(*)() \
+ , Args const& args \
+ , int \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
+ , n \
+ , BOOST_PP_TUPLE_ELEM(5,1,data) \
+ ) \
+ ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(5,2,data), const) \
+ BOOST_PP_IF( \
+ n \
+ , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY \
+ , ; BOOST_PP_TUPLE_EAT(4) \
+ )( \
+ BOOST_PP_TUPLE_ELEM(5,0,data) \
+ , n \
+ , BOOST_PP_TUPLE_ELEM(5,1,data) \
+ , BOOST_PP_TUPLE_ELEM(5,3,data) \
+ )
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION(z, n, data) \
+ BOOST_PP_IF( \
+ BOOST_PP_AND( \
+ BOOST_PP_NOT(n) \
+ , BOOST_PP_TUPLE_ELEM(5,4,data) \
+ ) \
+ , BOOST_PP_TUPLE_EAT(3) \
+ , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0 \
+ )(z, n, data) \
+ BOOST_PP_IF( \
+ BOOST_PP_EQUAL(n, BOOST_PP_TUPLE_ELEM(4,2,BOOST_PP_TUPLE_ELEM(5,1,data))) \
+ , BOOST_PP_TUPLE_EAT(5) \
+ , BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY \
+ )( \
+ BOOST_PP_TUPLE_ELEM(5,0,data) \
+ , n \
+ , BOOST_PP_TUPLE_ELEM(5,1,data) \
+ , BOOST_PP_TUPLE_ELEM(5,3,data) \
+ , BOOST_PP_TUPLE_ELEM(5,2,data) \
+ )
+
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG(r, tag_ns, arg) \
+ , BOOST_PARAMETER_FUNCTION_CAST( \
+ args[ \
+ boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \
+ ] \
+ , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+ , Args \
+ )
+
+// Generates the function template that recives a ArgumentPack, and then
+// goes on to call the layers of overloads generated by
+// BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER.
+# define BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_ns) \
+ template <class Args> \
+ typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type \
+ BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
+ BOOST_PARAMETER_IMPL(name)(Args const& args) BOOST_PP_EXPR_IF(const_, const) \
+ { \
+ return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
+ (typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type(*)())0 \
+ , args \
+ , 0L \
+ \
+ BOOST_PP_SEQ_FOR_EACH( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG \
+ , tag_ns \
+ , BOOST_PP_TUPLE_ELEM(4,1,split_args) \
+ ) \
+ \
+ ); \
+ }
+
+// Helper for BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER below.
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \
+ name, split_args, skip_fwd_decl, const_, tag_namespace \
+ ) \
+ BOOST_PP_REPEAT_FROM_TO( \
+ 0 \
+ , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, split_args)) \
+ , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION \
+ , (name, split_args, const_, tag_namespace, skip_fwd_decl) \
+ ) \
+ \
+ BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_namespace) \
+\
+ template < \
+ class ResultType \
+ , class Args \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \
+ , 0 \
+ , split_args \
+ ) \
+ > \
+ BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
+ ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
+ ResultType(*)() \
+ , Args const& args \
+ , int \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
+ , 0 \
+ , split_args \
+ ) \
+ ) BOOST_PP_EXPR_IF(const_, const)
+
+// Generates a bunch of forwarding functions that each extract
+// one more argument.
+# define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, skip_fwd_decl, const_, tag_ns) \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \
+ name, BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args), skip_fwd_decl, const_, tag_ns \
+ )
+/**/
+
+// Defines the result metafunction and the parameters specialization.
+# define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \
+ \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, name, args) \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(name); \
+
+// Helper for BOOST_PARAMETER_FUNCTION below.
+# define BOOST_PARAMETER_FUNCTION_AUX(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name); \
+\
+ BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \
+ result, name, args, 0 \
+ , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \
+ ) \
+ \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 0, 0, tag_namespace)
+
+// Defines a Boost.Parameter enabled function with the new syntax.
+# define BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_FUNCTION_AUX( \
+ result, name, tag_namespace \
+ , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \
+ ) \
+/**/
+
+// Defines a Boost.Parameter enabled function.
+# define BOOST_PARAMETER_BASIC_FUNCTION_AUX(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \
+ \
+ BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \
+ \
+ BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \
+ result, name, args, 0 \
+ , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \
+ ) \
+ \
+ BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name)
+
+# define BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_BASIC_FUNCTION_AUX( \
+ result, name, tag_namespace \
+ , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
+ ) \
+/**/
+
+// Defines a Boost.Parameter enabled member function.
+# define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(result, name, tag_namespace, args, const_) \
+ BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \
+ \
+ BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \
+ result, name, args, const_ \
+ , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \
+ ) \
+ \
+ BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) BOOST_PP_EXPR_IF(const_, const) \
+/**/
+
+# define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \
+ result, name, tag_namespace \
+ , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
+ , 0 \
+ )
+/**/
+
+# define BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \
+ result, name, tag_namespace \
+ , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
+ , 1 \
+ )
+/**/
+
+
+
+# define BOOST_PARAMETER_MEMBER_FUNCTION_AUX(result, name, tag_namespace, const_, args) \
+ BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \
+\
+ BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \
+ result, name, args, const_ \
+ , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \
+ ) \
+ \
+ BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 1, const_, tag_namespace)
+
+// Defines a Boost.Parameter enabled function with the new syntax.
+# define BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \
+ result, name, tag_namespace, 0 \
+ , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \
+ ) \
+/**/
+
+# define BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \
+ BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \
+ result, name, tag_namespace, 1 \
+ , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \
+ ) \
+/**/
+
+// Defines a Boost.Parameter enabled constructor.
+
+# define BOOST_PARAMETER_FUNCTION_ARGUMENT(r, _, i, elem) \
+ BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i)
+/**/
+
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+// Older MSVC can't do what's necessary to handle commas in base names; just
+// use a typedef instead if you have a base name that contains commas.
+# define BOOST_PARAMETER_PARENTHESIZED_BASE(x) BOOST_PP_SEQ_HEAD(x)
+
+# else
+
+# define BOOST_PARAMETER_PARENTHESIZED_BASE(x) BOOST_PARAMETER_PARENTHESIZED_TYPE(x)
+
+# endif
+
+# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00(z, n, r, data, elem) \
+ BOOST_PP_IF( \
+ n \
+ , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \
+ )(z, n) \
+ BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n,1), explicit) \
+ BOOST_PP_TUPLE_ELEM(6,2,data)( \
+ BOOST_PP_IF( \
+ n \
+ , BOOST_PP_SEQ_FOR_EACH_I_R \
+ , BOOST_PP_TUPLE_EAT(4) \
+ )( \
+ r \
+ , BOOST_PARAMETER_FUNCTION_ARGUMENT \
+ , ~ \
+ , elem \
+ ) \
+ BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \
+ z \
+ , BOOST_PP_TUPLE_ELEM(6,3,data) \
+ , BOOST_PP_CAT(constructor_parameters, __LINE__) \
+ , n \
+ ) \
+ ) \
+ : BOOST_PARAMETER_PARENTHESIZED_BASE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \
+ BOOST_PP_CAT(constructor_parameters, __LINE__)()( \
+ BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
+ ) \
+ ) \
+ {}
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0(r, data, elem) \
+ BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \
+ BOOST_PP_TUPLE_ELEM(6,0,data) \
+ , BOOST_PP_TUPLE_ELEM(6,1,data) \
+ , r \
+ , data \
+ , elem \
+ )
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_PRODUCT(r, product) \
+ (product)
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0(z, n, data) \
+ BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \
+ z, n, BOOST_PP_DEDUCE_R() \
+ , (z, n, BOOST_PP_TUPLE_REM(4) data) \
+ , ~ \
+ )
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N(z, n, data) \
+ BOOST_PP_SEQ_FOR_EACH( \
+ BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0 \
+ , (z, n, BOOST_PP_TUPLE_REM(4) data) \
+ , BOOST_PP_SEQ_FOR_EACH_PRODUCT( \
+ BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \
+ , BOOST_PP_SEQ_FIRST_N( \
+ n, BOOST_PP_TUPLE_ELEM(4,2,data) \
+ ) \
+ ) \
+ )
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR(z, n, data) \
+ BOOST_PP_IF( \
+ n \
+ , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N \
+ , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0 \
+ )(z,n,data) \
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0(class_,base,args,combinations,range) \
+ BOOST_PP_REPEAT_FROM_TO( \
+ BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \
+ , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR \
+ , (class_,base,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \
+ )
+/**/
+
+# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS(class_,base,args,combinations) \
+ BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0( \
+ class_, base, args, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \
+ )
+/**/
+
+# define BOOST_PARAMETER_CONSTRUCTOR_AUX(class_, base, tag_namespace, args) \
+ BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, ctor, args) \
+ BOOST_PP_CAT(constructor_parameters, __LINE__); \
+\
+ BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS( \
+ class_, base, args \
+ , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \
+ ) \
+/**/
+
+# define BOOST_PARAMETER_CONSTRUCTOR(class_, base, tag_namespace, args) \
+ BOOST_PARAMETER_CONSTRUCTOR_AUX( \
+ class_, base, tag_namespace \
+ , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
+ )
+/**/
+
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
+ (BOOST_PP_IF( \
+ BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \
+ BOOST_PARAMETER_FN_ARG_NAME(elem) \
+ ) \
+ , (const ParameterArgumentType ## i)(ParameterArgumentType ## i) \
+ , (const ParameterArgumentType ## i) \
+ ))
+// MSVC6.5 lets us bind rvalues to T&.
+# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
+ (BOOST_PP_IF( \
+ BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \
+ BOOST_PARAMETER_FN_ARG_NAME(elem) \
+ ) \
+ , (ParameterArgumentType ## i) \
+ , (const ParameterArgumentType ## i) \
+ ))
+// No partial ordering. This feature doesn't work.
+// This is exactly the same as for VC6.5, but we might change it later.
+# else
+# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
+ (BOOST_PP_IF( \
+ BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \
+ BOOST_PARAMETER_FN_ARG_NAME(elem) \
+ ) \
+ , (ParameterArgumentType ## i) \
+ , (const ParameterArgumentType ## i) \
+ ))
+# endif
+
+# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \
+ BOOST_PP_SEQ_FOR_EACH_I(BOOST_PARAMETER_FUNCTION_FWD_COMBINATION, ~, args)
+
+#endif // BOOST_PARAMETER_PREPROCESSOR_060206_HPP
+
diff --git a/3rdParty/Boost/src/boost/parameter/value_type.hpp b/3rdParty/Boost/src/boost/parameter/value_type.hpp
new file mode 100755
index 0000000..7415a5c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/parameter/value_type.hpp
@@ -0,0 +1,108 @@
+// Copyright Daniel Wallin 2006. 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)
+
+#ifndef BOOST_PARAMETER_VALUE_TYPE_060921_HPP
+# define BOOST_PARAMETER_VALUE_TYPE_060921_HPP
+
+# include <boost/mpl/apply.hpp>
+# include <boost/mpl/assert.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/parameter/aux_/result_of0.hpp>
+# include <boost/parameter/aux_/void.hpp>
+# include <boost/type_traits/is_same.hpp>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# include <boost/mpl/eval_if.hpp>
+# endif
+
+namespace boost { namespace parameter {
+
+// A metafunction that, given an argument pack, returns the type of
+// the parameter identified by the given keyword. If no such
+// parameter has been specified, returns Default
+
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <class Parameters, class Keyword, class Default>
+struct value_type0
+{
+ typedef typename mpl::apply_wrap3<
+ typename Parameters::binding,Keyword,Default,mpl::false_
+ >::type type;
+
+ BOOST_MPL_ASSERT_NOT((
+ mpl::and_<
+ is_same<Default, void_>
+ , is_same<type, void_>
+ >
+ ));
+};
+# endif
+
+template <class Parameters, class Keyword, class Default = void_>
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+struct value_type
+# else
+struct value_type_eti
+# endif
+{
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ typedef typename mpl::eval_if<
+ mpl::is_placeholder<Parameters>
+ , mpl::identity<int>
+ , value_type0<Parameters,Keyword,Default>
+ >::type type;
+# else
+ typedef typename mpl::apply_wrap3<
+ typename Parameters::binding,Keyword,Default,mpl::false_
+ >::type type;
+
+ BOOST_MPL_ASSERT_NOT((
+ mpl::and_<
+ is_same<Default, void_>
+ , is_same<type, void_>
+ >
+ ));
+# endif
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
+# endif
+};
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+template <class Parameters, class Keyword, class Default = void_>
+struct value_type
+{
+ typedef typename mpl::eval_if<
+ is_same<Parameters, int>
+ , mpl::identity<int>
+ , value_type_eti<Parameters, Keyword, Default>
+ >::type type;
+
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
+};
+# endif
+
+// A metafunction that, given an argument pack, returns the type of
+// the parameter identified by the given keyword. If no such
+// parameter has been specified, returns the type returned by invoking
+// DefaultFn
+template <class Parameters, class Keyword, class DefaultFn>
+struct lazy_value_type
+{
+ typedef typename mpl::apply_wrap3<
+ typename Parameters::binding
+ , Keyword
+ , typename aux::result_of0<DefaultFn>::type
+ , mpl::false_
+ >::type type;
+};
+
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_VALUE_TYPE_060921_HPP
+
diff --git a/3rdParty/Boost/src/boost/preprocessor/arithmetic.hpp b/3rdParty/Boost/src/boost/preprocessor/arithmetic.hpp
new file mode 100644
index 0000000..b1be781
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/arithmetic.hpp
@@ -0,0 +1,25 @@
+# /* Copyright (C) 2001
+# * Housemarque Oy
+# * http://www.housemarque.com
+# *
+# * 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)
+# */
+#
+# /* Revised by Paul Mensonides (2002) */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_ARITHMETIC_HPP
+# define BOOST_PREPROCESSOR_ARITHMETIC_HPP
+#
+# include <boost/preprocessor/arithmetic/add.hpp>
+# include <boost/preprocessor/arithmetic/dec.hpp>
+# include <boost/preprocessor/arithmetic/div.hpp>
+# include <boost/preprocessor/arithmetic/inc.hpp>
+# include <boost/preprocessor/arithmetic/mod.hpp>
+# include <boost/preprocessor/arithmetic/mul.hpp>
+# include <boost/preprocessor/arithmetic/sub.hpp>
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/arithmetic/div.hpp b/3rdParty/Boost/src/boost/preprocessor/arithmetic/div.hpp
new file mode 100644
index 0000000..277596c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/arithmetic/div.hpp
@@ -0,0 +1,39 @@
+# /* Copyright (C) 2001
+# * Housemarque Oy
+# * http://www.housemarque.com
+# *
+# * 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)
+# */
+#
+# /* Revised by Paul Mensonides (2002) */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_ARITHMETIC_DIV_HPP
+# define BOOST_PREPROCESSOR_ARITHMETIC_DIV_HPP
+#
+# include <boost/preprocessor/arithmetic/detail/div_base.hpp>
+# include <boost/preprocessor/config/config.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
+#
+# /* BOOST_PP_DIV */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+# define BOOST_PP_DIV(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE(x, y))
+# else
+# define BOOST_PP_DIV(x, y) BOOST_PP_DIV_I(x, y)
+# define BOOST_PP_DIV_I(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE(x, y))
+# endif
+#
+# /* BOOST_PP_DIV_D */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+# define BOOST_PP_DIV_D(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE_D(d, x, y))
+# else
+# define BOOST_PP_DIV_D(d, x, y) BOOST_PP_DIV_D_I(d, x, y)
+# define BOOST_PP_DIV_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE_D(d, x, y))
+# endif
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/arithmetic/mul.hpp b/3rdParty/Boost/src/boost/preprocessor/arithmetic/mul.hpp
new file mode 100644
index 0000000..f3d9ffc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/arithmetic/mul.hpp
@@ -0,0 +1,53 @@
+# /* Copyright (C) 2001
+# * Housemarque Oy
+# * http://www.housemarque.com
+# *
+# * 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)
+# */
+#
+# /* Revised by Paul Mensonides (2002) */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_ARITHMETIC_MUL_HPP
+# define BOOST_PREPROCESSOR_ARITHMETIC_MUL_HPP
+#
+# include <boost/preprocessor/arithmetic/add.hpp>
+# include <boost/preprocessor/arithmetic/dec.hpp>
+# include <boost/preprocessor/config/config.hpp>
+# include <boost/preprocessor/control/while.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
+# include <boost/preprocessor/tuple/rem.hpp>
+#
+# /* BOOST_PP_MUL */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+# define BOOST_PP_MUL(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_WHILE(BOOST_PP_MUL_P, BOOST_PP_MUL_O, (0, x, y)))
+# else
+# define BOOST_PP_MUL(x, y) BOOST_PP_MUL_I(x, y)
+# define BOOST_PP_MUL_I(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_WHILE(BOOST_PP_MUL_P, BOOST_PP_MUL_O, (0, x, y)))
+# endif
+#
+# define BOOST_PP_MUL_P(d, rxy) BOOST_PP_TUPLE_ELEM(3, 2, rxy)
+#
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT()
+# define BOOST_PP_MUL_O(d, rxy) BOOST_PP_MUL_O_IM(d, BOOST_PP_TUPLE_REM_3 rxy)
+# define BOOST_PP_MUL_O_IM(d, im) BOOST_PP_MUL_O_I(d, im)
+# else
+# define BOOST_PP_MUL_O(d, rxy) BOOST_PP_MUL_O_I(d, BOOST_PP_TUPLE_ELEM(3, 0, rxy), BOOST_PP_TUPLE_ELEM(3, 1, rxy), BOOST_PP_TUPLE_ELEM(3, 2, rxy))
+# endif
+#
+# define BOOST_PP_MUL_O_I(d, r, x, y) (BOOST_PP_ADD_D(d, r, x), x, BOOST_PP_DEC(y))
+#
+# /* BOOST_PP_MUL_D */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+# define BOOST_PP_MUL_D(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_MUL_P, BOOST_PP_MUL_O, (0, x, y)))
+# else
+# define BOOST_PP_MUL_D(d, x, y) BOOST_PP_MUL_D_I(d, x, y)
+# define BOOST_PP_MUL_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_MUL_P, BOOST_PP_MUL_O, (0, x, y)))
+# endif
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/detail/is_nullary.hpp b/3rdParty/Boost/src/boost/preprocessor/detail/is_nullary.hpp
new file mode 100644
index 0000000..dee4075
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/detail/is_nullary.hpp
@@ -0,0 +1,30 @@
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2002.
+# * 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)
+# * *
+# ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_DETAIL_IS_NULLARY_HPP
+# define BOOST_PREPROCESSOR_DETAIL_IS_NULLARY_HPP
+#
+# include <boost/preprocessor/config/config.hpp>
+# include <boost/preprocessor/detail/check.hpp>
+#
+# /* BOOST_PP_IS_NULLARY */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+# define BOOST_PP_IS_NULLARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_NULLARY_CHECK)
+# else
+# define BOOST_PP_IS_NULLARY(x) BOOST_PP_IS_NULLARY_I(x)
+# define BOOST_PP_IS_NULLARY_I(x) BOOST_PP_CHECK(x, BOOST_PP_IS_NULLARY_CHECK)
+# endif
+#
+# define BOOST_PP_IS_NULLARY_CHECK() 1
+# define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_NULLARY_CHECK 0, BOOST_PP_NIL
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/for.hpp b/3rdParty/Boost/src/boost/preprocessor/for.hpp
new file mode 100644
index 0000000..9ec9cee
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/for.hpp
@@ -0,0 +1,17 @@
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2002.
+# * 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)
+# * *
+# ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_FOR_HPP
+# define BOOST_PREPROCESSOR_FOR_HPP
+#
+# include <boost/preprocessor/repetition/for.hpp>
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/iteration.hpp b/3rdParty/Boost/src/boost/preprocessor/iteration.hpp
new file mode 100644
index 0000000..1055ac0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/iteration.hpp
@@ -0,0 +1,19 @@
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2002.
+# * 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)
+# * *
+# ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_ITERATION_HPP
+# define BOOST_PREPROCESSOR_ITERATION_HPP
+#
+# include <boost/preprocessor/iteration/iterate.hpp>
+# include <boost/preprocessor/iteration/local.hpp>
+# include <boost/preprocessor/iteration/self.hpp>
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/repetition.hpp b/3rdParty/Boost/src/boost/preprocessor/repetition.hpp
new file mode 100644
index 0000000..efcd60a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/repetition.hpp
@@ -0,0 +1,32 @@
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2002.
+# * 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)
+# * *
+# ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_REPETITION_HPP
+# define BOOST_PREPROCESSOR_REPETITION_HPP
+#
+# include <boost/preprocessor/repetition/deduce_r.hpp>
+# include <boost/preprocessor/repetition/deduce_z.hpp>
+# include <boost/preprocessor/repetition/enum.hpp>
+# include <boost/preprocessor/repetition/enum_binary_params.hpp>
+# include <boost/preprocessor/repetition/enum_params.hpp>
+# include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+# include <boost/preprocessor/repetition/enum_params_with_defaults.hpp>
+# include <boost/preprocessor/repetition/enum_shifted.hpp>
+# include <boost/preprocessor/repetition/enum_shifted_binary_params.hpp>
+# include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+# include <boost/preprocessor/repetition/enum_trailing.hpp>
+# include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
+# include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+# include <boost/preprocessor/repetition/for.hpp>
+# include <boost/preprocessor/repetition/repeat.hpp>
+# include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/repetition/deduce_r.hpp b/3rdParty/Boost/src/boost/preprocessor/repetition/deduce_r.hpp
new file mode 100644
index 0000000..e49296a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/repetition/deduce_r.hpp
@@ -0,0 +1,22 @@
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2002.
+# * 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)
+# * *
+# ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_REPETITION_DEDUCE_R_HPP
+# define BOOST_PREPROCESSOR_REPETITION_DEDUCE_R_HPP
+#
+# include <boost/preprocessor/detail/auto_rec.hpp>
+# include <boost/preprocessor/repetition/for.hpp>
+#
+# /* BOOST_PP_DEDUCE_R */
+#
+# define BOOST_PP_DEDUCE_R() BOOST_PP_AUTO_REC(BOOST_PP_FOR_P, 256)
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/repetition/deduce_z.hpp b/3rdParty/Boost/src/boost/preprocessor/repetition/deduce_z.hpp
new file mode 100644
index 0000000..14dedc2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/repetition/deduce_z.hpp
@@ -0,0 +1,22 @@
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2002.
+# * 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)
+# * *
+# ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_REPETITION_DEDUCE_Z_HPP
+# define BOOST_PREPROCESSOR_REPETITION_DEDUCE_Z_HPP
+#
+# include <boost/preprocessor/detail/auto_rec.hpp>
+# include <boost/preprocessor/repetition/repeat.hpp>
+#
+# /* BOOST_PP_DEDUCE_Z */
+#
+# define BOOST_PP_DEDUCE_Z() BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/preprocessor/repetition/enum_shifted_binary_params.hpp b/3rdParty/Boost/src/boost/preprocessor/repetition/enum_shifted_binary_params.hpp
new file mode 100644
index 0000000..f3d20fc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/preprocessor/repetition/enum_shifted_binary_params.hpp
@@ -0,0 +1,51 @@
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2005. *
+# * 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) *
+# * *
+# ************************************************************************** */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_SHIFTED_BINARY_PARAMS_HPP
+# define BOOST_PREPROCESSOR_REPETITION_ENUM_SHIFTED_BINARY_PARAMS_HPP
+#
+# include <boost/preprocessor/arithmetic/dec.hpp>
+# include <boost/preprocessor/arithmetic/inc.hpp>
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/config/config.hpp>
+# include <boost/preprocessor/punctuation/comma_if.hpp>
+# include <boost/preprocessor/repetition/repeat.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
+# include <boost/preprocessor/tuple/rem.hpp>
+#
+# /* BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(count, p1, p2) BOOST_PP_REPEAT(BOOST_PP_DEC(count), BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M, (p1, p2))
+# else
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(count, p1, p2) BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_I(count, p1, p2)
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_I(count, p1, p2) BOOST_PP_REPEAT(BOOST_PP_DEC(count), BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M, (p1, p2))
+# endif
+#
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT()
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M(z, n, pp) BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M_IM(z, n, BOOST_PP_TUPLE_REM_2 pp)
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M_IM(z, n, im) BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M_I(z, n, im)
+# else
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M(z, n, pp) BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, pp), BOOST_PP_TUPLE_ELEM(2, 1, pp))
+# endif
+#
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M_I(z, n, p1, p2) BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(p1, BOOST_PP_INC(n)) BOOST_PP_CAT(p2, BOOST_PP_INC(n))
+#
+# /* BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_Z */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_Z(z, count, p1, p2) BOOST_PP_REPEAT_ ## z(BOOST_PP_DEC(count), BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M, (p1, p2))
+# else
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_Z(z, count, p1, p2) BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_Z_I(z, count, p1, p2)
+# define BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_Z_I(z, count, p1, p2) BOOST_PP_REPEAT_ ## z(BOOST_PP_DEC(count), BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS_M, (p1, p2))
+# endif
+#
+# endif
diff --git a/3rdParty/Boost/src/boost/progress.hpp b/3rdParty/Boost/src/boost/progress.hpp
new file mode 100644
index 0000000..62bece0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/progress.hpp
@@ -0,0 +1,143 @@
+// boost progress.hpp header file ------------------------------------------//
+
+// Copyright Beman Dawes 1994-99. 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)
+
+// See http://www.boost.org/libs/timer for documentation.
+
+// Revision History
+// 1 Dec 01 Add leading progress display strings (suggested by Toon Knapen)
+// 20 May 01 Introduce several static_casts<> to eliminate warning messages
+// (Fixed by Beman, reported by Herve Bronnimann)
+// 12 Jan 01 Change to inline implementation to allow use without library
+// builds. See docs for more rationale. (Beman Dawes)
+// 22 Jul 99 Name changed to .hpp
+// 16 Jul 99 Second beta
+// 6 Jul 99 Initial boost version
+
+#ifndef BOOST_PROGRESS_HPP
+#define BOOST_PROGRESS_HPP
+
+#include <boost/timer.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/cstdint.hpp> // for uintmax_t
+#include <iostream> // for ostream, cout, etc
+#include <string> // for string
+
+namespace boost {
+
+// progress_timer ----------------------------------------------------------//
+
+// A progress_timer behaves like a timer except that the destructor displays
+// an elapsed time message at an appropriate place in an appropriate form.
+
+class progress_timer : public timer, private noncopyable
+{
+
+ public:
+ explicit progress_timer( std::ostream & os = std::cout )
+ // os is hint; implementation may ignore, particularly in embedded systems
+ : timer(), noncopyable(), m_os(os) {}
+ ~progress_timer()
+ {
+ // A) Throwing an exception from a destructor is a Bad Thing.
+ // B) The progress_timer destructor does output which may throw.
+ // C) A progress_timer is usually not critical to the application.
+ // Therefore, wrap the I/O in a try block, catch and ignore all exceptions.
+ try
+ {
+ // use istream instead of ios_base to workaround GNU problem (Greg Chicares)
+ std::istream::fmtflags old_flags = m_os.setf( std::istream::fixed,
+ std::istream::floatfield );
+ std::streamsize old_prec = m_os.precision( 2 );
+ m_os << elapsed() << " s\n" // "s" is System International d'Unites std
+ << std::endl;
+ m_os.flags( old_flags );
+ m_os.precision( old_prec );
+ }
+
+ catch (...) {} // eat any exceptions
+ } // ~progress_timer
+
+ private:
+ std::ostream & m_os;
+};
+
+
+// progress_display --------------------------------------------------------//
+
+// progress_display displays an appropriate indication of
+// progress at an appropriate place in an appropriate form.
+
+// NOTE: (Jan 12, 2001) Tried to change unsigned long to boost::uintmax_t, but
+// found some compilers couldn't handle the required conversion to double.
+// Reverted to unsigned long until the compilers catch up.
+
+class progress_display : private noncopyable
+{
+ public:
+ explicit progress_display( unsigned long expected_count_,
+ std::ostream & os = std::cout,
+ const std::string & s1 = "\n", //leading strings
+ const std::string & s2 = "",
+ const std::string & s3 = "" )
+ // os is hint; implementation may ignore, particularly in embedded systems
+ : noncopyable(), m_os(os), m_s1(s1), m_s2(s2), m_s3(s3) { restart(expected_count_); }
+
+ void restart( unsigned long expected_count_ )
+ // Effects: display appropriate scale
+ // Postconditions: count()==0, expected_count()==expected_count_
+ {
+ _count = _next_tic_count = _tic = 0;
+ _expected_count = expected_count_;
+
+ m_os << m_s1 << "0% 10 20 30 40 50 60 70 80 90 100%\n"
+ << m_s2 << "|----|----|----|----|----|----|----|----|----|----|"
+ << std::endl // endl implies flush, which ensures display
+ << m_s3;
+ if ( !_expected_count ) _expected_count = 1; // prevent divide by zero
+ } // restart
+
+ unsigned long operator+=( unsigned long increment )
+ // Effects: Display appropriate progress tic if needed.
+ // Postconditions: count()== original count() + increment
+ // Returns: count().
+ {
+ if ( (_count += increment) >= _next_tic_count ) { display_tic(); }
+ return _count;
+ }
+
+ unsigned long operator++() { return operator+=( 1 ); }
+ unsigned long count() const { return _count; }
+ unsigned long expected_count() const { return _expected_count; }
+
+ private:
+ std::ostream & m_os; // may not be present in all imps
+ const std::string m_s1; // string is more general, safer than
+ const std::string m_s2; // const char *, and efficiency or size are
+ const std::string m_s3; // not issues
+
+ unsigned long _count, _expected_count, _next_tic_count;
+ unsigned int _tic;
+ void display_tic()
+ {
+ // use of floating point ensures that both large and small counts
+ // work correctly. static_cast<>() is also used several places
+ // to suppress spurious compiler warnings.
+ unsigned int tics_needed =
+ static_cast<unsigned int>(
+ (static_cast<double>(_count)/_expected_count)*50.0 );
+ do { m_os << '*' << std::flush; } while ( ++_tic < tics_needed );
+ _next_tic_count =
+ static_cast<unsigned long>((_tic/50.0)*_expected_count);
+ if ( _count == _expected_count ) {
+ if ( _tic < 51 ) m_os << '*';
+ m_os << std::endl;
+ }
+ } // display_tic
+};
+
+} // namespace boost
+
+#endif // BOOST_PROGRESS_HPP
diff --git a/3rdParty/Boost/src/boost/range/adaptor/reversed.hpp b/3rdParty/Boost/src/boost/range/adaptor/reversed.hpp
new file mode 100644
index 0000000..944fbff
--- /dev/null
+++ b/3rdParty/Boost/src/boost/range/adaptor/reversed.hpp
@@ -0,0 +1,103 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/libs/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_REVERSED_HPP
+#define BOOST_RANGE_ADAPTOR_REVERSED_HPP
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class R >
+ struct reversed_range :
+ public boost::iterator_range<
+ boost::reverse_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef boost::iterator_range<
+ boost::reverse_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ base;
+
+ public:
+ typedef boost::reverse_iterator<BOOST_DEDUCED_TYPENAME range_iterator<R>::type> iterator;
+
+ explicit reversed_range( R& r )
+ : base( iterator(boost::end(r)), iterator(boost::begin(r)) )
+ { }
+ };
+
+ struct reverse_forwarder {};
+
+ template< class BidirectionalRange >
+ inline reversed_range<BidirectionalRange>
+ operator|( BidirectionalRange& r, reverse_forwarder )
+ {
+ BOOST_RANGE_CONCEPT_ASSERT((
+ BidirectionalRangeConcept<BidirectionalRange>));
+
+ return reversed_range<BidirectionalRange>( r );
+ }
+
+ template< class BidirectionalRange >
+ inline reversed_range<const BidirectionalRange>
+ operator|( const BidirectionalRange& r, reverse_forwarder )
+ {
+ BOOST_RANGE_CONCEPT_ASSERT((
+ BidirectionalRangeConcept<const BidirectionalRange>));
+
+ return reversed_range<const BidirectionalRange>( r );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::reversed_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::reverse_forwarder reversed =
+ range_detail::reverse_forwarder();
+ }
+
+ template<class BidirectionalRange>
+ inline reversed_range<BidirectionalRange>
+ reverse(BidirectionalRange& rng)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT((
+ BidirectionalRangeConcept<BidirectionalRange>));
+
+ return reversed_range<BidirectionalRange>(rng);
+ }
+
+ template<class BidirectionalRange>
+ inline reversed_range<const BidirectionalRange>
+ reverse(const BidirectionalRange& rng)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT((
+ BidirectionalRangeConcept<const BidirectionalRange>));
+
+ return reversed_range<const BidirectionalRange>(rng);
+ }
+ } // 'adaptors'
+
+} // 'boost'
+
+#endif
diff --git a/3rdParty/Boost/src/boost/signal.hpp b/3rdParty/Boost/src/boost/signal.hpp
deleted file mode 100644
index 7b31f36..0000000
--- a/3rdParty/Boost/src/boost/signal.hpp
+++ /dev/null
@@ -1,366 +0,0 @@
-// Boost.Signals library
-
-// Copyright Douglas Gregor 2001-2006. 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/libs/signals
-
-#ifndef BOOST_SIGNAL_HPP
-#define BOOST_SIGNAL_HPP
-
-#ifndef BOOST_SIGNALS_NO_DEPRECATION_WARNING
-# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
-# pragma message ("Warning: Boost.Signals is no longer being maintained and is now deprecated. Please switch to Boost.Signals2. To disable this warning message, define BOOST_SIGNALS_NO_DEPRECATION_WARNING.")
-# elif defined(__GNUC__) || defined(__HP_aCC) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
-# warning "Boost.Signals is no longer being maintained and is now deprecated. Please switch to Boost.Signals2. To disable this warning message, define BOOST_SIGNALS_NO_DEPRECATION_WARNING."
-# endif
-#endif
-
-#ifndef BOOST_SIGNALS_MAX_ARGS
-# define BOOST_SIGNALS_MAX_ARGS 10
-#endif
-
-#include <boost/config.hpp>
-#include <boost/type_traits/function_traits.hpp>
-#include <boost/signals/signal0.hpp>
-#include <boost/signals/signal1.hpp>
-#include <boost/signals/signal2.hpp>
-#include <boost/signals/signal3.hpp>
-#include <boost/signals/signal4.hpp>
-#include <boost/signals/signal5.hpp>
-#include <boost/signals/signal6.hpp>
-#include <boost/signals/signal7.hpp>
-#include <boost/signals/signal8.hpp>
-#include <boost/signals/signal9.hpp>
-#include <boost/signals/signal10.hpp>
-#include <boost/function.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-# include BOOST_ABI_PREFIX
-#endif
-
-namespace boost {
-#ifndef BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
- namespace BOOST_SIGNALS_NAMESPACE {
- namespace detail {
- template<int Arity,
- typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl;
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<0, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal0<typename traits::result_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<1, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal1<typename traits::result_type,
- typename traits::arg1_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<2, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal2<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<3, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal3<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- typename traits::arg3_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<4, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal4<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- typename traits::arg3_type,
- typename traits::arg4_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<5, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal5<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- typename traits::arg3_type,
- typename traits::arg4_type,
- typename traits::arg5_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<6, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal6<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- typename traits::arg3_type,
- typename traits::arg4_type,
- typename traits::arg5_type,
- typename traits::arg6_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<7, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal7<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- typename traits::arg3_type,
- typename traits::arg4_type,
- typename traits::arg5_type,
- typename traits::arg6_type,
- typename traits::arg7_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<8, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal8<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- typename traits::arg3_type,
- typename traits::arg4_type,
- typename traits::arg5_type,
- typename traits::arg6_type,
- typename traits::arg7_type,
- typename traits::arg8_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<9, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal9<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- typename traits::arg3_type,
- typename traits::arg4_type,
- typename traits::arg5_type,
- typename traits::arg6_type,
- typename traits::arg7_type,
- typename traits::arg8_type,
- typename traits::arg9_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- class real_get_signal_impl<10, Signature, Combiner, Group, GroupCompare,
- SlotFunction>
- {
- typedef function_traits<Signature> traits;
-
- public:
- typedef signal10<typename traits::result_type,
- typename traits::arg1_type,
- typename traits::arg2_type,
- typename traits::arg3_type,
- typename traits::arg4_type,
- typename traits::arg5_type,
- typename traits::arg6_type,
- typename traits::arg7_type,
- typename traits::arg8_type,
- typename traits::arg9_type,
- typename traits::arg10_type,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction> type;
- };
-
- template<typename Signature,
- typename Combiner,
- typename Group,
- typename GroupCompare,
- typename SlotFunction>
- struct get_signal_impl :
- public real_get_signal_impl<(function_traits<Signature>::arity),
- Signature,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction>
- {
- };
-
- } // end namespace detail
- } // end namespace BOOST_SIGNALS_NAMESPACE
-
- // Very lightweight wrapper around the signalN classes that allows signals to
- // be created where the number of arguments does not need to be part of the
- // class name.
- template<
- typename Signature, // function type R (T1, T2, ..., TN)
- typename Combiner = last_value<typename function_traits<Signature>::result_type>,
- typename Group = int,
- typename GroupCompare = std::less<Group>,
- typename SlotFunction = function<Signature>
- >
- class signal :
- public BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl<Signature,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction>::type
- {
- typedef typename BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl<
- Signature,
- Combiner,
- Group,
- GroupCompare,
- SlotFunction>::type base_type;
-
- public:
- explicit signal(const Combiner& combiner = Combiner(),
- const GroupCompare& group_compare = GroupCompare()) :
- base_type(combiner, group_compare)
- {
- }
- };
-#endif // ndef BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
-
-} // end namespace boost
-
-#ifdef BOOST_HAS_ABI_HEADERS
-# include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_SIGNAL_HPP
diff --git a/3rdParty/Boost/src/boost/signals.hpp b/3rdParty/Boost/src/boost/signals.hpp
deleted file mode 100644
index 7e83ed5..0000000
--- a/3rdParty/Boost/src/boost/signals.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// Boost.Signals library
-
-// Copyright Douglas Gregor 2003-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/libs/signals
-#include <boost/signal.hpp>
-
diff --git a/3rdParty/Boost/src/boost/signals/connection.hpp b/3rdParty/Boost/src/boost/signals/connection.hpp
deleted file mode 100644
index 1ede6be..0000000
--- a/3rdParty/Boost/src/boost/signals/connection.hpp
+++ /dev/null
@@ -1,213 +0,0 @@
-// 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();
-
- 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/src/boost/signals/detail/config.hpp b/3rdParty/Boost/src/boost/signals/detail/config.hpp
deleted file mode 100644
index bdd6d20..0000000
--- a/3rdParty/Boost/src/boost/signals/detail/config.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- *
- * 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/src/boost/signals/detail/named_slot_map.hpp b/3rdParty/Boost/src/boost/signals/detail/named_slot_map.hpp
deleted file mode 100644
index 3f7cf1c..0000000
--- a/3rdParty/Boost/src/boost/signals/detail/named_slot_map.hpp
+++ /dev/null
@@ -1,192 +0,0 @@
-// 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/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;
-
-// 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, <= 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;
-
- 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/src/boost/signals/detail/signal_base.hpp b/3rdParty/Boost/src/boost/signals/detail/signal_base.hpp
deleted file mode 100644
index 991e9fc..0000000
--- a/3rdParty/Boost/src/boost/signals/detail/signal_base.hpp
+++ /dev/null
@@ -1,159 +0,0 @@
-// 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/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)
- {
- 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/src/boost/signals/detail/signals_common.hpp b/3rdParty/Boost/src/boost/signals/detail/signals_common.hpp
deleted file mode 100644
index 9cf078d..0000000
--- a/3rdParty/Boost/src/boost/signals/detail/signals_common.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-// 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
- 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);
- };
-
- // 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/detail/slot_call_iterator.hpp b/3rdParty/Boost/src/boost/signals/detail/slot_call_iterator.hpp
deleted file mode 100644
index 0d6afd9..0000000
--- a/3rdParty/Boost/src/boost/signals/detail/slot_call_iterator.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-// 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 func,
- optional<result_type> &c)
- : iter(iter_in), end(end_in), f(func), 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/src/boost/signals/signal0.hpp b/3rdParty/Boost/src/boost/signals/signal0.hpp
deleted file mode 100644
index 6a6166c..0000000
--- a/3rdParty/Boost/src/boost/signals/signal0.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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/src/boost/signals/signal1.hpp b/3rdParty/Boost/src/boost/signals/signal1.hpp
deleted file mode 100644
index 645f7ab..0000000
--- a/3rdParty/Boost/src/boost/signals/signal1.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_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/src/boost/signals/signal10.hpp b/3rdParty/Boost/src/boost/signals/signal10.hpp
deleted file mode 100644
index e043563..0000000
--- a/3rdParty/Boost/src/boost/signals/signal10.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; typedef T7 arg7_type; typedef T8 arg8_type; typedef T9 arg9_type; typedef T10 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_SIGNAL10_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal2.hpp b/3rdParty/Boost/src/boost/signals/signal2.hpp
deleted file mode 100644
index e75f5e7..0000000
--- a/3rdParty/Boost/src/boost/signals/signal2.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 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_SIGNAL2_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal3.hpp b/3rdParty/Boost/src/boost/signals/signal3.hpp
deleted file mode 100644
index 0a695c5..0000000
--- a/3rdParty/Boost/src/boost/signals/signal3.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 arg2_type; typedef T3 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_SIGNAL3_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal4.hpp b/3rdParty/Boost/src/boost/signals/signal4.hpp
deleted file mode 100644
index 56ba360..0000000
--- a/3rdParty/Boost/src/boost/signals/signal4.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 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_SIGNAL4_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal5.hpp b/3rdParty/Boost/src/boost/signals/signal5.hpp
deleted file mode 100644
index 027cda9..0000000
--- a/3rdParty/Boost/src/boost/signals/signal5.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 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_SIGNAL5_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal6.hpp b/3rdParty/Boost/src/boost/signals/signal6.hpp
deleted file mode 100644
index 3955318..0000000
--- a/3rdParty/Boost/src/boost/signals/signal6.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 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_SIGNAL6_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal7.hpp b/3rdParty/Boost/src/boost/signals/signal7.hpp
deleted file mode 100644
index d4530ec..0000000
--- a/3rdParty/Boost/src/boost/signals/signal7.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; typedef T7 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_SIGNAL7_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal8.hpp b/3rdParty/Boost/src/boost/signals/signal8.hpp
deleted file mode 100644
index 094cd97..0000000
--- a/3rdParty/Boost/src/boost/signals/signal8.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; typedef T7 arg7_type; typedef T8 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_SIGNAL8_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal9.hpp b/3rdParty/Boost/src/boost/signals/signal9.hpp
deleted file mode 100644
index a551c16..0000000
--- a/3rdParty/Boost/src/boost/signals/signal9.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; typedef T7 arg7_type; typedef T8 arg8_type; typedef T9 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_SIGNAL9_HEADER
diff --git a/3rdParty/Boost/src/boost/signals/signal_template.hpp b/3rdParty/Boost/src/boost/signals/signal_template.hpp
deleted file mode 100644
index 94e1d1a..0000000
--- a/3rdParty/Boost/src/boost/signals/signal_template.hpp
+++ /dev/null
@@ -1,401 +0,0 @@
-// 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/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);
-
- 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();
- }
- }
-
- 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 call_result_type;
- optional<call_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 call_result_type;
- optional<call_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/src/boost/signals/slot.hpp b/3rdParty/Boost/src/boost/signals/slot.hpp
deleted file mode 100644
index bbf1848..0000000
--- a/3rdParty/Boost/src/boost/signals/slot.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-// 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/src/boost/signals/trackable.hpp b/3rdParty/Boost/src/boost/signals/trackable.hpp
deleted file mode 100644
index 047236c..0000000
--- a/3rdParty/Boost/src/boost/signals/trackable.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-// 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
diff --git a/3rdParty/Boost/src/boost/signals2.hpp b/3rdParty/Boost/src/boost/signals2.hpp
new file mode 100644
index 0000000..22b1119
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2.hpp
@@ -0,0 +1,23 @@
+// A convenience header for Boost.Signals2, should pull in everying in the library.
+
+// Copyright (c) 2008-2009 Frank Mori Hess
+
+// 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)
+
+#ifndef BOOST_SIGNALS2_HPP
+#define BOOST_SIGNALS2_HPP
+
+// For documentation, see http://www.boost.org/libs/signals2/
+
+#include <boost/signals2/deconstruct.hpp>
+#include <boost/signals2/deconstruct_ptr.hpp>
+#include <boost/signals2/dummy_mutex.hpp>
+#include <boost/signals2/last_value.hpp>
+#include <boost/signals2/signal.hpp>
+#include <boost/signals2/signal_type.hpp>
+#include <boost/signals2/shared_connection_block.hpp>
+
+#endif
diff --git a/3rdParty/Boost/src/boost/signals2/connection.hpp b/3rdParty/Boost/src/boost/signals2/connection.hpp
new file mode 100644
index 0000000..0ab4dac
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/connection.hpp
@@ -0,0 +1,297 @@
+/*
+ boost::signals2::connection provides a handle to a signal/slot connection.
+
+ Author: Frank Mori Hess <fmhess@users.sourceforge.net>
+ Begin: 2007-01-23
+*/
+// Copyright Frank Mori Hess 2007-2008.
+// 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)
+
+// See http://www.boost.org/libs/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_CONNECTION_HPP
+#define BOOST_SIGNALS2_CONNECTION_HPP
+
+#include <boost/function.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/signals2/detail/null_output_iterator.hpp>
+#include <boost/signals2/detail/unique_lock.hpp>
+#include <boost/signals2/slot.hpp>
+#include <boost/weak_ptr.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ extern inline void null_deleter(const void*) {}
+ namespace detail
+ {
+ class connection_body_base
+ {
+ public:
+ connection_body_base():
+ _connected(true)
+ {
+ }
+ virtual ~connection_body_base() {}
+ void disconnect()
+ {
+ unique_lock<connection_body_base> local_lock(*this);
+ nolock_disconnect();
+ }
+ void nolock_disconnect()
+ {
+ _connected = false;
+ }
+ virtual bool connected() const = 0;
+ shared_ptr<void> get_blocker()
+ {
+ unique_lock<connection_body_base> local_lock(*this);
+ shared_ptr<void> blocker = _weak_blocker.lock();
+ if(blocker == shared_ptr<void>())
+ {
+ blocker.reset(this, &null_deleter);
+ _weak_blocker = blocker;
+ }
+ return blocker;
+ }
+ bool blocked() const
+ {
+ return !_weak_blocker.expired();
+ }
+ bool nolock_nograb_blocked() const
+ {
+ return nolock_nograb_connected() == false || blocked();
+ }
+ bool nolock_nograb_connected() const {return _connected;}
+ // expose part of Lockable concept of mutex
+ virtual void lock() = 0;
+ virtual void unlock() = 0;
+
+ protected:
+
+ mutable bool _connected;
+ weak_ptr<void> _weak_blocker;
+ };
+
+ template<typename GroupKey, typename SlotType, typename Mutex>
+ class connection_body: public connection_body_base
+ {
+ public:
+ typedef Mutex mutex_type;
+ connection_body(const SlotType &slot_in):
+ slot(slot_in)
+ {
+ }
+ virtual ~connection_body() {}
+ virtual bool connected() const
+ {
+ unique_lock<mutex_type> local_lock(_mutex);
+ nolock_grab_tracked_objects(detail::null_output_iterator());
+ return nolock_nograb_connected();
+ }
+ const GroupKey& group_key() const {return _group_key;}
+ void set_group_key(const GroupKey &key) {_group_key = key;}
+ bool nolock_slot_expired() const
+ {
+ bool expired = slot.expired();
+ if(expired == true)
+ {
+ _connected = false;
+ }
+ return expired;
+ }
+ template<typename OutputIterator>
+ void nolock_grab_tracked_objects(OutputIterator inserter) const
+ {
+ slot_base::tracked_container_type::const_iterator it;
+ for(it = slot.tracked_objects().begin();
+ it != slot.tracked_objects().end();
+ ++it)
+ {
+ void_shared_ptr_variant locked_object
+ (
+ apply_visitor
+ (
+ detail::lock_weak_ptr_visitor(),
+ *it
+ )
+ );
+ if(apply_visitor(detail::expired_weak_ptr_visitor(), *it))
+ {
+ _connected = false;
+ return;
+ }
+ *inserter++ = locked_object;
+ }
+ }
+ // expose Lockable concept of mutex
+ virtual void lock()
+ {
+ _mutex.lock();
+ }
+ virtual void unlock()
+ {
+ _mutex.unlock();
+ }
+ SlotType slot;
+ private:
+ mutable mutex_type _mutex;
+ GroupKey _group_key;
+ };
+ }
+
+ class shared_connection_block;
+
+ class connection
+ {
+ public:
+ friend class shared_connection_block;
+
+ connection() {}
+ connection(const connection &other): _weak_connection_body(other._weak_connection_body)
+ {}
+ connection(const boost::weak_ptr<detail::connection_body_base> &connectionBody):
+ _weak_connection_body(connectionBody)
+ {}
+
+ // move support
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ connection(connection && other): _weak_connection_body(std::move(other._weak_connection_body))
+ {
+ // make sure other is reset, in case it is a scoped_connection (so it
+ // won't disconnect on destruction after being moved away from).
+ other._weak_connection_body.reset();
+ }
+ connection & operator=(connection && other)
+ {
+ if(&other == this) return *this;
+ _weak_connection_body = std::move(other._weak_connection_body);
+ // make sure other is reset, in case it is a scoped_connection (so it
+ // won't disconnect on destruction after being moved away from).
+ other._weak_connection_body.reset();
+ return *this;
+ }
+#endif // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ connection & operator=(const connection & other)
+ {
+ if(&other == this) return *this;
+ _weak_connection_body = other._weak_connection_body;
+ return *this;
+ }
+
+ ~connection() {}
+ void disconnect() const
+ {
+ boost::shared_ptr<detail::connection_body_base> connectionBody(_weak_connection_body.lock());
+ if(connectionBody == 0) return;
+ connectionBody->disconnect();
+ }
+ bool connected() const
+ {
+ boost::shared_ptr<detail::connection_body_base> connectionBody(_weak_connection_body.lock());
+ if(connectionBody == 0) return false;
+ return connectionBody->connected();
+ }
+ bool blocked() const
+ {
+ boost::shared_ptr<detail::connection_body_base> connectionBody(_weak_connection_body.lock());
+ if(connectionBody == 0) return true;
+ return connectionBody->blocked();
+ }
+ bool operator==(const connection& other) const
+ {
+ boost::shared_ptr<detail::connection_body_base> connectionBody(_weak_connection_body.lock());
+ boost::shared_ptr<detail::connection_body_base> otherConnectionBody(other._weak_connection_body.lock());
+ return connectionBody == otherConnectionBody;
+ }
+ bool operator!=(const connection& other) const
+ {
+ return !(*this == other);
+ }
+ bool operator<(const connection& other) const
+ {
+ boost::shared_ptr<detail::connection_body_base> connectionBody(_weak_connection_body.lock());
+ boost::shared_ptr<detail::connection_body_base> otherConnectionBody(other._weak_connection_body.lock());
+ return connectionBody < otherConnectionBody;
+ }
+ void swap(connection &other)
+ {
+ using std::swap;
+ swap(_weak_connection_body, other._weak_connection_body);
+ }
+ protected:
+
+ boost::weak_ptr<detail::connection_body_base> _weak_connection_body;
+ };
+ inline void swap(connection &conn1, connection &conn2)
+ {
+ conn1.swap(conn2);
+ }
+
+ class scoped_connection: public connection
+ {
+ public:
+ scoped_connection() {}
+ scoped_connection(const connection &other):
+ connection(other)
+ {}
+ ~scoped_connection()
+ {
+ disconnect();
+ }
+ scoped_connection& operator=(const connection &rhs)
+ {
+ disconnect();
+ connection::operator=(rhs);
+ return *this;
+ }
+
+ // move support
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ scoped_connection(scoped_connection && other): connection(std::move(other))
+ {
+ }
+ scoped_connection(connection && other): connection(std::move(other))
+ {
+ }
+ scoped_connection & operator=(scoped_connection && other)
+ {
+ if(&other == this) return *this;
+ disconnect();
+ connection::operator=(std::move(other));
+ return *this;
+ }
+ scoped_connection & operator=(connection && other)
+ {
+ if(&other == this) return *this;
+ disconnect();
+ connection::operator=(std::move(other));
+ return *this;
+ }
+#endif // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+ connection release()
+ {
+ connection conn(_weak_connection_body);
+ _weak_connection_body.reset();
+ return conn;
+ }
+ private:
+ scoped_connection(const scoped_connection &other);
+ scoped_connection& operator=(const scoped_connection &rhs);
+ };
+ // Sun 5.9 compiler doesn't find the swap for base connection class when
+ // arguments are scoped_connection, so we provide this explicitly.
+ inline void swap(scoped_connection &conn1, scoped_connection &conn2)
+ {
+ conn1.swap(conn2);
+ }
+ }
+}
+
+#endif // BOOST_SIGNALS2_CONNECTION_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/deconstruct.hpp b/3rdParty/Boost/src/boost/signals2/deconstruct.hpp
new file mode 100644
index 0000000..d3eca33
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/deconstruct.hpp
@@ -0,0 +1,547 @@
+#ifndef BOOST_SIGNALS2_DECONSTRUCT_HPP
+#define BOOST_SIGNALS2_DECONSTRUCT_HPP
+
+// deconstruct.hpp
+//
+// A factory function for creating a shared_ptr which creates
+// an object and its owning shared_ptr with one allocation, similar
+// to make_shared<T>(). It also supports postconstructors
+// and predestructors through unqualified calls of adl_postconstruct() and
+// adl_predestruct, relying on argument-dependent
+// lookup to find the appropriate postconstructor or predestructor.
+// Passing arguments to postconstructors is also supported.
+//
+// based on make_shared.hpp and make_shared_access patch from Michael Marcin
+//
+// Copyright (c) 2007, 2008 Peter Dimov
+// Copyright (c) 2008 Michael Marcin
+// Copyright (c) 2009 Frank Mori Hess
+//
+// 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
+//
+// See http://www.boost.org
+// for more information
+
+#include <boost/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/signals2/deconstruct_ptr.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <cstddef>
+#include <new>
+
+namespace boost
+{
+ template<typename T> class enable_shared_from_this;
+
+namespace signals2
+{
+ class deconstruct_access;
+
+namespace detail
+{
+ inline void adl_predestruct(...) {}
+} // namespace detail
+
+template<typename T>
+ class postconstructor_invoker
+{
+public:
+ operator const shared_ptr<T> & () const
+ {
+ return postconstruct();
+ }
+ const shared_ptr<T>& postconstruct() const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()));
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ template<class... Args>
+ const shared_ptr<T>& postconstruct(Args && ... args)
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ std::forward<Args>(args)...);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+#else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ template<typename A1>
+ const shared_ptr<T>& postconstruct(const A1 &a1) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+ template<typename A1, typename A2>
+ const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1, a2);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+ template<typename A1, typename A2, typename A3>
+ const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1, a2, a3);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+ template<typename A1, typename A2, typename A3, typename A4>
+ const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1, a2, a3, a4);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+ template<typename A1, typename A2, typename A3, typename A4, typename A5>
+ const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1, a2, a3, a4, a5);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+ template<typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename A6>
+ const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
+ const A6 &a6) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1, a2, a3, a4, a5, a6);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+ template<typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename A6, typename A7>
+ const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
+ const A6 &a6, const A7 &a7) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1, a2, a3, a4, a5, a6, a7);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+ template<typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename A6, typename A7, typename A8>
+ const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
+ const A6 &a6, const A7 &a7, const A8 &a8) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1, a2, a3, a4, a5, a6, a7, a8);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+ template<typename A1, typename A2, typename A3, typename A4, typename A5,
+ typename A6, typename A7, typename A8, typename A9>
+ const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
+ const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9) const
+ {
+ if(!_postconstructed)
+ {
+ adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+ a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ _postconstructed = true;
+ }
+ return _sp;
+ }
+#endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+private:
+ friend class boost::signals2::deconstruct_access;
+ postconstructor_invoker(const shared_ptr<T> & sp):
+ _sp(sp), _postconstructed(false)
+ {}
+ shared_ptr<T> _sp;
+ mutable bool _postconstructed;
+};
+
+namespace detail
+{
+
+template< std::size_t N, std::size_t A > struct sp_aligned_storage
+{
+ union type
+ {
+ char data_[ N ];
+ typename boost::type_with_alignment< A >::type align_;
+ };
+};
+
+template< class T > class deconstruct_deleter
+{
+private:
+
+ typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+
+ bool initialized_;
+ storage_type storage_;
+
+private:
+
+ void destroy()
+ {
+ if( initialized_ )
+ {
+ T* p = reinterpret_cast< T* >( storage_.data_ );
+ using boost::signals2::detail::adl_predestruct;
+ adl_predestruct(const_cast<typename boost::remove_const<T>::type *>(p));
+ p->~T();
+ initialized_ = false;
+ }
+ }
+
+public:
+
+ deconstruct_deleter(): initialized_( false )
+ {
+ }
+
+ // this copy constructor is an optimization: we don't need to copy the storage_ member,
+ // and shouldn't be copying anyways after initialized_ becomes true
+ deconstruct_deleter(const deconstruct_deleter &): initialized_( false )
+ {
+ }
+
+ ~deconstruct_deleter()
+ {
+ destroy();
+ }
+
+ void operator()( T * )
+ {
+ destroy();
+ }
+
+ void * address()
+ {
+ return storage_.data_;
+ }
+
+ void set_initialized()
+ {
+ initialized_ = true;
+ }
+};
+} // namespace detail
+
+class deconstruct_access
+{
+public:
+
+ template< class T >
+ static postconstructor_invoker<T> deconstruct()
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T();
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+
+ }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+ // Variadic templates, rvalue reference
+
+ template< class T, class... Args >
+ static postconstructor_invoker<T> deconstruct( Args && ... args )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( std::forward<Args>( args )... );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+#else
+
+ template< class T, class A1 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+ template< class T, class A1, class A2 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1, a2 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+ template< class T, class A1, class A2, class A3 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1, a2, a3 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+ template< class T, class A1, class A2, class A3, class A4 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1, a2, a3, a4 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+ template< class T, class A1, class A2, class A3, class A4, class A5 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1, a2, a3, a4, a5 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+ template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1, a2, a3, a4, a5, a6 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+ template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+ template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+ template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+ static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+ {
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
+
+ detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
+
+ void * pv = pd->address();
+
+ new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+ pd->set_initialized();
+
+ boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
+ boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
+ return retval;
+ }
+
+#endif
+};
+
+// Zero-argument versions
+//
+// Used even when variadic templates are available because of the new T() vs new T issue
+
+template< class T > postconstructor_invoker<T> deconstruct()
+{
+ return deconstruct_access::deconstruct<T>();
+}
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+// Variadic templates, rvalue reference
+
+template< class T, class... Args > postconstructor_invoker< T > deconstruct( Args && ... args )
+{
+ return deconstruct_access::deconstruct<T>( std::forward<Args>( args )... );
+}
+
+#else
+
+// C++03 version
+
+template< class T, class A1 >
+postconstructor_invoker<T> deconstruct( A1 const & a1 )
+{
+ return deconstruct_access::deconstruct<T>(a1);
+}
+
+template< class T, class A1, class A2 >
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2 )
+{
+ return deconstruct_access::deconstruct<T>(a1,a2);
+}
+
+template< class T, class A1, class A2, class A3 >
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3 )
+{
+ return deconstruct_access::deconstruct<T>(a1,a2,a3);
+}
+
+template< class T, class A1, class A2, class A3, class A4 >
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+{
+ return deconstruct_access::deconstruct<T>(a1,a2,a3,a4);
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5 >
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+{
+ return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5);
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+{
+ return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6);
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+{
+ return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7);
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+{
+ return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7,a8);
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+{
+ return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7,a8,a9);
+}
+
+#endif
+
+} // namespace signals2
+} // namespace boost
+
+#endif // #ifndef BOOST_SIGNALS2_DECONSTRUCT_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/deconstruct_ptr.hpp b/3rdParty/Boost/src/boost/signals2/deconstruct_ptr.hpp
new file mode 100644
index 0000000..841b19b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/deconstruct_ptr.hpp
@@ -0,0 +1,84 @@
+// DEPRECATED in favor of adl_postconstruct and adl_predestruct with
+// deconstruct<T>().
+// A factory function for creating a shared_ptr that enhances the plain
+// shared_ptr constructors by adding support for postconstructors
+// and predestructors through the boost::signals2::postconstructible and
+// boost::signals2::predestructible base classes.
+//
+// Copyright Frank Mori Hess 2007-2008.
+//
+// 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)
+
+#ifndef BOOST_SIGNALS2_DECONSTRUCT_PTR_HPP
+#define BOOST_SIGNALS2_DECONSTRUCT_PTR_HPP
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/signals2/postconstructible.hpp>
+#include <boost/signals2/predestructible.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ extern inline void do_postconstruct(const postconstructible *ptr)
+ {
+ postconstructible *nonconst_ptr = const_cast<postconstructible*>(ptr);
+ nonconst_ptr->postconstruct();
+ }
+ extern inline void do_postconstruct(...)
+ {
+ }
+ extern inline void do_predestruct(...)
+ {
+ }
+ extern inline void do_predestruct(const predestructible *ptr)
+ {
+ try
+ {
+ predestructible *nonconst_ptr = const_cast<predestructible*>(ptr);
+ nonconst_ptr->predestruct();
+ }
+ catch(...)
+ {
+ BOOST_ASSERT(false);
+ }
+ }
+ }
+
+ template<typename T> class predestructing_deleter
+ {
+ public:
+ void operator()(const T *ptr) const
+ {
+ detail::do_predestruct(ptr);
+ checked_delete(ptr);
+ }
+ };
+
+ template<typename T>
+ shared_ptr<T> deconstruct_ptr(T *ptr)
+ {
+ if(ptr == 0) return shared_ptr<T>(ptr);
+ shared_ptr<T> shared(ptr, boost::signals2::predestructing_deleter<T>());
+ detail::do_postconstruct(ptr);
+ return shared;
+ }
+ template<typename T, typename D>
+ shared_ptr<T> deconstruct_ptr(T *ptr, D deleter)
+ {
+ shared_ptr<T> shared(ptr, deleter);
+ if(ptr == 0) return shared;
+ detail::do_postconstruct(ptr);
+ return shared;
+ }
+ }
+}
+
+#endif // BOOST_SIGNALS2_DECONSTRUCT_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/auto_buffer.hpp b/3rdParty/Boost/src/boost/signals2/detail/auto_buffer.hpp
new file mode 100644
index 0000000..bf12e69
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/auto_buffer.hpp
@@ -0,0 +1,1138 @@
+// Copyright Thorsten Ottosen, 2009.
+// 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_SIGNALS2_DETAIL_AUTO_BUFFER_HPP_25_02_2009
+#define BOOST_SIGNALS2_DETAIL_AUTO_BUFFER_HPP_25_02_2009
+
+#include <boost/detail/workaround.hpp>
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(push)
+#pragma warning(disable:4996)
+#endif
+
+#include <boost/assert.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/multi_index/detail/scope_guard.hpp>
+#include <boost/swap.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/type_traits/has_nothrow_assign.hpp>
+#include <boost/type_traits/has_trivial_assign.hpp>
+#include <boost/type_traits/has_trivial_constructor.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <algorithm>
+#include <cstring>
+#include <iterator>
+#include <memory>
+#include <stdexcept>
+
+namespace boost
+{
+namespace signals2
+{
+namespace detail
+{
+ //
+ // Policies for creating the stack buffer.
+ //
+ template< unsigned N >
+ struct store_n_objects
+ {
+ BOOST_STATIC_CONSTANT( unsigned, value = N );
+ };
+
+ template< unsigned N >
+ struct store_n_bytes
+ {
+ BOOST_STATIC_CONSTANT( unsigned, value = N );
+ };
+
+ namespace auto_buffer_detail
+ {
+ template< class Policy, class T >
+ struct compute_buffer_size
+ {
+ BOOST_STATIC_CONSTANT( unsigned, value = Policy::value * sizeof(T) );
+ };
+
+ template< unsigned N, class T >
+ struct compute_buffer_size< store_n_bytes<N>, T >
+ {
+ BOOST_STATIC_CONSTANT( unsigned, value = N );
+ };
+
+ template< class Policy, class T >
+ struct compute_buffer_objects
+ {
+ BOOST_STATIC_CONSTANT( unsigned, value = Policy::value );
+ };
+
+ template< unsigned N, class T >
+ struct compute_buffer_objects< store_n_bytes<N>, T >
+ {
+ BOOST_STATIC_CONSTANT( unsigned, value = N / sizeof(T) );
+ };
+ }
+
+ struct default_grow_policy
+ {
+ template< class SizeType >
+ static SizeType new_capacity( SizeType capacity )
+ {
+ //
+ // @remark: we grow the capacity quite agressively.
+ // this is justified since we aim to minimize
+ // heap-allocations, and because we mostly use
+ // the buffer locally.
+ return capacity * 4u;
+ }
+
+ template< class SizeType >
+ static bool should_shrink( SizeType size, SizeType capacity )
+ {
+ //
+ // @remark: when defining a new grow policy, one might
+ // choose that if the waated space is less
+ // than a certain percentage, then it is of
+ // little use to shrink.
+ //
+ return true;
+ }
+ };
+
+ template< class T,
+ class StackBufferPolicy = store_n_objects<256>,
+ class GrowPolicy = default_grow_policy,
+ class Allocator = std::allocator<T> >
+ class auto_buffer;
+
+
+
+ template
+ <
+ class T,
+ class StackBufferPolicy,
+ class GrowPolicy,
+ class Allocator
+ >
+ class auto_buffer : Allocator
+ {
+ private:
+ enum { N = auto_buffer_detail::
+ compute_buffer_objects<StackBufferPolicy,T>::value };
+
+ BOOST_STATIC_CONSTANT( bool, is_stack_buffer_empty = N == 0u );
+
+ typedef auto_buffer<T, store_n_objects<0>, GrowPolicy, Allocator>
+ local_buffer;
+
+ public:
+ typedef Allocator allocator_type;
+ typedef T value_type;
+ typedef typename Allocator::size_type size_type;
+ typedef typename Allocator::difference_type difference_type;
+ typedef T* pointer;
+ typedef typename Allocator::pointer allocator_pointer;
+ typedef const T* const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef pointer iterator;
+ typedef const_pointer const_iterator;
+ typedef boost::reverse_iterator<iterator> reverse_iterator;
+ typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef typename boost::mpl::if_c< boost::has_trivial_assign<T>::value
+ && sizeof(T) <= sizeof(long double),
+ const value_type,
+ const_reference >::type
+ optimized_const_reference;
+ private:
+
+ pointer allocate( size_type capacity_arg )
+ {
+ if( capacity_arg > N )
+ return &*get_allocator().allocate( capacity_arg );
+ else
+ return static_cast<T*>( members_.address() );
+ }
+
+ void deallocate( pointer where, size_type capacity_arg )
+ {
+ if( capacity_arg <= N )
+ return;
+ get_allocator().deallocate( allocator_pointer(where), capacity_arg );
+ }
+
+ template< class I >
+ static void copy_impl( I begin, I end, pointer where, std::random_access_iterator_tag )
+ {
+ copy_rai( begin, end, where, boost::has_trivial_assign<T>() );
+ }
+
+ static void copy_rai( const T* begin, const T* end,
+ pointer where, const boost::true_type& )
+ {
+ std::memcpy( where, begin, sizeof(T) * std::distance(begin,end) );
+ }
+
+ template< class I, bool b >
+ static void copy_rai( I begin, I end,
+ pointer where, const boost::integral_constant<bool, b>& )
+ {
+ std::uninitialized_copy( begin, end, where );
+ }
+
+ template< class I >
+ static void copy_impl( I begin, I end, pointer where, std::bidirectional_iterator_tag )
+ {
+ std::uninitialized_copy( begin, end, where );
+ }
+
+ template< class I >
+ static void copy_impl( I begin, I end, pointer where )
+ {
+ copy_impl( begin, end, where,
+ typename std::iterator_traits<I>::iterator_category() );
+ }
+
+ template< class I, class I2 >
+ static void assign_impl( I begin, I end, I2 where )
+ {
+ assign_impl( begin, end, where, boost::has_trivial_assign<T>() );
+ }
+
+ template< class I, class I2 >
+ static void assign_impl( I begin, I end, I2 where, const boost::true_type& )
+ {
+ std::memcpy( where, begin, sizeof(T) * std::distance(begin,end) );
+ }
+
+ template< class I, class I2 >
+ static void assign_impl( I begin, I end, I2 where, const boost::false_type& )
+ {
+ for( ; begin != end; ++begin, ++where )
+ *where = *begin;
+ }
+
+ void unchecked_push_back_n( size_type n, const boost::true_type& )
+ {
+ std::uninitialized_fill( end(), end() + n, T() );
+ size_ += n;
+ }
+
+ void unchecked_push_back_n( size_type n, const boost::false_type& )
+ {
+ for( size_type i = 0u; i < n; ++i )
+ unchecked_push_back();
+ }
+
+ void auto_buffer_destroy( pointer where, const boost::false_type& )
+ {
+ (*where).~T();
+ }
+
+ void auto_buffer_destroy( pointer, const boost::true_type& )
+ { }
+
+ void auto_buffer_destroy( pointer where )
+ {
+ auto_buffer_destroy( where, boost::has_trivial_destructor<T>() );
+ }
+
+ void destroy_back_n( size_type n, const boost::false_type& )
+ {
+ BOOST_ASSERT( n > 0 );
+ pointer buffer = buffer_ + size_ - 1u;
+ pointer new_end = buffer - n;
+ for( ; buffer > new_end; --buffer )
+ auto_buffer_destroy( buffer );
+ }
+
+ void destroy_back_n( size_type n, const boost::true_type& )
+ { }
+
+ void destroy_back_n( size_type n )
+ {
+ destroy_back_n( n, boost::has_trivial_destructor<T>() );
+ }
+
+ void auto_buffer_destroy( const boost::false_type& x )
+ {
+ if( size_ )
+ destroy_back_n( size_, x );
+ deallocate( buffer_, members_.capacity_ );
+ }
+
+ void auto_buffer_destroy( const boost::true_type& )
+ {
+ deallocate( buffer_, members_.capacity_ );
+ }
+
+ pointer move_to_new_buffer( size_type new_capacity, const boost::false_type& )
+ {
+ pointer new_buffer = allocate( new_capacity ); // strong
+ boost::multi_index::detail::scope_guard guard =
+ boost::multi_index::detail::make_obj_guard( *this,
+ &auto_buffer::deallocate,
+ new_buffer,
+ new_capacity );
+ copy_impl( begin(), end(), new_buffer ); // strong
+ guard.dismiss(); // nothrow
+ return new_buffer;
+ }
+
+ pointer move_to_new_buffer( size_type new_capacity, const boost::true_type& )
+ {
+ pointer new_buffer = allocate( new_capacity ); // strong
+ copy_impl( begin(), end(), new_buffer ); // nothrow
+ return new_buffer;
+ }
+
+ void reserve_impl( size_type new_capacity )
+ {
+ pointer new_buffer = move_to_new_buffer( new_capacity,
+ boost::has_nothrow_copy<T>() );
+ (*this).~auto_buffer();
+ buffer_ = new_buffer;
+ members_.capacity_ = new_capacity;
+ BOOST_ASSERT( size_ <= members_.capacity_ );
+ }
+
+ size_type new_capacity_impl( size_type n )
+ {
+ BOOST_ASSERT( n > members_.capacity_ );
+ size_type new_capacity = GrowPolicy::new_capacity( members_.capacity_ );
+ // @todo: consider to check for allocator.max_size()
+ return (std::max)(new_capacity,n);
+ }
+
+ static void swap_helper( auto_buffer& l, auto_buffer& r,
+ const boost::true_type& )
+ {
+ BOOST_ASSERT( l.is_on_stack() && r.is_on_stack() );
+
+ auto_buffer temp( l.begin(), l.end() );
+ assign_impl( r.begin(), r.end(), l.begin() );
+ assign_impl( temp.begin(), temp.end(), r.begin() );
+ boost::swap( l.size_, r.size_ );
+ boost::swap( l.members_.capacity_, r.members_.capacity_ );
+ }
+
+ static void swap_helper( auto_buffer& l, auto_buffer& r,
+ const boost::false_type& )
+ {
+ BOOST_ASSERT( l.is_on_stack() && r.is_on_stack() );
+ size_type min_size = (std::min)(l.size_,r.size_);
+ size_type max_size = (std::max)(l.size_,r.size_);
+ size_type diff = max_size - min_size;
+ auto_buffer* smallest = l.size_ == min_size ? &l : &r;
+ auto_buffer* largest = smallest == &l ? &r : &l;
+
+ // @remark: the implementation below is not as fast
+ // as it could be if we assumed T had a default
+ // constructor.
+
+ size_type i = 0u;
+ for( ; i < min_size; ++i )
+ boost::swap( (*smallest)[i], (*largest)[i] );
+
+ for( ; i < max_size; ++i )
+ smallest->unchecked_push_back( (*largest)[i] );
+
+ largest->pop_back_n( diff );
+ boost::swap( l.members_.capacity_, r.members_.capacity_ );
+ }
+
+ void one_sided_swap( auto_buffer& temp ) // nothrow
+ {
+ BOOST_ASSERT( !temp.is_on_stack() );
+ this->~auto_buffer();
+ // @remark: must be nothrow
+ get_allocator() = temp.get_allocator();
+ members_.capacity_ = temp.members_.capacity_;
+ buffer_ = temp.buffer_;
+ BOOST_ASSERT( temp.size_ >= size_ + 1u );
+ size_ = temp.size_;
+ temp.buffer_ = 0;
+ BOOST_ASSERT( temp.is_valid() );
+ }
+
+ template< class I >
+ void insert_impl( const_iterator before, I begin_arg, I end_arg,
+ std::input_iterator_tag )
+ {
+ for( ; begin_arg != end_arg; ++begin_arg )
+ {
+ before = insert( before, *begin_arg );
+ ++before;
+ }
+ }
+
+ void grow_back( size_type n, const boost::true_type& )
+ {
+ BOOST_ASSERT( size_ + n <= members_.capacity_ );
+ size_ += n;
+ }
+
+ void grow_back( size_type n, const boost::false_type& )
+ {
+ unchecked_push_back_n(n);
+ }
+
+ void grow_back( size_type n )
+ {
+ grow_back( n, boost::has_trivial_constructor<T>() );
+ }
+
+ void grow_back_one( const boost::true_type& )
+ {
+ BOOST_ASSERT( size_ + 1 <= members_.capacity_ );
+ size_ += 1;
+ }
+
+ void grow_back_one( const boost::false_type& )
+ {
+ unchecked_push_back();
+ }
+
+ void grow_back_one()
+ {
+ grow_back_one( boost::has_trivial_constructor<T>() );
+ }
+
+ template< class I >
+ void insert_impl( const_iterator before, I begin_arg, I end_arg,
+ std::forward_iterator_tag )
+ {
+ difference_type n = std::distance(begin_arg, end_arg);
+
+ if( size_ + n <= members_.capacity_ )
+ {
+ bool is_back_insertion = before == cend();
+ if( !is_back_insertion )
+ {
+ grow_back( n );
+ iterator where = const_cast<T*>(before);
+ std::copy( before, cend() - n, where + n );
+ assign_impl( begin_arg, end_arg, where );
+ }
+ else
+ {
+ unchecked_push_back( begin_arg, end_arg );
+ }
+ BOOST_ASSERT( is_valid() );
+ return;
+ }
+
+ auto_buffer temp( new_capacity_impl( size_ + n ) );
+ temp.unchecked_push_back( cbegin(), before );
+ temp.unchecked_push_back( begin_arg, end_arg );
+ temp.unchecked_push_back( before, cend() );
+ one_sided_swap( temp );
+ BOOST_ASSERT( is_valid() );
+ }
+
+ public:
+ bool is_valid() const // invariant
+ {
+ // @remark: allowed for N==0 and when
+ // using a locally instance
+ // in insert()/one_sided_swap()
+ if( buffer_ == 0 )
+ return true;
+
+ if( members_.capacity_ < N )
+ return false;
+
+ if( !is_on_stack() && members_.capacity_ <= N )
+ return false;
+
+ if( buffer_ == members_.address() )
+ if( members_.capacity_ > N )
+ return false;
+
+ if( size_ > members_.capacity_ )
+ return false;
+
+ return true;
+ }
+
+ auto_buffer()
+ : members_( N ),
+ buffer_( static_cast<T*>(members_.address()) ),
+ size_( 0u )
+ {
+ BOOST_ASSERT( is_valid() );
+ }
+
+ auto_buffer( const auto_buffer& r )
+ : members_( (std::max)(r.size_,size_type(N)) ),
+ buffer_( allocate( members_.capacity_ ) ),
+ size_( 0 )
+ {
+ copy_impl( r.begin(), r.end(), buffer_ );
+ size_ = r.size_;
+ BOOST_ASSERT( is_valid() );
+ }
+
+ auto_buffer& operator=( const auto_buffer& r ) // basic
+ {
+ if( this == &r )
+ return *this;
+
+ difference_type diff = size_ - r.size_;
+ if( diff >= 0 )
+ {
+ pop_back_n( static_cast<size_type>(diff) );
+ assign_impl( r.begin(), r.end(), begin() );
+ }
+ else
+ {
+ if( members_.capacity_ >= r.size() )
+ {
+ unchecked_push_back_n( static_cast<size_type>(-diff) );
+ assign_impl( r.begin(), r.end(), begin() );
+ }
+ else
+ {
+ // @remark: we release memory as early as possible
+ // since we only give the basic guarantee
+ (*this).~auto_buffer();
+ buffer_ = 0;
+ pointer new_buffer = allocate( r.size() );
+ boost::multi_index::detail::scope_guard guard =
+ boost::multi_index::detail::make_obj_guard( *this,
+ &auto_buffer::deallocate,
+ new_buffer,
+ r.size() );
+ copy_impl( r.begin(), r.end(), new_buffer );
+ guard.dismiss();
+ buffer_ = new_buffer;
+ members_.capacity_ = r.size();
+ size_ = members_.capacity_;
+ }
+ }
+
+ BOOST_ASSERT( size() == r.size() );
+ BOOST_ASSERT( is_valid() );
+ return *this;
+ }
+
+ explicit auto_buffer( size_type capacity_arg )
+ : members_( (std::max)(capacity_arg, size_type(N)) ),
+ buffer_( allocate(members_.capacity_) ),
+ size_( 0 )
+ {
+ BOOST_ASSERT( is_valid() );
+ }
+
+ auto_buffer( size_type size_arg, optimized_const_reference init_value )
+ : members_( (std::max)(size_arg, size_type(N)) ),
+ buffer_( allocate(members_.capacity_) ),
+ size_( 0 )
+ {
+ std::uninitialized_fill( buffer_, buffer_ + size_arg, init_value );
+ size_ = size_arg;
+ BOOST_ASSERT( is_valid() );
+ }
+
+ auto_buffer( size_type capacity_arg, const allocator_type& a )
+ : allocator_type( a ),
+ members_( (std::max)(capacity_arg, size_type(N)) ),
+ buffer_( allocate(members_.capacity_) ),
+ size_( 0 )
+ {
+ BOOST_ASSERT( is_valid() );
+ }
+
+ auto_buffer( size_type size_arg, optimized_const_reference init_value,
+ const allocator_type& a )
+ : allocator_type( a ),
+ members_( (std::max)(size_arg, size_type(N)) ),
+ buffer_( allocate(members_.capacity_) ),
+ size_( 0 )
+ {
+ std::uninitialized_fill( buffer_, buffer_ + size_arg, init_value );
+ size_ = size_arg;
+ BOOST_ASSERT( is_valid() );
+ }
+
+ template< class ForwardIterator >
+ auto_buffer( ForwardIterator begin_arg, ForwardIterator end_arg )
+ :
+ members_( std::distance(begin_arg, end_arg) ),
+ buffer_( allocate(members_.capacity_) ),
+ size_( 0 )
+ {
+ copy_impl( begin_arg, end_arg, buffer_ );
+ size_ = members_.capacity_;
+ if( members_.capacity_ < N )
+ members_.capacity_ = N;
+ BOOST_ASSERT( is_valid() );
+ }
+
+ template< class ForwardIterator >
+ auto_buffer( ForwardIterator begin_arg, ForwardIterator end_arg,
+ const allocator_type& a )
+ : allocator_type( a ),
+ members_( std::distance(begin_arg, end_arg) ),
+ buffer_( allocate(members_.capacity_) ),
+ size_( 0 )
+ {
+ copy_impl( begin_arg, end_arg, buffer_ );
+ size_ = members_.capacity_;
+ if( members_.capacity_ < N )
+ members_.capacity_ = N;
+ BOOST_ASSERT( is_valid() );
+ }
+
+ ~auto_buffer()
+ {
+ BOOST_ASSERT( is_valid() );
+ if( buffer_ ) // do we need this check? Yes, but only
+ // for N = 0u + local instances in one_sided_swap()
+ auto_buffer_destroy( boost::has_trivial_destructor<T>() );
+ }
+
+ public:
+ bool empty() const
+ {
+ return size_ == 0;
+ }
+
+ bool full() const
+ {
+ return size_ == members_.capacity_;
+ }
+
+ bool is_on_stack() const
+ {
+ return members_.capacity_ <= N;
+ }
+
+ size_type size() const
+ {
+ return size_;
+ }
+
+ size_type capacity() const
+ {
+ return members_.capacity_;
+ }
+
+ public:
+ pointer data()
+ {
+ return buffer_;
+ }
+
+ const_pointer data() const
+ {
+ return buffer_;
+ }
+
+ allocator_type& get_allocator()
+ {
+ return static_cast<allocator_type&>(*this);
+ }
+
+ const allocator_type& get_allocator() const
+ {
+ return static_cast<const allocator_type&>(*this);
+ }
+
+ public:
+ iterator begin()
+ {
+ return buffer_;
+ }
+
+ const_iterator begin() const
+ {
+ return buffer_;
+ }
+
+ iterator end()
+ {
+ return buffer_ + size_;
+ }
+
+ const_iterator end() const
+ {
+ return buffer_ + size_;
+ }
+
+ reverse_iterator rbegin()
+ {
+ return reverse_iterator(end());
+ }
+
+ const_reverse_iterator rbegin() const
+ {
+ return const_reverse_iterator(end());
+ }
+
+ reverse_iterator rend()
+ {
+ return reverse_iterator(begin());
+ }
+
+ const_reverse_iterator rend() const
+ {
+ return const_reverse_iterator(begin());
+ }
+
+ const_iterator cbegin() const
+ {
+ return const_cast<const auto_buffer*>(this)->begin();
+ }
+
+ const_iterator cend() const
+ {
+ return const_cast<const auto_buffer*>(this)->end();
+ }
+
+ const_reverse_iterator crbegin() const
+ {
+ return const_cast<const auto_buffer*>(this)->rbegin();
+ }
+
+ const_reverse_iterator crend() const
+ {
+ return const_cast<const auto_buffer*>(this)->rend();
+ }
+
+ public:
+ reference front()
+ {
+ return buffer_[0];
+ }
+
+ optimized_const_reference front() const
+ {
+ return buffer_[0];
+ }
+
+ reference back()
+ {
+ return buffer_[size_-1];
+ }
+
+ optimized_const_reference back() const
+ {
+ return buffer_[size_-1];
+ }
+
+ reference operator[]( size_type n )
+ {
+ BOOST_ASSERT( n < size_ );
+ return buffer_[n];
+ }
+
+ optimized_const_reference operator[]( size_type n ) const
+ {
+ BOOST_ASSERT( n < size_ );
+ return buffer_[n];
+ }
+
+ void unchecked_push_back()
+ {
+ BOOST_ASSERT( !full() );
+ new (buffer_ + size_) T;
+ ++size_;
+ }
+
+ void unchecked_push_back_n( size_type n )
+ {
+ BOOST_ASSERT( size_ + n <= members_.capacity_ );
+ unchecked_push_back_n( n, boost::has_trivial_assign<T>() );
+ }
+
+ void unchecked_push_back( optimized_const_reference x ) // non-growing
+ {
+ BOOST_ASSERT( !full() );
+ new (buffer_ + size_) T( x );
+ ++size_;
+ }
+
+ template< class ForwardIterator >
+ void unchecked_push_back( ForwardIterator begin_arg,
+ ForwardIterator end_arg ) // non-growing
+ {
+ BOOST_ASSERT( size_ + std::distance(begin_arg, end_arg) <= members_.capacity_ );
+ copy_impl( begin_arg, end_arg, buffer_ + size_ );
+ size_ += std::distance(begin_arg, end_arg);
+ }
+
+ void reserve_precisely( size_type n )
+ {
+ BOOST_ASSERT( members_.capacity_ >= N );
+
+ if( n <= members_.capacity_ )
+ return;
+ reserve_impl( n );
+ BOOST_ASSERT( members_.capacity_ == n );
+ }
+
+ void reserve( size_type n ) // strong
+ {
+ BOOST_ASSERT( members_.capacity_ >= N );
+
+ if( n <= members_.capacity_ )
+ return;
+
+ reserve_impl( new_capacity_impl( n ) );
+ BOOST_ASSERT( members_.capacity_ >= n );
+ }
+
+ void push_back()
+ {
+ if( size_ != members_.capacity_ )
+ {
+ unchecked_push_back();
+ }
+ else
+ {
+ reserve( size_ + 1u );
+ unchecked_push_back();
+ }
+ }
+
+ void push_back( optimized_const_reference x )
+ {
+ if( size_ != members_.capacity_ )
+ {
+ unchecked_push_back( x );
+ }
+ else
+ {
+ reserve( size_ + 1u );
+ unchecked_push_back( x );
+ }
+ }
+
+ template< class ForwardIterator >
+ void push_back( ForwardIterator begin_arg, ForwardIterator end_arg )
+ {
+ difference_type diff = std::distance(begin_arg, end_arg);
+ if( size_ + diff > members_.capacity_ )
+ reserve( size_ + diff );
+ unchecked_push_back( begin_arg, end_arg );
+ }
+
+ iterator insert( const_iterator before, optimized_const_reference x ) // basic
+ {
+ // @todo: consider if we want to support x in 'this'
+ if( size_ < members_.capacity_ )
+ {
+ bool is_back_insertion = before == cend();
+ iterator where = const_cast<T*>(before);
+
+ if( !is_back_insertion )
+ {
+ grow_back_one();
+ std::copy( before, cend() - 1u, where + 1u );
+ *where = x;
+ BOOST_ASSERT( is_valid() );
+ }
+ else
+ {
+ unchecked_push_back( x );
+ }
+ return where;
+ }
+
+ auto_buffer temp( new_capacity_impl( size_ + 1u ) );
+ temp.unchecked_push_back( cbegin(), before );
+ iterator result = temp.end();
+ temp.unchecked_push_back( x );
+ temp.unchecked_push_back( before, cend() );
+ one_sided_swap( temp );
+ BOOST_ASSERT( is_valid() );
+ return result;
+ }
+
+ void insert( const_iterator before, size_type n,
+ optimized_const_reference x )
+ {
+ // @todo: see problems above
+ if( size_ + n <= members_.capacity_ )
+ {
+ grow_back( n );
+ iterator where = const_cast<T*>(before);
+ std::copy( before, cend() - n, where + n );
+ std::fill( where, where + n, x );
+ BOOST_ASSERT( is_valid() );
+ return;
+ }
+
+ auto_buffer temp( new_capacity_impl( size_ + n ) );
+ temp.unchecked_push_back( cbegin(), before );
+ std::uninitialized_fill_n( temp.end(), n, x );
+ temp.size_ += n;
+ temp.unchecked_push_back( before, cend() );
+ one_sided_swap( temp );
+ BOOST_ASSERT( is_valid() );
+ }
+
+ template< class ForwardIterator >
+ void insert( const_iterator before,
+ ForwardIterator begin_arg, ForwardIterator end_arg ) // basic
+ {
+ typedef typename std::iterator_traits<ForwardIterator>
+ ::iterator_category category;
+ insert_impl( before, begin_arg, end_arg, category() );
+ }
+
+ void pop_back()
+ {
+ BOOST_ASSERT( !empty() );
+ auto_buffer_destroy( buffer_ + size_ - 1, boost::has_trivial_destructor<T>() );
+ --size_;
+ }
+
+ void pop_back_n( size_type n )
+ {
+ BOOST_ASSERT( n <= size_ );
+ if( n )
+ {
+ destroy_back_n( n );
+ size_ -= n;
+ }
+ }
+
+ void clear()
+ {
+ pop_back_n( size_ );
+ }
+
+ iterator erase( const_iterator where )
+ {
+ BOOST_ASSERT( !empty() );
+ BOOST_ASSERT( cbegin() <= where );
+ BOOST_ASSERT( cend() > where );
+
+ unsigned elements = cend() - where - 1u;
+
+ if( elements > 0u )
+ {
+ const_iterator start = where + 1u;
+ std::copy( start, start + elements,
+ const_cast<T*>(where) );
+ }
+ pop_back();
+ BOOST_ASSERT( !full() );
+ iterator result = const_cast<T*>( where );
+ BOOST_ASSERT( result <= end() );
+ return result;
+ }
+
+ iterator erase( const_iterator from, const_iterator to )
+ {
+ BOOST_ASSERT( !(std::distance(from,to)>0) ||
+ !empty() );
+ BOOST_ASSERT( cbegin() <= from );
+ BOOST_ASSERT( cend() >= to );
+
+ unsigned elements = std::distance(to,cend());
+
+ if( elements > 0u )
+ {
+ BOOST_ASSERT( elements > 0u );
+ std::copy( to, to + elements,
+ const_cast<T*>(from) );
+ }
+ pop_back_n( std::distance(from,to) );
+ BOOST_ASSERT( !full() );
+ iterator result = const_cast<T*>( from );
+ BOOST_ASSERT( result <= end() );
+ return result;
+ }
+
+ void shrink_to_fit()
+ {
+ if( is_on_stack() || !GrowPolicy::should_shrink(size_,members_.capacity_) )
+ return;
+
+ reserve_impl( size_ );
+ members_.capacity_ = (std::max)(size_type(N),members_.capacity_);
+ BOOST_ASSERT( is_on_stack() || size_ == members_.capacity_ );
+ BOOST_ASSERT( !is_on_stack() || size_ <= members_.capacity_ );
+ }
+
+ pointer uninitialized_grow( size_type n ) // strong
+ {
+ if( size_ + n <= members_.capacity_ )
+ reserve( size_ + n );
+
+ pointer res = end();
+ size_ += n;
+ return res;
+ }
+
+ void uninitialized_shrink( size_type n ) // nothrow
+ {
+ // @remark: test for wrap-around
+ BOOST_ASSERT( size_ - n <= members_.capacity_ );
+ size_ -= n;
+ }
+
+ void uninitialized_resize( size_type n )
+ {
+ if( n > size() )
+ uninitialized_grow( n - size() );
+ else if( n < size() )
+ uninitialized_shrink( size() - n );
+
+ BOOST_ASSERT( size() == n );
+ }
+
+ // nothrow - if both buffer are on the heap, or
+ // - if one buffer is on the heap and one has
+ // 'has_allocated_buffer() == false', or
+ // - if copy-construction cannot throw
+ // basic - otherwise (better guarantee impossible)
+ // requirement: the allocator must be no-throw-swappable
+ void swap( auto_buffer& r )
+ {
+ bool on_stack = is_on_stack();
+ bool r_on_stack = r.is_on_stack();
+ bool both_on_heap = !on_stack && !r_on_stack;
+ if( both_on_heap )
+ {
+ boost::swap( get_allocator(), r.get_allocator() );
+ boost::swap( members_.capacity_, r.members_.capacity_ );
+ boost::swap( buffer_, r.buffer_ );
+ boost::swap( size_, r.size_ );
+ BOOST_ASSERT( is_valid() );
+ BOOST_ASSERT( r.is_valid() );
+ return;
+ }
+
+ BOOST_ASSERT( on_stack || r_on_stack );
+ bool exactly_one_on_stack = (on_stack && !r_on_stack) ||
+ (!on_stack && r_on_stack);
+
+ //
+ // Remark: we now know that we can copy into
+ // the unused stack buffer.
+ //
+ if( exactly_one_on_stack )
+ {
+ auto_buffer* one_on_stack = on_stack ? this : &r;
+ auto_buffer* other = on_stack ? &r : this;
+ pointer new_buffer = static_cast<T*>(other->members_.address());
+ copy_impl( one_on_stack->begin(), one_on_stack->end(),
+ new_buffer ); // strong
+ one_on_stack->~auto_buffer(); // nothrow
+ boost::swap( get_allocator(), r.get_allocator() ); // assume nothrow
+ boost::swap( members_.capacity_, r.members_.capacity_ );
+ boost::swap( size_, r.size_ );
+ one_on_stack->buffer_ = other->buffer_;
+ other->buffer_ = new_buffer;
+ BOOST_ASSERT( other->is_on_stack() );
+ BOOST_ASSERT( !one_on_stack->is_on_stack() );
+ BOOST_ASSERT( is_valid() );
+ BOOST_ASSERT( r.is_valid() );
+ return;
+ }
+
+ BOOST_ASSERT( on_stack && r_on_stack );
+ swap_helper( *this, r, boost::has_trivial_assign<T>() );
+ BOOST_ASSERT( is_valid() );
+ BOOST_ASSERT( r.is_valid() );
+ }
+
+ private:
+ typedef boost::aligned_storage< N * sizeof(T),
+ boost::alignment_of<T>::value >
+ storage;
+
+ struct members_type : storage /* to enable EBO */
+ {
+ size_type capacity_;
+
+ members_type( size_type capacity )
+ : capacity_(capacity)
+ { }
+
+ void* address() const
+ { return const_cast<storage&>(static_cast<const storage&>(*this)).address(); }
+ };
+
+ members_type members_;
+ pointer buffer_;
+ size_type size_;
+
+ };
+
+ template< class T, class SBP, class GP, class A >
+ inline void swap( auto_buffer<T,SBP,GP,A>& l, auto_buffer<T,SBP,GP,A>& r )
+ {
+ l.swap( r );
+ }
+
+ template< class T, class SBP, class GP, class A >
+ inline bool operator==( const auto_buffer<T,SBP,GP,A>& l,
+ const auto_buffer<T,SBP,GP,A>& r )
+ {
+ if( l.size() != r.size() )
+ return false;
+ return std::equal( l.begin(), l.end(), r.begin() );
+ }
+
+ template< class T, class SBP, class GP, class A >
+ inline bool operator!=( const auto_buffer<T,SBP,GP,A>& l,
+ const auto_buffer<T,SBP,GP,A>& r )
+ {
+ return !(l == r);
+ }
+
+ template< class T, class SBP, class GP, class A >
+ inline bool operator<( const auto_buffer<T,SBP,GP,A>& l,
+ const auto_buffer<T,SBP,GP,A>& r )
+ {
+ return std::lexicographical_compare( l.begin(), l.end(),
+ r.begin(), r.end() );
+ }
+
+ template< class T, class SBP, class GP, class A >
+ inline bool operator>( const auto_buffer<T,SBP,GP,A>& l,
+ const auto_buffer<T,SBP,GP,A>& r )
+ {
+ return (r < l);
+ }
+
+ template< class T, class SBP, class GP, class A >
+ inline bool operator<=( const auto_buffer<T,SBP,GP,A>& l,
+ const auto_buffer<T,SBP,GP,A>& r )
+ {
+ return !(r > l);
+ }
+
+ template< class T, class SBP, class GP, class A >
+ inline bool operator>=( const auto_buffer<T,SBP,GP,A>& l,
+ const auto_buffer<T,SBP,GP,A>& r )
+ {
+ return !(l < r);
+ }
+
+} // namespace detail
+} // namespace signals2
+}
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/3rdParty/Boost/src/boost/signals2/detail/foreign_ptr.hpp b/3rdParty/Boost/src/boost/signals2/detail/foreign_ptr.hpp
new file mode 100644
index 0000000..4349b38
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/foreign_ptr.hpp
@@ -0,0 +1,185 @@
+
+// helper code for dealing with tracking non-boost shared_ptr/weak_ptr
+
+// Copyright Frank Mori Hess 2009.
+// 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)
+
+// See http://www.boost.org/libs/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_FOREIGN_PTR_HPP
+#define BOOST_SIGNALS2_FOREIGN_PTR_HPP
+
+#include <algorithm>
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/smart_ptr/bad_weak_ptr.hpp>
+#include <boost/utility/swap.hpp>
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+#include <memory>
+#endif
+
+namespace boost
+{
+ template<typename T> class shared_ptr;
+ template<typename T> class weak_ptr;
+
+ namespace signals2
+ {
+ template<typename WeakPtr> struct weak_ptr_traits
+ {};
+ template<typename T> struct weak_ptr_traits<boost::weak_ptr<T> >
+ {
+ typedef boost::shared_ptr<T> shared_type;
+ };
+#ifndef BOOST_NO_CXX11_SMART_PTR
+ template<typename T> struct weak_ptr_traits<std::weak_ptr<T> >
+ {
+ typedef std::shared_ptr<T> shared_type;
+ };
+#endif
+
+ template<typename SharedPtr> struct shared_ptr_traits
+ {};
+
+ template<typename T> struct shared_ptr_traits<boost::shared_ptr<T> >
+ {
+ typedef boost::weak_ptr<T> weak_type;
+ };
+#ifndef BOOST_NO_CXX11_SMART_PTR
+ template<typename T> struct shared_ptr_traits<std::shared_ptr<T> >
+ {
+ typedef std::weak_ptr<T> weak_type;
+ };
+#endif
+
+ namespace detail
+ {
+ struct foreign_shared_ptr_impl_base
+ {
+ virtual ~foreign_shared_ptr_impl_base() {}
+ virtual void* get() const = 0;
+ virtual foreign_shared_ptr_impl_base * clone() const = 0;
+ };
+
+ template<typename FSP>
+ class foreign_shared_ptr_impl: public foreign_shared_ptr_impl_base
+ {
+ public:
+ foreign_shared_ptr_impl(const FSP &p): _p(p)
+ {}
+ virtual void * get() const
+ {
+ return _p.get();
+ }
+ virtual foreign_shared_ptr_impl * clone() const
+ {
+ return new foreign_shared_ptr_impl(*this);
+ }
+ private:
+ FSP _p;
+ };
+
+ class foreign_void_shared_ptr
+ {
+ public:
+ foreign_void_shared_ptr():
+ _p(0)
+ {}
+ foreign_void_shared_ptr(const foreign_void_shared_ptr &other):
+ _p(other._p->clone())
+ {}
+ template<typename FSP>
+ explicit foreign_void_shared_ptr(const FSP &fsp):
+ _p(new foreign_shared_ptr_impl<FSP>(fsp))
+ {}
+ ~foreign_void_shared_ptr()
+ {
+ delete _p;
+ }
+ foreign_void_shared_ptr & operator=(const foreign_void_shared_ptr &other)
+ {
+ if(&other == this) return *this;
+ foreign_void_shared_ptr(other).swap(*this);
+ return *this;
+ }
+ void swap(foreign_void_shared_ptr &other)
+ {
+ boost::swap(_p, other._p);
+ }
+ private:
+ foreign_shared_ptr_impl_base *_p;
+ };
+
+ struct foreign_weak_ptr_impl_base
+ {
+ virtual ~foreign_weak_ptr_impl_base() {}
+ virtual foreign_void_shared_ptr lock() const = 0;
+ virtual bool expired() const = 0;
+ virtual foreign_weak_ptr_impl_base * clone() const = 0;
+ };
+
+ template<typename FWP>
+ class foreign_weak_ptr_impl: public foreign_weak_ptr_impl_base
+ {
+ public:
+ foreign_weak_ptr_impl(const FWP &p): _p(p)
+ {}
+ virtual foreign_void_shared_ptr lock() const
+ {
+ return foreign_void_shared_ptr(_p.lock());
+ }
+ virtual bool expired() const
+ {
+ return _p.expired();
+ }
+ virtual foreign_weak_ptr_impl * clone() const
+ {
+ return new foreign_weak_ptr_impl(*this);
+ }
+ private:
+ FWP _p;
+ };
+
+ class foreign_void_weak_ptr
+ {
+ public:
+ foreign_void_weak_ptr()
+ {}
+ foreign_void_weak_ptr(const foreign_void_weak_ptr &other):
+ _p(other._p->clone())
+ {}
+ template<typename FWP>
+ explicit foreign_void_weak_ptr(const FWP &fwp):
+ _p(new foreign_weak_ptr_impl<FWP>(fwp))
+ {}
+ foreign_void_weak_ptr & operator=(const foreign_void_weak_ptr &other)
+ {
+ if(&other == this) return *this;
+ foreign_void_weak_ptr(other).swap(*this);
+ return *this;
+ }
+ void swap(foreign_void_weak_ptr &other)
+ {
+ boost::swap(_p, other._p);
+ }
+ foreign_void_shared_ptr lock() const
+ {
+ return _p->lock();
+ }
+ bool expired() const
+ {
+ return _p->expired();
+ }
+ private:
+ boost::scoped_ptr<foreign_weak_ptr_impl_base> _p;
+ };
+ } // namespace detail
+
+ } // namespace signals2
+} // namespace boost
+
+#endif // BOOST_SIGNALS2_FOREIGN_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/lwm_nop.hpp b/3rdParty/Boost/src/boost/signals2/detail/lwm_nop.hpp
new file mode 100644
index 0000000..2b70544
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/lwm_nop.hpp
@@ -0,0 +1,38 @@
+//
+// boost/signals2/detail/lwm_nop.hpp
+//
+// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+// Copyright (c) 2008 Frank Mori Hess
+//
+// 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_SIGNALS2_LWM_NOP_HPP
+#define BOOST_SIGNALS2_LWM_NOP_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+
+#include <boost/signals2/dummy_mutex.hpp>
+
+namespace boost
+{
+
+namespace signals2
+{
+
+class mutex: public dummy_mutex
+{
+};
+
+} // namespace signals2
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SIGNALS2_LWM_NOP_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/lwm_pthreads.hpp b/3rdParty/Boost/src/boost/signals2/detail/lwm_pthreads.hpp
new file mode 100644
index 0000000..fb0dd66
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/lwm_pthreads.hpp
@@ -0,0 +1,78 @@
+//
+// boost/signals2/detail/lwm_pthreads.hpp
+//
+// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+// Copyright (c) 2008 Frank Mori Hess
+//
+// 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_SIGNALS2_LWM_PTHREADS_HPP
+#define BOOST_SIGNALS2_LWM_PTHREADS_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/assert.hpp>
+#include <pthread.h>
+
+namespace boost
+{
+
+namespace signals2
+{
+
+class mutex
+{
+private:
+
+ pthread_mutex_t m_;
+
+ mutex(mutex const &);
+ mutex & operator=(mutex const &);
+
+public:
+
+ mutex()
+ {
+
+// HPUX 10.20 / DCE has a nonstandard pthread_mutex_init
+
+#if defined(__hpux) && defined(_DECTHREADS_)
+ BOOST_VERIFY(pthread_mutex_init(&m_, pthread_mutexattr_default) == 0);
+#else
+ BOOST_VERIFY(pthread_mutex_init(&m_, 0) == 0);
+#endif
+ }
+
+ ~mutex()
+ {
+ BOOST_VERIFY(pthread_mutex_destroy(&m_) == 0);
+ }
+
+ void lock()
+ {
+ BOOST_VERIFY(pthread_mutex_lock(&m_) == 0);
+ }
+
+ bool try_lock()
+ {
+ return pthread_mutex_trylock(&m_) == 0;
+ }
+
+ void unlock()
+ {
+ BOOST_VERIFY(pthread_mutex_unlock(&m_) == 0);
+ }
+};
+
+} // namespace signals2
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SIGNALS2_LWM_PTHREADS_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/lwm_win32_cs.hpp b/3rdParty/Boost/src/boost/signals2/detail/lwm_win32_cs.hpp
new file mode 100644
index 0000000..d1c1965
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/lwm_win32_cs.hpp
@@ -0,0 +1,120 @@
+//
+// boost/signals2/detail/lwm_win32_cs.hpp
+//
+// Copyright (c) 2002, 2003 Peter Dimov
+// Copyright (c) 2008 Frank Mori Hess
+// Copyright (c) Microsoft Corporation 2014
+//
+// 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_SIGNALS2_LWM_WIN32_CS_HPP
+#define BOOST_SIGNALS2_LWM_WIN32_CS_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/assert.hpp>
+
+#ifdef BOOST_USE_WINDOWS_H
+# include <windows.h>
+#endif
+
+#include <boost/predef/platform.h>
+
+namespace boost
+{
+
+namespace signals2
+{
+
+#ifndef BOOST_USE_WINDOWS_H
+
+struct critical_section
+{
+ struct critical_section_debug * DebugInfo;
+ long LockCount;
+ long RecursionCount;
+ void * OwningThread;
+ void * LockSemaphore;
+#if defined(_WIN64)
+ unsigned __int64 SpinCount;
+#else
+ unsigned long SpinCount;
+#endif
+};
+
+#if BOOST_PLAT_WINDOWS_RUNTIME
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(critical_section *, unsigned long, unsigned long);
+#else
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
+#endif
+extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *);
+extern "C" __declspec(dllimport) bool __stdcall TryEnterCriticalSection(critical_section *);
+extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *);
+extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *);
+
+#else
+
+typedef ::CRITICAL_SECTION critical_section;
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
+class mutex
+{
+private:
+
+ critical_section cs_;
+
+ mutex(mutex const &);
+ mutex & operator=(mutex const &);
+
+public:
+
+ mutex()
+ {
+#if BOOST_PLAT_WINDOWS_RUNTIME
+ InitializeCriticalSectionEx(&cs_, 4000, 0);
+#else
+ InitializeCriticalSection(&cs_);
+#endif
+ }
+
+ ~mutex()
+ {
+ DeleteCriticalSection(&cs_);
+ }
+
+ void lock()
+ {
+ EnterCriticalSection(&cs_);
+ }
+// TryEnterCriticalSection only exists on Windows NT 4.0 and later
+#if (defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400))
+ bool try_lock()
+ {
+ return TryEnterCriticalSection(&cs_) != 0;
+ }
+#else
+ bool try_lock()
+ {
+ BOOST_ASSERT(false);
+ return false;
+ }
+#endif
+ void unlock()
+ {
+ LeaveCriticalSection(&cs_);
+ }
+};
+
+} // namespace signals2
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SIGNALS2_LWM_WIN32_CS_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/null_output_iterator.hpp b/3rdParty/Boost/src/boost/signals2/detail/null_output_iterator.hpp
new file mode 100644
index 0000000..9e98695
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/null_output_iterator.hpp
@@ -0,0 +1,34 @@
+/*
+ An output iterator which simply discards output.
+*/
+// Copyright Frank Mori Hess 2008.
+// 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)
+
+// See http://www.boost.org/libs/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_NULL_OUTPUT_ITERATOR_HPP
+#define BOOST_SIGNALS2_NULL_OUTPUT_ITERATOR_HPP
+
+#include <boost/function_output_iterator.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ class does_nothing
+ {
+ public:
+ template<typename T>
+ void operator()(const T&) const
+ {}
+ };
+ typedef boost::function_output_iterator<does_nothing> null_output_iterator;
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+#endif // BOOST_SIGNALS2_NULL_OUTPUT_ITERATOR_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/preprocessed_arg_type.hpp b/3rdParty/Boost/src/boost/signals2/detail/preprocessed_arg_type.hpp
new file mode 100644
index 0000000..02717c9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/preprocessed_arg_type.hpp
@@ -0,0 +1,34 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2009.
+// Copyright Timmo Stange 2007.
+// 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_SIGNALS2_PREPROCESSED_ARG_TYPE_HPP
+#define BOOST_SIGNALS2_PREPROCESSED_ARG_TYPE_HPP
+
+#include <boost/preprocessor/repetition.hpp>
+#include <boost/signals2/detail/signals_common_macros.hpp>
+
+#define BOOST_PP_ITERATION_LIMITS (0, BOOST_PP_INC(BOOST_SIGNALS2_MAX_ARGS))
+#define BOOST_PP_FILENAME_1 <boost/signals2/detail/preprocessed_arg_type_template.hpp>
+#include BOOST_PP_ITERATE()
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ struct std_functional_base
+ {};
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+#endif // BOOST_SIGNALS2_PREPROCESSED_ARG_TYPE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/preprocessed_arg_type_template.hpp b/3rdParty/Boost/src/boost/signals2/detail/preprocessed_arg_type_template.hpp
new file mode 100644
index 0000000..4f39433
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/preprocessed_arg_type_template.hpp
@@ -0,0 +1,39 @@
+// Copyright Frank Mori Hess 2009
+//
+// 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 is included iteratively, and should not be protected from multiple inclusion
+
+#define BOOST_SIGNALS2_NUM_ARGS BOOST_PP_ITERATION()
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ template<unsigned n BOOST_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_ARGS_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_PREPROCESSED_ARG_N_TYPE_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS);
+
+// template<typename T1, typename T2, ... , typename TN> class preprocessed_arg_typeN<n, T1, T2, ..., TN>{...} ...
+#define BOOST_SIGNALS2_PREPROCESSED_ARG_TYPE_CLASS_TEMPLATE_SPECIALIZATION(z, n, data) \
+ template<BOOST_SIGNALS2_ARGS_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)> \
+ class BOOST_SIGNALS2_PREPROCESSED_ARG_N_TYPE_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)<n, \
+ BOOST_SIGNALS2_ARGS_TEMPLATE_INSTANTIATION(BOOST_SIGNALS2_NUM_ARGS)> \
+ { \
+ public: \
+ typedef BOOST_PP_CAT(T, BOOST_PP_INC(n)) type; \
+ };
+ BOOST_PP_REPEAT(BOOST_SIGNALS2_NUM_ARGS, BOOST_SIGNALS2_PREPROCESSED_ARG_TYPE_CLASS_TEMPLATE_SPECIALIZATION, ~)
+
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+#undef BOOST_SIGNALS2_NUM_ARGS
diff --git a/3rdParty/Boost/src/boost/signals2/detail/replace_slot_function.hpp b/3rdParty/Boost/src/boost/signals2/detail/replace_slot_function.hpp
new file mode 100644
index 0000000..de8f425
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/replace_slot_function.hpp
@@ -0,0 +1,32 @@
+// Copyright Frank Mori Hess 2007-2009
+//
+// 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_SIGNALS2_DETAIL_REPLACE_SLOT_FUNCTION_HPP
+#define BOOST_SIGNALS2_DETAIL_REPLACE_SLOT_FUNCTION_HPP
+
+#include <boost/signals2/slot_base.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ template<typename ResultSlot, typename SlotIn, typename SlotFunction>
+ ResultSlot replace_slot_function(const SlotIn &slot_in, const SlotFunction &fun)
+ {
+ ResultSlot slot(fun);
+ slot.track(slot_in);
+ return slot;
+ }
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+#endif // BOOST_SIGNALS2_DETAIL_REPLACE_SLOT_FUNCTION_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/result_type_wrapper.hpp b/3rdParty/Boost/src/boost/signals2/detail/result_type_wrapper.hpp
new file mode 100644
index 0000000..35dea7c
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/result_type_wrapper.hpp
@@ -0,0 +1,72 @@
+// Boost.Signals2 library
+
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2007. 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_SIGNALS2_RESULT_TYPE_WRAPPER_HPP
+#define BOOST_SIGNALS2_RESULT_TYPE_WRAPPER_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+ namespace signals2 {
+ namespace detail {
+ // A placeholder for void on compilers that don't support void returns
+ struct void_type {};
+
+ // Replaces void with void_type
+ template<typename R>
+ struct nonvoid {
+ typedef R type;
+ };
+ template<>
+ struct nonvoid<void> {
+ typedef void_type type;
+ };
+
+ // Replaces void with void_type only if compiler doesn't support void returns
+ template<typename R>
+ struct result_type_wrapper {
+ typedef R type;
+ };
+#ifdef BOOST_NO_VOID_RETURNS
+ template<>
+ struct result_type_wrapper<void> {
+ typedef void_type type;
+ };
+#endif
+
+ // specialization deals with possible void return from combiners
+ template<typename R> class combiner_invoker
+ {
+ public:
+ typedef R result_type;
+ template<typename Combiner, typename InputIterator>
+ result_type operator()(Combiner &combiner,
+ InputIterator first, InputIterator last) const
+ {
+ return combiner(first, last);
+ }
+ };
+ template<> class combiner_invoker<void>
+ {
+ public:
+ typedef result_type_wrapper<void>::type result_type;
+ template<typename Combiner, typename InputIterator>
+ result_type operator()(Combiner &combiner,
+ InputIterator first, InputIterator last) const
+ {
+ combiner(first, last);
+ return result_type();
+ }
+ };
+ } // end namespace detail
+ } // end namespace signals2
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_RESULT_TYPE_WRAPPER_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/signal_template.hpp b/3rdParty/Boost/src/boost/signals2/detail/signal_template.hpp
new file mode 100644
index 0000000..bb5d3a4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/signal_template.hpp
@@ -0,0 +1,859 @@
+/*
+ Template for Signa1, Signal2, ... classes that support signals
+ with 1, 2, ... parameters
+
+ Begin: 2007-01-23
+*/
+// Copyright Frank Mori Hess 2007-2008
+//
+// 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)
+
+// This file is included iteratively, and should not be protected from multiple inclusion
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_SIGNALS2_NUM_ARGS BOOST_PP_ITERATION()
+#else
+#define BOOST_SIGNALS2_NUM_ARGS 1
+#endif
+
+// R, T1, T2, ..., TN, Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION \
+ BOOST_SIGNALS2_SIGNATURE_TEMPLATE_INSTANTIATION(BOOST_SIGNALS2_NUM_ARGS), \
+ Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ // helper for bound_extended_slot_function that handles specialization for void return
+ template<typename R>
+ class BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_INVOKER_N(BOOST_SIGNALS2_NUM_ARGS)
+ {
+ public:
+ typedef R result_type;
+ template<typename ExtendedSlotFunction BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_ARGS_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ result_type operator()(ExtendedSlotFunction &func, const connection &conn
+ BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_FULL_REF_ARGS(BOOST_SIGNALS2_NUM_ARGS)) const
+ {
+ return func(conn BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ };
+#ifdef BOOST_NO_VOID_RETURNS
+ template<>
+ class BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_INVOKER_N(BOOST_SIGNALS2_NUM_ARGS)<void>
+ {
+ public:
+ typedef result_type_wrapper<void>::type result_type;
+ template<typename ExtendedSlotFunction BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_ARGS_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ result_type operator()(ExtendedSlotFunction &func, const connection &conn
+ BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_FULL_REF_ARGS(BOOST_SIGNALS2_NUM_ARGS)) const
+ {
+ func(conn BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ return result_type();
+ }
+ };
+#endif
+// wrapper around an signalN::extended_slot_function which binds the
+// connection argument so it looks like a normal
+// signalN::slot_function
+
+ template<typename ExtendedSlotFunction>
+ class BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_N(BOOST_SIGNALS2_NUM_ARGS)
+ {
+ public:
+ typedef typename result_type_wrapper<typename ExtendedSlotFunction::result_type>::type result_type;
+ BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_N(BOOST_SIGNALS2_NUM_ARGS)(const ExtendedSlotFunction &fun):
+ _fun(fun), _connection(new connection)
+ {}
+ void set_connection(const connection &conn)
+ {
+ *_connection = conn;
+ }
+
+#if BOOST_SIGNALS2_NUM_ARGS > 0
+ template<BOOST_SIGNALS2_ARGS_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+#endif // BOOST_SIGNALS2_NUM_ARGS > 0
+ result_type operator()(BOOST_SIGNALS2_FULL_REF_ARGS(BOOST_SIGNALS2_NUM_ARGS))
+ {
+ return BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_INVOKER_N(BOOST_SIGNALS2_NUM_ARGS)
+ <typename ExtendedSlotFunction::result_type>()
+ (_fun, *_connection BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ // const overload
+#if BOOST_SIGNALS2_NUM_ARGS > 0
+ template<BOOST_SIGNALS2_ARGS_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+#endif // BOOST_SIGNALS2_NUM_ARGS > 0
+ result_type operator()(BOOST_SIGNALS2_FULL_REF_ARGS(BOOST_SIGNALS2_NUM_ARGS)) const
+ {
+ return BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_INVOKER_N(BOOST_SIGNALS2_NUM_ARGS)
+ <typename ExtendedSlotFunction::result_type>()
+ (_fun, *_connection BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ template<typename T>
+ bool operator==(const T &other) const
+ {
+ return _fun == other;
+ }
+ private:
+ BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_N(BOOST_SIGNALS2_NUM_ARGS)()
+ {}
+
+ ExtendedSlotFunction _fun;
+ boost::shared_ptr<connection> _connection;
+ };
+
+ template<BOOST_SIGNALS2_SIGNAL_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS);
+
+ template<BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION
+ {
+ public:
+ typedef SlotFunction slot_function_type;
+ // typedef slotN<Signature, SlotFunction> slot_type;
+ typedef BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNATURE_TEMPLATE_INSTANTIATION(BOOST_SIGNALS2_NUM_ARGS),
+ slot_function_type> slot_type;
+ typedef ExtendedSlotFunction extended_slot_function_type;
+ // typedef slotN+1<R, const connection &, T1, T2, ..., TN, extended_slot_function_type> extended_slot_type;
+ typedef BOOST_SIGNALS2_EXTENDED_SLOT_TYPE(BOOST_SIGNALS2_NUM_ARGS) extended_slot_type;
+ typedef typename nonvoid<typename slot_function_type::result_type>::type nonvoid_slot_result_type;
+ private:
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ class slot_invoker;
+#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ typedef variadic_slot_invoker<nonvoid_slot_result_type, Args...> slot_invoker;
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ typedef slot_call_iterator_cache<nonvoid_slot_result_type, slot_invoker> slot_call_iterator_cache_type;
+ typedef typename group_key<Group>::type group_key_type;
+ typedef shared_ptr<connection_body<group_key_type, slot_type, Mutex> > connection_body_type;
+ typedef grouped_list<Group, GroupCompare, connection_body_type> connection_list_type;
+ typedef BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_N(BOOST_SIGNALS2_NUM_ARGS)<extended_slot_function_type>
+ bound_extended_slot_function_type;
+ public:
+ typedef Combiner combiner_type;
+ typedef typename result_type_wrapper<typename combiner_type::result_type>::type result_type;
+ typedef Group group_type;
+ typedef GroupCompare group_compare_type;
+ typedef typename detail::slot_call_iterator_t<slot_invoker,
+ typename connection_list_type::iterator, connection_body<group_key_type, slot_type, Mutex> > slot_call_iterator;
+
+ BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)(const combiner_type &combiner_arg,
+ const group_compare_type &group_compare):
+ _shared_state(new invocation_state(connection_list_type(group_compare), combiner_arg)),
+ _garbage_collector_it(_shared_state->connection_bodies().end())
+ {}
+ // connect slot
+ connection connect(const slot_type &slot, connect_position position = at_back)
+ {
+ unique_lock<mutex_type> lock(_mutex);
+ return nolock_connect(slot, position);
+ }
+ connection connect(const group_type &group,
+ const slot_type &slot, connect_position position = at_back)
+ {
+ unique_lock<Mutex> lock(_mutex);
+ return nolock_connect(group, slot, position);
+ }
+ // connect extended slot
+ connection connect_extended(const extended_slot_type &ext_slot, connect_position position = at_back)
+ {
+ unique_lock<mutex_type> lock(_mutex);
+ bound_extended_slot_function_type bound_slot(ext_slot.slot_function());
+ slot_type slot = replace_slot_function<slot_type>(ext_slot, bound_slot);
+ connection conn = nolock_connect(slot, position);
+ bound_slot.set_connection(conn);
+ return conn;
+ }
+ connection connect_extended(const group_type &group,
+ const extended_slot_type &ext_slot, connect_position position = at_back)
+ {
+ unique_lock<Mutex> lock(_mutex);
+ bound_extended_slot_function_type bound_slot(ext_slot.slot_function());
+ slot_type slot = replace_slot_function<slot_type>(ext_slot, bound_slot);
+ connection conn = nolock_connect(group, slot, position);
+ bound_slot.set_connection(conn);
+ return conn;
+ }
+ // disconnect slot(s)
+ void disconnect_all_slots()
+ {
+ shared_ptr<invocation_state> local_state =
+ get_readable_state();
+ typename connection_list_type::iterator it;
+ for(it = local_state->connection_bodies().begin();
+ it != local_state->connection_bodies().end(); ++it)
+ {
+ (*it)->disconnect();
+ }
+ }
+ void disconnect(const group_type &group)
+ {
+ shared_ptr<invocation_state> local_state =
+ get_readable_state();
+ group_key_type group_key(grouped_slots, group);
+ typename connection_list_type::iterator it;
+ typename connection_list_type::iterator end_it =
+ local_state->connection_bodies().upper_bound(group_key);
+ for(it = local_state->connection_bodies().lower_bound(group_key);
+ it != end_it; ++it)
+ {
+ (*it)->disconnect();
+ }
+ }
+ template <typename T>
+ void disconnect(const T &slot)
+ {
+ typedef mpl::bool_<(is_convertible<T, group_type>::value)> is_group;
+ do_disconnect(slot, is_group());
+ }
+ // emit signal
+ result_type operator ()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS))
+ {
+ shared_ptr<invocation_state> local_state;
+ typename connection_list_type::iterator it;
+ {
+ unique_lock<mutex_type> list_lock(_mutex);
+ // only clean up if it is safe to do so
+ if(_shared_state.unique())
+ nolock_cleanup_connections(false, 1);
+ /* Make a local copy of _shared_state while holding mutex, so we are
+ thread safe against the combiner or connection list getting modified
+ during invocation. */
+ local_state = _shared_state;
+ }
+ slot_invoker invoker = slot_invoker(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ slot_call_iterator_cache_type cache(invoker);
+ invocation_janitor janitor(cache, *this, &local_state->connection_bodies());
+ return detail::combiner_invoker<typename combiner_type::result_type>()
+ (
+ local_state->combiner(),
+ slot_call_iterator(local_state->connection_bodies().begin(), local_state->connection_bodies().end(), cache),
+ slot_call_iterator(local_state->connection_bodies().end(), local_state->connection_bodies().end(), cache)
+ );
+ }
+ result_type operator ()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS)) const
+ {
+ shared_ptr<invocation_state> local_state;
+ typename connection_list_type::iterator it;
+ {
+ unique_lock<mutex_type> list_lock(_mutex);
+ // only clean up if it is safe to do so
+ if(_shared_state.unique())
+ nolock_cleanup_connections(false, 1);
+ /* Make a local copy of _shared_state while holding mutex, so we are
+ thread safe against the combiner or connection list getting modified
+ during invocation. */
+ local_state = _shared_state;
+ }
+ slot_invoker invoker = slot_invoker(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ slot_call_iterator_cache_type cache(invoker);
+ invocation_janitor janitor(cache, *this, &local_state->connection_bodies());
+ return detail::combiner_invoker<typename combiner_type::result_type>()
+ (
+ local_state->combiner(),
+ slot_call_iterator(local_state->connection_bodies().begin(), local_state->connection_bodies().end(), cache),
+ slot_call_iterator(local_state->connection_bodies().end(), local_state->connection_bodies().end(), cache)
+ );
+ }
+ std::size_t num_slots() const
+ {
+ shared_ptr<invocation_state> local_state =
+ get_readable_state();
+ typename connection_list_type::iterator it;
+ std::size_t count = 0;
+ for(it = local_state->connection_bodies().begin();
+ it != local_state->connection_bodies().end(); ++it)
+ {
+ if((*it)->connected()) ++count;
+ }
+ return count;
+ }
+ bool empty() const
+ {
+ shared_ptr<invocation_state> local_state =
+ get_readable_state();
+ typename connection_list_type::iterator it;
+ for(it = local_state->connection_bodies().begin();
+ it != local_state->connection_bodies().end(); ++it)
+ {
+ if((*it)->connected()) return false;
+ }
+ return true;
+ }
+ combiner_type combiner() const
+ {
+ unique_lock<mutex_type> lock(_mutex);
+ return _shared_state->combiner();
+ }
+ void set_combiner(const combiner_type &combiner_arg)
+ {
+ unique_lock<mutex_type> lock(_mutex);
+ if(_shared_state.unique())
+ _shared_state->combiner() = combiner_arg;
+ else
+ _shared_state.reset(new invocation_state(*_shared_state, combiner_arg));
+ }
+ private:
+ typedef Mutex mutex_type;
+
+ // slot_invoker is passed to slot_call_iterator_t to run slots
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ class slot_invoker
+ {
+ public:
+ typedef nonvoid_slot_result_type result_type;
+// typename add_reference<Tn>::type
+#define BOOST_SIGNALS2_ADD_REF_TYPE(z, n, data) \
+ typename add_reference<BOOST_PP_CAT(T, BOOST_PP_INC(n))>::type
+// typename add_reference<Tn>::type argn
+#define BOOST_SIGNALS2_ADD_REF_ARG(z, n, data) \
+ BOOST_SIGNALS2_ADD_REF_TYPE(~, n, ~) \
+ BOOST_SIGNALS2_SIGNATURE_ARG_NAME(~, n, ~)
+// typename add_reference<T1>::type arg1, typename add_reference<T2>::type arg2, ..., typename add_reference<Tn>::type argn
+#define BOOST_SIGNALS2_ADD_REF_ARGS(arity) \
+ BOOST_PP_ENUM(arity, BOOST_SIGNALS2_ADD_REF_ARG, ~)
+ slot_invoker(BOOST_SIGNALS2_ADD_REF_ARGS(BOOST_SIGNALS2_NUM_ARGS)) BOOST_PP_EXPR_IF(BOOST_SIGNALS2_NUM_ARGS, :)
+#undef BOOST_SIGNALS2_ADD_REF_ARGS
+
+// m_argn
+#define BOOST_SIGNALS2_M_ARG_NAME(z, n, data) BOOST_PP_CAT(m_arg, BOOST_PP_INC(n))
+// m_argn ( argn )
+#define BOOST_SIGNALS2_MISC_STATEMENT(z, n, data) \
+ BOOST_SIGNALS2_M_ARG_NAME(~, n, ~) ( BOOST_SIGNALS2_SIGNATURE_ARG_NAME(~, n, ~) )
+// m_arg1(arg1), m_arg2(arg2), ..., m_argn(argn)
+ BOOST_PP_ENUM(BOOST_SIGNALS2_NUM_ARGS, BOOST_SIGNALS2_MISC_STATEMENT, ~)
+#undef BOOST_SIGNALS2_MISC_STATEMENT
+ {}
+ result_type operator ()(const connection_body_type &connectionBody) const
+ {
+ result_type *resolver = 0;
+ return m_invoke(connectionBody,
+ resolver);
+ }
+ private:
+ // declare assignment operator private since this class might have reference or const members
+ slot_invoker & operator=(const slot_invoker &);
+
+#define BOOST_SIGNALS2_ADD_REF_M_ARG_STATEMENT(z, n, data) \
+ BOOST_SIGNALS2_ADD_REF_TYPE(~, n, ~) BOOST_SIGNALS2_M_ARG_NAME(~, n, ~) ;
+ BOOST_PP_REPEAT(BOOST_SIGNALS2_NUM_ARGS, BOOST_SIGNALS2_ADD_REF_M_ARG_STATEMENT, ~)
+#undef BOOST_SIGNALS2_ADD_REF_M_ARG_STATEMENT
+#undef BOOST_SIGNALS2_ADD_REF_ARG
+#undef BOOST_SIGNALS2_ADD_REF_TYPE
+
+// m_arg1, m_arg2, ..., m_argn
+#define BOOST_SIGNALS2_M_ARG_NAMES(arity) BOOST_PP_ENUM(arity, BOOST_SIGNALS2_M_ARG_NAME, ~)
+ result_type m_invoke(const connection_body_type &connectionBody,
+ const void_type *) const
+ {
+ connectionBody->slot.slot_function()(BOOST_SIGNALS2_M_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ return void_type();
+ }
+ result_type m_invoke(const connection_body_type &connectionBody, ...) const
+ {
+ return connectionBody->slot.slot_function()(BOOST_SIGNALS2_M_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ };
+#undef BOOST_SIGNALS2_M_ARG_NAMES
+#undef BOOST_SIGNALS2_M_ARG_NAME
+
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ // a struct used to optimize (minimize) the number of shared_ptrs that need to be created
+ // inside operator()
+ class invocation_state
+ {
+ public:
+ invocation_state(const connection_list_type &connections_in,
+ const combiner_type &combiner_in): _connection_bodies(new connection_list_type(connections_in)),
+ _combiner(new combiner_type(combiner_in))
+ {}
+ invocation_state(const invocation_state &other, const connection_list_type &connections_in):
+ _connection_bodies(new connection_list_type(connections_in)),
+ _combiner(other._combiner)
+ {}
+ invocation_state(const invocation_state &other, const combiner_type &combiner_in):
+ _connection_bodies(other._connection_bodies),
+ _combiner(new combiner_type(combiner_in))
+ {}
+ connection_list_type & connection_bodies() { return *_connection_bodies; }
+ const connection_list_type & connection_bodies() const { return *_connection_bodies; }
+ combiner_type & combiner() { return *_combiner; }
+ const combiner_type & combiner() const { return *_combiner; }
+ private:
+ invocation_state(const invocation_state &);
+
+ shared_ptr<connection_list_type> _connection_bodies;
+ shared_ptr<combiner_type> _combiner;
+ };
+ // Destructor of invocation_janitor does some cleanup when a signal invocation completes.
+ // Code can't be put directly in signal's operator() due to complications from void return types.
+ class invocation_janitor
+ {
+ public:
+ typedef BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) signal_type;
+ invocation_janitor
+ (
+ const slot_call_iterator_cache_type &cache,
+ const signal_type &sig,
+ const connection_list_type *connection_bodies
+ ):_cache(cache), _sig(sig), _connection_bodies(connection_bodies)
+ {}
+ ~invocation_janitor()
+ {
+ // force a full cleanup of disconnected slots if there are too many
+ if(_cache.disconnected_slot_count > _cache.connected_slot_count)
+ {
+ _sig.force_cleanup_connections(_connection_bodies);
+ }
+ }
+ private:
+ const slot_call_iterator_cache_type &_cache;
+ const signal_type &_sig;
+ const connection_list_type *_connection_bodies;
+ };
+
+ // clean up disconnected connections
+ void nolock_cleanup_connections_from(bool grab_tracked,
+ const typename connection_list_type::iterator &begin, unsigned count = 0) const
+ {
+ BOOST_ASSERT(_shared_state.unique());
+ typename connection_list_type::iterator it;
+ unsigned i;
+ for(it = begin, i = 0;
+ it != _shared_state->connection_bodies().end() && (count == 0 || i < count);
+ ++i)
+ {
+ bool connected;
+ {
+ unique_lock<connection_body_base> lock(**it);
+ if(grab_tracked)
+ (*it)->nolock_slot_expired();
+ connected = (*it)->nolock_nograb_connected();
+ }// scoped lock destructs here, safe to erase now
+ if(connected == false)
+ {
+ it = _shared_state->connection_bodies().erase((*it)->group_key(), it);
+ }else
+ {
+ ++it;
+ }
+ }
+ _garbage_collector_it = it;
+ }
+ // clean up a few connections in constant time
+ void nolock_cleanup_connections(bool grab_tracked, unsigned count) const
+ {
+ BOOST_ASSERT(_shared_state.unique());
+ typename connection_list_type::iterator begin;
+ if(_garbage_collector_it == _shared_state->connection_bodies().end())
+ {
+ begin = _shared_state->connection_bodies().begin();
+ }else
+ {
+ begin = _garbage_collector_it;
+ }
+ nolock_cleanup_connections_from(grab_tracked, begin, count);
+ }
+ /* Make a new copy of the slot list if it is currently being read somewhere else
+ */
+ void nolock_force_unique_connection_list()
+ {
+ if(_shared_state.unique() == false)
+ {
+ _shared_state.reset(new invocation_state(*_shared_state, _shared_state->connection_bodies()));
+ nolock_cleanup_connections_from(true, _shared_state->connection_bodies().begin());
+ }else
+ {
+ /* We need to try and check more than just 1 connection here to avoid corner
+ cases where certain repeated connect/disconnect patterns cause the slot
+ list to grow without limit. */
+ nolock_cleanup_connections(true, 2);
+ }
+ }
+ // force a full cleanup of the connection list
+ void force_cleanup_connections(const connection_list_type *connection_bodies) const
+ {
+ unique_lock<mutex_type> list_lock(_mutex);
+ // if the connection list passed in as a parameter is no longer in use,
+ // we don't need to do any cleanup.
+ if(&_shared_state->connection_bodies() != connection_bodies)
+ {
+ return;
+ }
+ if(_shared_state.unique() == false)
+ {
+ _shared_state.reset(new invocation_state(*_shared_state, _shared_state->connection_bodies()));
+ }
+ nolock_cleanup_connections_from(false, _shared_state->connection_bodies().begin());
+ }
+ shared_ptr<invocation_state> get_readable_state() const
+ {
+ unique_lock<mutex_type> list_lock(_mutex);
+ return _shared_state;
+ }
+ connection_body_type create_new_connection(const slot_type &slot)
+ {
+ nolock_force_unique_connection_list();
+ return connection_body_type(new connection_body<group_key_type, slot_type, Mutex>(slot));
+ }
+ void do_disconnect(const group_type &group, mpl::bool_<true> /* is_group */)
+ {
+ disconnect(group);
+ }
+ template<typename T>
+ void do_disconnect(const T &slot, mpl::bool_<false> /* is_group */)
+ {
+ shared_ptr<invocation_state> local_state =
+ get_readable_state();
+ typename connection_list_type::iterator it;
+ for(it = local_state->connection_bodies().begin();
+ it != local_state->connection_bodies().end(); ++it)
+ {
+ unique_lock<connection_body_base> lock(**it);
+ if((*it)->slot.slot_function() == slot)
+ {
+ (*it)->nolock_disconnect();
+ }else
+ {
+ // check for wrapped extended slot
+ bound_extended_slot_function_type *fp;
+ fp = (*it)->slot.slot_function().template target<bound_extended_slot_function_type>();
+ if(fp && *fp == slot)
+ {
+ (*it)->nolock_disconnect();
+ }
+ }
+ }
+ }
+ // connect slot
+ connection nolock_connect(const slot_type &slot, connect_position position)
+ {
+ connection_body_type newConnectionBody =
+ create_new_connection(slot);
+ group_key_type group_key;
+ if(position == at_back)
+ {
+ group_key.first = back_ungrouped_slots;
+ _shared_state->connection_bodies().push_back(group_key, newConnectionBody);
+ }else
+ {
+ group_key.first = front_ungrouped_slots;
+ _shared_state->connection_bodies().push_front(group_key, newConnectionBody);
+ }
+ newConnectionBody->set_group_key(group_key);
+ return connection(newConnectionBody);
+ }
+ connection nolock_connect(const group_type &group,
+ const slot_type &slot, connect_position position)
+ {
+ connection_body_type newConnectionBody =
+ create_new_connection(slot);
+ // update map to first connection body in group if needed
+ group_key_type group_key(grouped_slots, group);
+ newConnectionBody->set_group_key(group_key);
+ if(position == at_back)
+ {
+ _shared_state->connection_bodies().push_back(group_key, newConnectionBody);
+ }else // at_front
+ {
+ _shared_state->connection_bodies().push_front(group_key, newConnectionBody);
+ }
+ return connection(newConnectionBody);
+ }
+
+ // _shared_state is mutable so we can do force_cleanup_connections during a const invocation
+ mutable shared_ptr<invocation_state> _shared_state;
+ mutable typename connection_list_type::iterator _garbage_collector_it;
+ // connection list mutex must never be locked when attempting a blocking lock on a slot,
+ // or you could deadlock.
+ mutable mutex_type _mutex;
+ };
+
+ template<BOOST_SIGNALS2_SIGNAL_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_WEAK_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS);
+ }
+
+ template<BOOST_SIGNALS2_SIGNAL_TEMPLATE_DEFAULTED_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS);
+
+ template<BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION: public signal_base,
+ public detail::BOOST_SIGNALS2_STD_FUNCTIONAL_BASE
+ (typename detail::result_type_wrapper<typename Combiner::result_type>::type)
+ {
+ typedef detail::BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> impl_class;
+ public:
+ typedef detail::BOOST_SIGNALS2_WEAK_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> weak_signal_type;
+ friend class detail::BOOST_SIGNALS2_WEAK_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION>;
+
+ typedef SlotFunction slot_function_type;
+ // typedef slotN<Signature, SlotFunction> slot_type;
+ typedef typename impl_class::slot_type slot_type;
+ typedef typename impl_class::extended_slot_function_type extended_slot_function_type;
+ typedef typename impl_class::extended_slot_type extended_slot_type;
+ typedef typename slot_function_type::result_type slot_result_type;
+ typedef Combiner combiner_type;
+ typedef typename impl_class::result_type result_type;
+ typedef Group group_type;
+ typedef GroupCompare group_compare_type;
+ typedef typename impl_class::slot_call_iterator
+ slot_call_iterator;
+ typedef typename mpl::identity<BOOST_SIGNALS2_SIGNATURE_FUNCTION_TYPE(BOOST_SIGNALS2_NUM_ARGS)>::type signature_type;
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+// typedef Tn argn_type;
+#define BOOST_SIGNALS2_MISC_STATEMENT(z, n, data) \
+ typedef BOOST_PP_CAT(T, BOOST_PP_INC(n)) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(n)), _type);
+ BOOST_PP_REPEAT(BOOST_SIGNALS2_NUM_ARGS, BOOST_SIGNALS2_MISC_STATEMENT, ~)
+#undef BOOST_SIGNALS2_MISC_STATEMENT
+#if BOOST_SIGNALS2_NUM_ARGS == 1
+ typedef arg1_type argument_type;
+#elif BOOST_SIGNALS2_NUM_ARGS == 2
+ typedef arg1_type first_argument_type;
+ typedef arg2_type second_argument_type;
+#endif
+
+ template<unsigned n> class arg : public
+ detail::BOOST_SIGNALS2_PREPROCESSED_ARG_N_TYPE_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <n BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_ARGS_TEMPLATE_INSTANTIATION(BOOST_SIGNALS2_NUM_ARGS)>
+ {};
+
+ BOOST_STATIC_CONSTANT(int, arity = BOOST_SIGNALS2_NUM_ARGS);
+
+#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+ template<unsigned n> class arg
+ {
+ public:
+ typedef typename detail::variadic_arg_type<n, Args...>::type type;
+ };
+ BOOST_STATIC_CONSTANT(int, arity = sizeof...(Args));
+
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+ BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)(const combiner_type &combiner_arg = combiner_type(),
+ const group_compare_type &group_compare = group_compare_type()):
+ _pimpl(new impl_class(combiner_arg, group_compare))
+ {};
+ virtual ~BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)()
+ {
+ }
+
+ //move support
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)(
+ BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) && other)
+ {
+ using std::swap;
+ swap(_pimpl, other._pimpl);
+ };
+
+ BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) &
+ operator=(BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) && rhs)
+ {
+ if(this == &rhs)
+ {
+ return *this;
+ }
+ _pimpl.reset();
+ using std::swap;
+ swap(_pimpl, rhs._pimpl);
+ return *this;
+ }
+#endif // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+ connection connect(const slot_type &slot, connect_position position = at_back)
+ {
+ return (*_pimpl).connect(slot, position);
+ }
+ connection connect(const group_type &group,
+ const slot_type &slot, connect_position position = at_back)
+ {
+ return (*_pimpl).connect(group, slot, position);
+ }
+ connection connect_extended(const extended_slot_type &slot, connect_position position = at_back)
+ {
+ return (*_pimpl).connect_extended(slot, position);
+ }
+ connection connect_extended(const group_type &group,
+ const extended_slot_type &slot, connect_position position = at_back)
+ {
+ return (*_pimpl).connect_extended(group, slot, position);
+ }
+ void disconnect_all_slots()
+ {
+ (*_pimpl).disconnect_all_slots();
+ }
+ void disconnect(const group_type &group)
+ {
+ (*_pimpl).disconnect(group);
+ }
+ template <typename T>
+ void disconnect(const T &slot)
+ {
+ (*_pimpl).disconnect(slot);
+ }
+ result_type operator ()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS))
+ {
+ return (*_pimpl)(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ result_type operator ()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS)) const
+ {
+ return (*_pimpl)(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ std::size_t num_slots() const
+ {
+ return (*_pimpl).num_slots();
+ }
+ bool empty() const
+ {
+ return (*_pimpl).empty();
+ }
+ combiner_type combiner() const
+ {
+ return (*_pimpl).combiner();
+ }
+ void set_combiner(const combiner_type &combiner_arg)
+ {
+ return (*_pimpl).set_combiner(combiner_arg);
+ }
+ void swap(BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) & other)
+ {
+ using std::swap;
+ swap(_pimpl, other._pimpl);
+ }
+ protected:
+ virtual shared_ptr<void> lock_pimpl() const
+ {
+ return _pimpl;
+ }
+ private:
+ shared_ptr<impl_class>
+ _pimpl;
+ };
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ // free swap function for signalN classes, findable by ADL
+ template<BOOST_SIGNALS2_SIGNAL_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ void swap(
+ BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> &sig1,
+ BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> &sig2 )
+ {
+ sig1.swap(sig2);
+ }
+#endif
+
+ namespace detail
+ {
+ // wrapper class for storing other signals as slots with automatic lifetime tracking
+ template<BOOST_SIGNALS2_SIGNAL_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_WEAK_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS);
+
+ template<BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_WEAK_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION
+ {
+ public:
+ typedef typename BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION>::result_type
+ result_type;
+
+ BOOST_SIGNALS2_WEAK_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ (const BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION>
+ &signal):
+ _weak_pimpl(signal._pimpl)
+ {}
+ result_type operator ()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS))
+ {
+ shared_ptr<detail::BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> >
+ shared_pimpl(_weak_pimpl.lock());
+ if(shared_pimpl == 0) boost::throw_exception(expired_slot());
+ return (*shared_pimpl)(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ result_type operator ()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS)) const
+ {
+ shared_ptr<detail::BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> >
+ shared_pimpl(_weak_pimpl.lock());
+ if(shared_pimpl == 0) boost::throw_exception(expired_slot());
+ return (*shared_pimpl)(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ private:
+ boost::weak_ptr<detail::BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> > _weak_pimpl;
+ };
+
+#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ template<int arity, typename Signature>
+ class extended_signature: public variadic_extended_signature<Signature>
+ {};
+#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ template<int arity, typename Signature>
+ class extended_signature;
+ // partial template specialization
+ template<typename Signature>
+ class extended_signature<BOOST_SIGNALS2_NUM_ARGS, Signature>
+ {
+ public:
+// typename function_traits<Signature>::result_type (
+// const boost::signals2::connection &,
+// typename function_traits<Signature>::arg1_type,
+// typename function_traits<Signature>::arg2_type,
+// ...,
+// typename function_traits<Signature>::argn_type)
+#define BOOST_SIGNALS2_EXT_SIGNATURE(arity, Signature) \
+ typename function_traits<Signature>::result_type ( \
+ const boost::signals2::connection & BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS) \
+ BOOST_PP_ENUM(arity, BOOST_SIGNALS2_SIGNATURE_TO_ARGN_TYPE, Signature) )
+ typedef function<BOOST_SIGNALS2_EXT_SIGNATURE(BOOST_SIGNALS2_NUM_ARGS, Signature)> function_type;
+#undef BOOST_SIGNALS2_EXT_SIGNATURE
+ };
+
+ template<unsigned arity, typename Signature, typename Combiner,
+ typename Group, typename GroupCompare, typename SlotFunction,
+ typename ExtendedSlotFunction, typename Mutex>
+ class signalN;
+ // partial template specialization
+ template<typename Signature, typename Combiner, typename Group,
+ typename GroupCompare, typename SlotFunction,
+ typename ExtendedSlotFunction, typename Mutex>
+ class signalN<BOOST_SIGNALS2_NUM_ARGS, Signature, Combiner, Group,
+ GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex>
+ {
+ public:
+ typedef BOOST_SIGNALS2_SIGNAL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)<
+ BOOST_SIGNALS2_PORTABLE_SIGNATURE(BOOST_SIGNALS2_NUM_ARGS, Signature),
+ Combiner, Group,
+ GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex> type;
+ };
+
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+#undef BOOST_SIGNALS2_NUM_ARGS
+#undef BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION
diff --git a/3rdParty/Boost/src/boost/signals2/detail/signals_common.hpp b/3rdParty/Boost/src/boost/signals2/detail/signals_common.hpp
new file mode 100644
index 0000000..8c4baf0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/signals_common.hpp
@@ -0,0 +1,77 @@
+// Boost.Signals library
+
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2007. 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_SIGNALS2_SIGNALS_COMMON_HPP
+#define BOOST_SIGNALS2_SIGNALS_COMMON_HPP
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/ref.hpp>
+#include <boost/signals2/signal_base.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+namespace boost {
+ namespace signals2 {
+ namespace detail {
+ // Determine if the given type T is a signal
+ template<typename T>
+ class is_signal: public mpl::bool_<is_base_of<signal_base, T>::value>
+ {};
+
+ // 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 mpl::if_<is_signal<S>,
+ signal_tag, value_tag>::type signal_or_value;
+ public:
+ typedef typename mpl::if_<is_reference_wrapper<S>,
+ reference_tag,
+ signal_or_value>::type type;
+ };
+
+ // Get the slot so that it can be copied
+ template<typename F>
+ typename F::weak_signal_type
+ get_invocable_slot(const F &signal, signal_tag)
+ { return typename F::weak_signal_type(signal); }
+
+ template<typename F>
+ const F&
+ get_invocable_slot(const F& f, reference_tag)
+ { return f; }
+
+ template<typename F>
+ const F&
+ get_invocable_slot(const F& f, 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 get_slot_tag<F>::type
+ tag_type(const F&)
+ {
+ typedef typename get_slot_tag<F>::type
+ the_tag_type;
+ the_tag_type tag = the_tag_type();
+ return tag;
+ }
+ } // end namespace detail
+ } // end namespace signals2
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_SIGNALS_COMMON_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/signals_common_macros.hpp b/3rdParty/Boost/src/boost/signals2/detail/signals_common_macros.hpp
new file mode 100644
index 0000000..b149dbc
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/signals_common_macros.hpp
@@ -0,0 +1,212 @@
+/*
+ Author: Frank Mori Hess <fmhess@users.sourceforge.net>
+ Begin: 2007-01-23
+*/
+// Copyright Frank Mori Hess 2007-2008
+// 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)
+
+#ifndef BOOST_SIGNALS2_SIGNALS_COMMON_MACROS_HPP
+#define BOOST_SIGNALS2_SIGNALS_COMMON_MACROS_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+#ifndef BOOST_SIGNALS2_MAX_ARGS
+#define BOOST_SIGNALS2_MAX_ARGS 9
+#endif
+
+// signaln
+#define BOOST_SIGNALS2_SIGNAL_CLASS_NAME(arity) BOOST_PP_CAT(signal, arity)
+// weak_signaln
+#define BOOST_SIGNALS2_WEAK_SIGNAL_CLASS_NAME(arity) BOOST_PP_CAT(weak_, BOOST_SIGNALS2_SIGNAL_CLASS_NAME(arity))
+// signaln_impl
+#define BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(arity) BOOST_PP_CAT(BOOST_SIGNALS2_SIGNAL_CLASS_NAME(arity), _impl)
+// argn
+#define BOOST_SIGNALS2_SIGNATURE_ARG_NAME(z, n, data) BOOST_PP_CAT(arg, BOOST_PP_INC(n))
+// Tn argn
+#define BOOST_SIGNALS2_SIGNATURE_FULL_ARG(z, n, data) \
+ BOOST_PP_CAT(T, BOOST_PP_INC(n)) BOOST_SIGNALS2_SIGNATURE_ARG_NAME(~, n, ~)
+// T1 arg1, T2 arg2, ..., Tn argn
+#define BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(arity) \
+ BOOST_PP_ENUM(arity, BOOST_SIGNALS2_SIGNATURE_FULL_ARG, ~)
+// arg1, arg2, ..., argn
+#define BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(arity) BOOST_PP_ENUM(arity, BOOST_SIGNALS2_SIGNATURE_ARG_NAME, ~)
+// T1, T2, ..., TN
+#define BOOST_SIGNALS2_ARGS_TEMPLATE_INSTANTIATION(arity) \
+ BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), T)
+// R (T1, T2, ..., TN)
+#define BOOST_SIGNALS2_SIGNATURE_FUNCTION_TYPE(arity) \
+ R ( BOOST_SIGNALS2_ARGS_TEMPLATE_INSTANTIATION(arity) )
+// typename prefixR, typename prefixT1, typename prefixT2, ..., typename prefixTN
+#define BOOST_SIGNALS2_PREFIXED_SIGNATURE_TEMPLATE_DECL(arity, prefix) \
+ typename BOOST_PP_CAT(prefix, R) BOOST_PP_COMMA_IF(arity) \
+ BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), typename BOOST_PP_CAT(prefix, T))
+// typename R, typename T1, typename T2, ..., typename TN
+#define BOOST_SIGNALS2_SIGNATURE_TEMPLATE_DECL(arity) \
+ typename R BOOST_PP_COMMA_IF(arity) \
+ BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), typename T)
+// typename prefixT1, typename prefixT2, ..., typename prefixTN
+#define BOOST_SIGNALS2_PREFIXED_ARGS_TEMPLATE_DECL(arity, prefix) \
+ BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), typename BOOST_PP_CAT(prefix, T))
+// typename T1, typename T2, ..., typename TN
+#define BOOST_SIGNALS2_ARGS_TEMPLATE_DECL(arity) \
+ BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), typename T)
+// prefixR, prefixT1, prefixT2, ..., prefixTN
+#define BOOST_SIGNALS2_PREFIXED_SIGNATURE_TEMPLATE_INSTANTIATION(arity, prefix) \
+ BOOST_PP_CAT(prefix, R) BOOST_PP_COMMA_IF(arity) BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), BOOST_PP_CAT(prefix, T))
+// R, T1, T2, ..., TN
+#define BOOST_SIGNALS2_SIGNATURE_TEMPLATE_INSTANTIATION(arity) \
+ R BOOST_PP_COMMA_IF(arity) BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), T)
+// boost::functionN<R, T1, T2, ..., TN>
+#define BOOST_SIGNALS2_FUNCTION_N_DECL(arity) BOOST_PP_CAT(boost::function, arity)<\
+ BOOST_SIGNALS2_SIGNATURE_TEMPLATE_INSTANTIATION(arity) >
+// R, const boost::signals2::connection&, T1, T2, ..., TN
+#define BOOST_SIGNALS2_EXT_SLOT_TEMPLATE_INSTANTIATION(arity) \
+ R, const boost::signals2::connection& BOOST_PP_COMMA_IF(arity) \
+ BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), T)
+// boost::functionN<R, const boost::signals2::connection &, T1, T2, ..., TN>
+#define BOOST_SIGNALS2_EXT_FUNCTION_N_DECL(arity) BOOST_PP_CAT(boost::function, BOOST_PP_INC(arity))<\
+ BOOST_SIGNALS2_EXT_SLOT_TEMPLATE_INSTANTIATION(arity) >
+// slotN
+#define BOOST_SIGNALS2_SLOT_CLASS_NAME(arity) BOOST_PP_CAT(slot, arity)
+// slotN+1<R, const connection &, T1, T2, ..., TN, extended_slot_function_type>
+#define BOOST_SIGNALS2_EXTENDED_SLOT_TYPE(arity) \
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_PP_INC(arity))< \
+ BOOST_SIGNALS2_EXT_SLOT_TEMPLATE_INSTANTIATION(arity), \
+ extended_slot_function_type>
+// bound_extended_slot_functionN
+#define BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_N(arity) BOOST_PP_CAT(bound_extended_slot_function, arity)
+// bound_extended_slot_function_helperN
+#define BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_INVOKER_N(arity) BOOST_PP_CAT(bound_extended_slot_function_invoker, arity)
+// typename function_traits<Signature>::argn_type
+#define BOOST_SIGNALS2_SIGNATURE_TO_ARGN_TYPE(z, n, Signature) \
+ BOOST_PP_CAT(BOOST_PP_CAT(typename function_traits<Signature>::arg, BOOST_PP_INC(n)), _type)
+// typename function_traits<Signature>::result_type,
+// typename function_traits<Signature>::arg1_type,
+// typename function_traits<Signature>::arg2_type,
+// ...,
+// typename function_traits<Signature>::argn_type
+#define BOOST_SIGNALS2_PORTABLE_SIGNATURE(arity, Signature) \
+ typename function_traits<Signature>::result_type \
+ BOOST_PP_COMMA_IF(arity) BOOST_PP_ENUM(arity, BOOST_SIGNALS2_SIGNATURE_TO_ARGN_TYPE, Signature)
+// prefixTn & argn
+#define BOOST_SIGNALS2_PREFIXED_FULL_REF_ARG(z, n, prefix) \
+ BOOST_PP_CAT(BOOST_PP_CAT(prefix, T), BOOST_PP_INC(n)) & BOOST_SIGNALS2_SIGNATURE_ARG_NAME(~, n, ~)
+// prefixT1 & arg1, prefixT2 & arg2, ..., prefixTn & argn
+#define BOOST_SIGNALS2_PREFIXED_FULL_REF_ARGS(arity, prefix) \
+ BOOST_PP_ENUM(arity, BOOST_SIGNALS2_PREFIXED_FULL_REF_ARG, prefix)
+// Tn & argn
+#define BOOST_SIGNALS2_FULL_REF_ARG(z, n, data) \
+ BOOST_PP_CAT(T, BOOST_PP_INC(n)) & BOOST_SIGNALS2_SIGNATURE_ARG_NAME(~, n, ~)
+// T1 & arg1, T2 & arg2, ..., Tn & argn
+#define BOOST_SIGNALS2_FULL_REF_ARGS(arity) \
+ BOOST_PP_ENUM(arity, BOOST_SIGNALS2_FULL_REF_ARG, ~)
+// preprocessed_arg_typeN
+#define BOOST_SIGNALS2_PREPROCESSED_ARG_N_TYPE_CLASS_NAME(arity) BOOST_PP_CAT(preprocessed_arg_type, arity)
+
+// typename R, typename T1, typename T2, ..., typename TN, typename SlotFunction
+#define BOOST_SIGNALS2_SLOT_TEMPLATE_SPECIALIZATION_DECL(arity) \
+ BOOST_SIGNALS2_SIGNATURE_TEMPLATE_DECL(arity), \
+ typename SlotFunction
+#define BOOST_SIGNALS2_SLOT_TEMPLATE_SPECIALIZATION
+
+// typename R, typename T1, typename T2, ..., typename TN, typename Combiner, ...
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_DECL(arity) \
+ BOOST_SIGNALS2_SIGNATURE_TEMPLATE_DECL(arity), \
+ typename Combiner, \
+ typename Group, \
+ typename GroupCompare, \
+ typename SlotFunction, \
+ typename ExtendedSlotFunction, \
+ typename Mutex
+// typename R, typename T1, typename T2, ..., typename TN, typename Combiner = optional_last_value<R>, ...
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_DEFAULTED_DECL(arity) \
+ BOOST_SIGNALS2_SIGNATURE_TEMPLATE_DECL(arity), \
+ typename Combiner = optional_last_value<R>, \
+ typename Group = int, \
+ typename GroupCompare = std::less<Group>, \
+ typename SlotFunction = BOOST_SIGNALS2_FUNCTION_N_DECL(arity), \
+ typename ExtendedSlotFunction = BOOST_SIGNALS2_EXT_FUNCTION_N_DECL(arity), \
+ typename Mutex = signals2::mutex
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION_DECL(arity) BOOST_SIGNALS2_SIGNAL_TEMPLATE_DECL(arity)
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION
+
+#define BOOST_SIGNALS2_STD_FUNCTIONAL_BASE(result_type) std_functional_base
+
+#define BOOST_SIGNALS2_PP_COMMA_IF(arity) BOOST_PP_COMMA_IF(arity)
+
+#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+#define BOOST_SIGNALS2_SIGNAL_CLASS_NAME(arity) signal
+#define BOOST_SIGNALS2_WEAK_SIGNAL_CLASS_NAME(arity) weak_signal
+#define BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(arity) signal_impl
+#define BOOST_SIGNALS2_SIGNATURE_TEMPLATE_DECL(arity) typename Signature
+#define BOOST_SIGNALS2_ARGS_TEMPLATE_INSTANTIATION(arity) Args...
+#define BOOST_SIGNALS2_SIGNATURE_TEMPLATE_INSTANTIATION(arity) R (Args...)
+#define BOOST_SIGNALS2_SIGNATURE_FUNCTION_TYPE(arity) R (Args...)
+#define BOOST_SIGNALS2_ARGS_TEMPLATE_DECL(arity) typename ... Args
+#define BOOST_SIGNALS2_FULL_REF_ARGS(arity) Args & ... args
+#define BOOST_SIGNALS2_SLOT_CLASS_NAME(arity) slot
+#define BOOST_SIGNALS2_EXTENDED_SLOT_TYPE(arity) slot<R (const connection &, Args...), extended_slot_function_type>
+#define BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_N(arity) bound_extended_slot_function
+#define BOOST_SIGNALS2_BOUND_EXTENDED_SLOT_FUNCTION_INVOKER_N(arity) bound_extended_slot_function_invoker
+#define BOOST_SIGNALS2_FUNCTION_N_DECL(arity) boost::function<Signature>
+#define BOOST_SIGNALS2_PREFIXED_SIGNATURE_TEMPLATE_DECL(arity, prefix) typename prefixSignature
+#define BOOST_SIGNALS2_PREFIXED_SIGNATURE_TEMPLATE_INSTANTIATION(arity, prefix) prefixSignature
+#define BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(arity) Args ... args
+#define BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(arity) args...
+#define BOOST_SIGNALS2_PORTABLE_SIGNATURE(arity, Signature) Signature
+
+#define BOOST_SIGNALS2_SLOT_TEMPLATE_SPECIALIZATION_DECL(arity) \
+ typename SlotFunction, \
+ typename R, \
+ typename ... Args
+#define BOOST_SIGNALS2_SLOT_TEMPLATE_SPECIALIZATION \
+ <R (Args...), SlotFunction>
+
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_DECL(arity) \
+ typename Signature, \
+ typename Combiner, \
+ typename Group, \
+ typename GroupCompare, \
+ typename SlotFunction, \
+ typename ExtendedSlotFunction, \
+ typename Mutex
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_DEFAULTED_DECL(arity) \
+ typename Signature, \
+ typename Combiner = optional_last_value<typename boost::function_traits<Signature>::result_type>, \
+ typename Group = int, \
+ typename GroupCompare = std::less<Group>, \
+ typename SlotFunction = boost::function<Signature>, \
+ typename ExtendedSlotFunction = typename detail::variadic_extended_signature<Signature>::function_type, \
+ typename Mutex = signals2::mutex
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION_DECL(arity) \
+ typename Combiner, \
+ typename Group, \
+ typename GroupCompare, \
+ typename SlotFunction, \
+ typename ExtendedSlotFunction, \
+ typename Mutex, \
+ typename R, \
+ typename ... Args
+#define BOOST_SIGNALS2_SIGNAL_TEMPLATE_SPECIALIZATION <\
+ R (Args...), \
+ Combiner, \
+ Group, \
+ GroupCompare, \
+ SlotFunction, \
+ ExtendedSlotFunction, \
+ Mutex>
+
+#define BOOST_SIGNALS2_STD_FUNCTIONAL_BASE(result_type) \
+ std_functional_base<result_type , Args...>
+
+#define BOOST_SIGNALS2_PP_COMMA_IF(arity) ,
+
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+#endif // BOOST_SIGNALS2_SIGNALS_COMMON_MACROS_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/slot_call_iterator.hpp b/3rdParty/Boost/src/boost/signals2/detail/slot_call_iterator.hpp
new file mode 100644
index 0000000..99eec1d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/slot_call_iterator.hpp
@@ -0,0 +1,147 @@
+// Boost.Signals2 library
+
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2007-2008.
+// 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_SIGNALS2_SLOT_CALL_ITERATOR_HPP
+#define BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
+
+#include <boost/assert.hpp>
+#include <boost/aligned_storage.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/optional.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/slot_base.hpp>
+#include <boost/signals2/detail/auto_buffer.hpp>
+#include <boost/signals2/detail/unique_lock.hpp>
+#include <boost/weak_ptr.hpp>
+
+namespace boost {
+ namespace signals2 {
+ namespace detail {
+ template<typename ResultType, typename Function>
+ class slot_call_iterator_cache
+ {
+ public:
+ slot_call_iterator_cache(const Function &f_arg):
+ f(f_arg),
+ connected_slot_count(0),
+ disconnected_slot_count(0)
+ {}
+ optional<ResultType> result;
+ typedef auto_buffer<void_shared_ptr_variant, store_n_objects<10> > tracked_ptrs_type;
+ tracked_ptrs_type tracked_ptrs;
+ Function f;
+ unsigned connected_slot_count;
+ unsigned disconnected_slot_count;
+ };
+
+ // 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, typename ConnectionBody>
+ class slot_call_iterator_t
+ : public boost::iterator_facade<slot_call_iterator_t<Function, Iterator, ConnectionBody>,
+ typename Function::result_type,
+ boost::single_pass_traversal_tag,
+ typename Function::result_type const&>
+ {
+ typedef boost::iterator_facade<slot_call_iterator_t<Function, Iterator, ConnectionBody>,
+ typename Function::result_type,
+ boost::single_pass_traversal_tag,
+ typename Function::result_type const&>
+ inherited;
+
+ typedef typename Function::result_type result_type;
+
+ friend class boost::iterator_core_access;
+
+ public:
+ slot_call_iterator_t(Iterator iter_in, Iterator end_in,
+ slot_call_iterator_cache<result_type, Function> &c):
+ iter(iter_in), end(end_in),
+ cache(&c), callable_iter(end_in)
+ {
+ lock_next_callable();
+ }
+
+ typename inherited::reference
+ dereference() const
+ {
+ if (!cache->result) {
+ try
+ {
+ cache->result.reset(cache->f(*iter));
+ }
+ catch(expired_slot &)
+ {
+ (*iter)->disconnect();
+ throw;
+ }
+ }
+ return cache->result.get();
+ }
+
+ void increment()
+ {
+ ++iter;
+ lock_next_callable();
+ cache->result.reset();
+ }
+
+ bool equal(const slot_call_iterator_t& other) const
+ {
+ return iter == other.iter;
+ }
+
+ private:
+ typedef unique_lock<connection_body_base> lock_type;
+
+ void lock_next_callable() const
+ {
+ if(iter == callable_iter)
+ {
+ return;
+ }
+ for(;iter != end; ++iter)
+ {
+ lock_type lock(**iter);
+ cache->tracked_ptrs.clear();
+ (*iter)->nolock_grab_tracked_objects(std::back_inserter(cache->tracked_ptrs));
+ if((*iter)->nolock_nograb_connected())
+ {
+ ++cache->connected_slot_count;
+ }else
+ {
+ ++cache->disconnected_slot_count;
+ }
+ if((*iter)->nolock_nograb_blocked() == false)
+ {
+ callable_iter = iter;
+ break;
+ }
+ }
+ if(iter == end)
+ {
+ callable_iter = end;
+ }
+ }
+
+ mutable Iterator iter;
+ Iterator end;
+ slot_call_iterator_cache<result_type, Function> *cache;
+ mutable Iterator callable_iter;
+ };
+ } // end namespace detail
+ } // end namespace BOOST_SIGNALS_NAMESPACE
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/slot_groups.hpp b/3rdParty/Boost/src/boost/signals2/detail/slot_groups.hpp
new file mode 100644
index 0000000..5e1853a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/slot_groups.hpp
@@ -0,0 +1,235 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2008.
+// 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_SIGNALS2_SLOT_GROUPS_HPP
+#define BOOST_SIGNALS2_SLOT_GROUPS_HPP
+
+#include <boost/signals2/connection.hpp>
+#include <boost/optional.hpp>
+#include <list>
+#include <map>
+#include <utility>
+
+namespace boost {
+ namespace signals2 {
+ namespace detail {
+ enum slot_meta_group {front_ungrouped_slots, grouped_slots, back_ungrouped_slots};
+ template<typename Group>
+ struct group_key
+ {
+ typedef std::pair<enum slot_meta_group, boost::optional<Group> > type;
+ };
+ template<typename Group, typename GroupCompare>
+ class group_key_less
+ {
+ public:
+ group_key_less()
+ {}
+ group_key_less(const GroupCompare &group_compare): _group_compare(group_compare)
+ {}
+ bool operator ()(const typename group_key<Group>::type &key1, const typename group_key<Group>::type &key2) const
+ {
+ if(key1.first != key2.first) return key1.first < key2.first;
+ if(key1.first != grouped_slots) return false;
+ return _group_compare(key1.second.get(), key2.second.get());
+ }
+ private:
+ GroupCompare _group_compare;
+ };
+ template<typename Group, typename GroupCompare, typename ValueType>
+ class grouped_list
+ {
+ public:
+ typedef group_key_less<Group, GroupCompare> group_key_compare_type;
+ private:
+ typedef std::list<ValueType> list_type;
+ typedef std::map
+ <
+ typename group_key<Group>::type,
+ typename list_type::iterator,
+ group_key_compare_type
+ > map_type;
+ typedef typename map_type::iterator map_iterator;
+ typedef typename map_type::const_iterator const_map_iterator;
+ public:
+ typedef typename list_type::iterator iterator;
+ typedef typename list_type::const_iterator const_iterator;
+ typedef typename group_key<Group>::type group_key_type;
+
+ grouped_list(const group_key_compare_type &group_key_compare):
+ _group_key_compare(group_key_compare)
+ {}
+ grouped_list(const grouped_list &other): _list(other._list),
+ _group_map(other._group_map), _group_key_compare(other._group_key_compare)
+ {
+ // fix up _group_map
+ typename map_type::const_iterator other_map_it;
+ typename list_type::iterator this_list_it = _list.begin();
+ typename map_type::iterator this_map_it = _group_map.begin();
+ for(other_map_it = other._group_map.begin();
+ other_map_it != other._group_map.end();
+ ++other_map_it, ++this_map_it)
+ {
+ BOOST_ASSERT(this_map_it != _group_map.end());
+ this_map_it->second = this_list_it;
+ typename list_type::const_iterator other_list_it = other.get_list_iterator(other_map_it);
+ typename map_type::const_iterator other_next_map_it = other_map_it;
+ ++other_next_map_it;
+ typename list_type::const_iterator other_next_list_it = other.get_list_iterator(other_next_map_it);
+ while(other_list_it != other_next_list_it)
+ {
+ ++other_list_it;
+ ++this_list_it;
+ }
+ }
+ }
+ iterator begin()
+ {
+ return _list.begin();
+ }
+ iterator end()
+ {
+ return _list.end();
+ }
+ iterator lower_bound(const group_key_type &key)
+ {
+ map_iterator map_it = _group_map.lower_bound(key);
+ return get_list_iterator(map_it);
+ }
+ iterator upper_bound(const group_key_type &key)
+ {
+ map_iterator map_it = _group_map.upper_bound(key);
+ return get_list_iterator(map_it);
+ }
+ void push_front(const group_key_type &key, const ValueType &value)
+ {
+ map_iterator map_it;
+ if(key.first == front_ungrouped_slots)
+ {// optimization
+ map_it = _group_map.begin();
+ }else
+ {
+ map_it = _group_map.lower_bound(key);
+ }
+ m_insert(map_it, key, value);
+ }
+ void push_back(const group_key_type &key, const ValueType &value)
+ {
+ map_iterator map_it;
+ if(key.first == back_ungrouped_slots)
+ {// optimization
+ map_it = _group_map.end();
+ }else
+ {
+ map_it = _group_map.upper_bound(key);
+ }
+ m_insert(map_it, key, value);
+ }
+ void erase(const group_key_type &key)
+ {
+ map_iterator map_it = _group_map.lower_bound(key);
+ iterator begin_list_it = get_list_iterator(map_it);
+ iterator end_list_it = upper_bound(key);
+ if(begin_list_it != end_list_it)
+ {
+ _list.erase(begin_list_it, end_list_it);
+ _group_map.erase(map_it);
+ }
+ }
+ iterator erase(const group_key_type &key, const iterator &it)
+ {
+ BOOST_ASSERT(it != _list.end());
+ map_iterator map_it = _group_map.lower_bound(key);
+ BOOST_ASSERT(map_it != _group_map.end());
+ BOOST_ASSERT(weakly_equivalent(map_it->first, key));
+ if(map_it->second == it)
+ {
+ iterator next = it;
+ ++next;
+ // if next is in same group
+ if(next != upper_bound(key))
+ {
+ _group_map[key] = next;
+ }else
+ {
+ _group_map.erase(map_it);
+ }
+ }
+ return _list.erase(it);
+ }
+ void clear()
+ {
+ _list.clear();
+ _group_map.clear();
+ }
+ private:
+ /* Suppress default assignment operator, since it has the wrong semantics. */
+ grouped_list& operator=(const grouped_list &other);
+
+ bool weakly_equivalent(const group_key_type &arg1, const group_key_type &arg2)
+ {
+ if(_group_key_compare(arg1, arg2)) return false;
+ if(_group_key_compare(arg2, arg1)) return false;
+ return true;
+ }
+ void m_insert(const map_iterator &map_it, const group_key_type &key, const ValueType &value)
+ {
+ iterator list_it = get_list_iterator(map_it);
+ iterator new_it = _list.insert(list_it, value);
+ if(map_it != _group_map.end() && weakly_equivalent(key, map_it->first))
+ {
+ _group_map.erase(map_it);
+ }
+ map_iterator lower_bound_it = _group_map.lower_bound(key);
+ if(lower_bound_it == _group_map.end() ||
+ weakly_equivalent(lower_bound_it->first, key) == false)
+ {
+ /* doing the following instead of just
+ _group_map[key] = new_it;
+ to avoid bogus error when enabling checked iterators with g++ */
+ _group_map.insert(typename map_type::value_type(key, new_it));
+ }
+ }
+ iterator get_list_iterator(const const_map_iterator &map_it)
+ {
+ iterator list_it;
+ if(map_it == _group_map.end())
+ {
+ list_it = _list.end();
+ }else
+ {
+ list_it = map_it->second;
+ }
+ return list_it;
+ }
+ const_iterator get_list_iterator(const const_map_iterator &map_it) const
+ {
+ const_iterator list_it;
+ if(map_it == _group_map.end())
+ {
+ list_it = _list.end();
+ }else
+ {
+ list_it = map_it->second;
+ }
+ return list_it;
+ }
+
+ list_type _list;
+ // holds iterators to first list item in each group
+ map_type _group_map;
+ group_key_compare_type _group_key_compare;
+ };
+ } // end namespace detail
+ enum connect_position { at_back, at_front };
+ } // end namespace signals2
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_SLOT_GROUPS_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/slot_template.hpp b/3rdParty/Boost/src/boost/signals2/detail/slot_template.hpp
new file mode 100644
index 0000000..fc19f51
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/slot_template.hpp
@@ -0,0 +1,187 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2008.
+// Copyright Timmo Stange 2007.
+// 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 is included iteratively, and should not be protected from multiple inclusion
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_SIGNALS2_NUM_ARGS BOOST_PP_ITERATION()
+#else
+#define BOOST_SIGNALS2_NUM_ARGS 1
+#endif
+
+
+namespace boost
+{
+ namespace signals2
+ {
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ template<typename Signature, typename SlotFunction> class slot;
+#else
+ template<typename Signature, typename SlotFunction = boost::function<Signature> >
+ class slot;
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1900)
+ template<typename Signature, typename SlotFunction> class slot{};
+#endif
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+ template<BOOST_SIGNALS2_SLOT_TEMPLATE_SPECIALIZATION_DECL(BOOST_SIGNALS2_NUM_ARGS)>
+ class BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS) BOOST_SIGNALS2_SLOT_TEMPLATE_SPECIALIZATION
+ : public slot_base, public detail::BOOST_SIGNALS2_STD_FUNCTIONAL_BASE(R)
+
+ {
+ public:
+ template<BOOST_SIGNALS2_PREFIXED_SIGNATURE_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS, Other), typename OtherSlotFunction>
+ friend class BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS);
+
+ typedef SlotFunction slot_function_type;
+ typedef R result_type;
+ typedef typename mpl::identity<BOOST_SIGNALS2_SIGNATURE_FUNCTION_TYPE(BOOST_SIGNALS2_NUM_ARGS)>::type signature_type;
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+// typedef Tn argn_type;
+#define BOOST_SIGNALS2_MISC_STATEMENT(z, n, data) \
+ typedef BOOST_PP_CAT(T, BOOST_PP_INC(n)) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(n)), _type);
+ BOOST_PP_REPEAT(BOOST_SIGNALS2_NUM_ARGS, BOOST_SIGNALS2_MISC_STATEMENT, ~)
+#undef BOOST_SIGNALS2_MISC_STATEMENT
+#if BOOST_SIGNALS2_NUM_ARGS == 1
+ typedef arg1_type argument_type;
+#elif BOOST_SIGNALS2_NUM_ARGS == 2
+ typedef arg1_type first_argument_type;
+ typedef arg2_type second_argument_type;
+#endif
+
+ template<unsigned n> class arg : public
+ detail::BOOST_SIGNALS2_PREPROCESSED_ARG_N_TYPE_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <n BOOST_SIGNALS2_PP_COMMA_IF(BOOST_SIGNALS2_NUM_ARGS)
+ BOOST_SIGNALS2_ARGS_TEMPLATE_INSTANTIATION(BOOST_SIGNALS2_NUM_ARGS)>
+ {};
+
+ BOOST_STATIC_CONSTANT(int, arity = BOOST_SIGNALS2_NUM_ARGS);
+
+#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+ template<unsigned n> class arg
+ {
+ public:
+ typedef typename detail::variadic_arg_type<n, Args...>::type type;
+ };
+ BOOST_STATIC_CONSTANT(int, arity = sizeof...(Args));
+
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+ template<typename F>
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)(const F& f)
+ {
+ init_slot_function(f);
+ }
+ // copy constructors
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ template<BOOST_SIGNALS2_PREFIXED_SIGNATURE_TEMPLATE_DECL(BOOST_SIGNALS2_NUM_ARGS, Other), typename OtherSlotFunction>
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)(const BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
+ <BOOST_SIGNALS2_PREFIXED_SIGNATURE_TEMPLATE_INSTANTIATION(BOOST_SIGNALS2_NUM_ARGS, Other), OtherSlotFunction> &other_slot):
+ slot_base(other_slot), _slot_function(other_slot._slot_function)
+ {
+ }
+#endif
+ template<typename Signature, typename OtherSlotFunction>
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)(const slot<Signature, OtherSlotFunction> &other_slot):
+ slot_base(other_slot), _slot_function(other_slot._slot_function)
+ {
+ }
+ // bind syntactic sugar
+ BOOST_SIGNALS2_SLOT_N_BINDING_CONSTRUCTORS
+ // invocation
+ R operator()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS))
+ {
+ locked_container_type locked_objects = lock();
+ return _slot_function(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ R operator()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS)) const
+ {
+ locked_container_type locked_objects = lock();
+ return _slot_function(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
+ }
+ // tracking
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)& track(const weak_ptr<void> &tracked) {
+ _tracked_objects.push_back(tracked);
+ return *this;
+ }
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)& track(const signal_base &signal)
+ {
+ track_signal(signal);
+ return *this;
+ }
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)& track(const slot_base &slot)
+ {
+ tracked_container_type::const_iterator it;
+ for(it = slot.tracked_objects().begin(); it != slot.tracked_objects().end(); ++it)
+ {
+ _tracked_objects.push_back(*it);
+ }
+ return *this;
+ }
+ template<typename ForeignWeakPtr>
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)& track_foreign(const ForeignWeakPtr &tracked,
+ typename weak_ptr_traits<ForeignWeakPtr>::shared_type * /*SFINAE*/ = 0)
+ {
+ _tracked_objects.push_back(detail::foreign_void_weak_ptr(tracked));
+ return *this;
+ }
+ template<typename ForeignSharedPtr>
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)& track_foreign(const ForeignSharedPtr &tracked,
+ typename shared_ptr_traits<ForeignSharedPtr>::weak_type * /*SFINAE*/ = 0)
+ {
+ _tracked_objects.push_back
+ (
+ detail::foreign_void_weak_ptr
+ (
+ typename shared_ptr_traits<ForeignSharedPtr>::weak_type(tracked)
+ )
+ );
+ return *this;
+ }
+
+ const slot_function_type& slot_function() const {return _slot_function;}
+ slot_function_type& slot_function() {return _slot_function;}
+ private:
+ template<typename F>
+ void init_slot_function(const F& f)
+ {
+ _slot_function = detail::get_invocable_slot(f, detail::tag_type(f));
+ signals2::detail::tracked_objects_visitor visitor(this);
+ boost::visit_each(visitor, f);
+ }
+
+ SlotFunction _slot_function;
+ };
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+ namespace detail
+ {
+ template<unsigned arity, typename Signature, typename SlotFunction>
+ class slotN;
+ // partial template specialization
+ template<typename Signature, typename SlotFunction>
+ class slotN<BOOST_SIGNALS2_NUM_ARGS, Signature, SlotFunction>
+ {
+ public:
+ typedef BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)<
+ BOOST_SIGNALS2_PORTABLE_SIGNATURE(BOOST_SIGNALS2_NUM_ARGS, Signature),
+ SlotFunction> type;
+ };
+ }
+#endif
+ } // end namespace signals2
+} // end namespace boost
+
+#undef BOOST_SIGNALS2_NUM_ARGS
diff --git a/3rdParty/Boost/src/boost/signals2/detail/tracked_objects_visitor.hpp b/3rdParty/Boost/src/boost/signals2/detail/tracked_objects_visitor.hpp
new file mode 100644
index 0000000..71a1d50
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/tracked_objects_visitor.hpp
@@ -0,0 +1,98 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2008.
+// Copyright Timmo Stange 2007.
+// 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_SIGNALS2_TRACKED_OBJECTS_VISITOR_HPP
+#define BOOST_SIGNALS2_TRACKED_OBJECTS_VISITOR_HPP
+
+#include <boost/mpl/bool.hpp>
+#include <boost/ref.hpp>
+#include <boost/signals2/detail/signals_common.hpp>
+#include <boost/signals2/slot_base.hpp>
+#include <boost/signals2/trackable.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/utility/addressof.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ // Visitor to collect tracked objects from a bound function.
+ class tracked_objects_visitor
+ {
+ public:
+ tracked_objects_visitor(slot_base *slot) : slot_(slot)
+ {}
+ template<typename T>
+ void operator()(const T& t) const
+ {
+ m_visit_reference_wrapper(t, mpl::bool_<is_reference_wrapper<T>::value>());
+ }
+ private:
+ template<typename T>
+ void m_visit_reference_wrapper(const reference_wrapper<T> &t, const mpl::bool_<true> &) const
+ {
+ m_visit_pointer(t.get_pointer(), mpl::bool_<true>());
+ }
+ template<typename T>
+ void m_visit_reference_wrapper(const T &t, const mpl::bool_<false> &) const
+ {
+ m_visit_pointer(t, mpl::bool_<is_pointer<T>::value>());
+ }
+ template<typename T>
+ void m_visit_pointer(const T &t, const mpl::bool_<true> &) const
+ {
+ m_visit_not_function_pointer(t, mpl::bool_<!is_function<typename remove_pointer<T>::type>::value>());
+ }
+ template<typename T>
+ void m_visit_pointer(const T &t, const mpl::bool_<false> &) const
+ {
+ m_visit_pointer(boost::addressof(t), mpl::bool_<true>());
+ }
+ template<typename T>
+ void m_visit_not_function_pointer(const T *t, const mpl::bool_<true> &) const
+ {
+ m_visit_signal(t, mpl::bool_<is_signal<T>::value>());
+ }
+ template<typename T>
+ void m_visit_not_function_pointer(const T &, const mpl::bool_<false> &) const
+ {}
+ template<typename T>
+ void m_visit_signal(const T *signal, const mpl::bool_<true> &) const
+ {
+ if(signal)
+ slot_->track_signal(*signal);
+ }
+ template<typename T>
+ void m_visit_signal(const T &t, const mpl::bool_<false> &) const
+ {
+ add_if_trackable(t);
+ }
+ void add_if_trackable(const trackable *trackable) const
+ {
+ if(trackable)
+ slot_->_tracked_objects.push_back(trackable->get_shared_ptr());
+ }
+ void add_if_trackable(const void *) const {}
+
+ mutable slot_base * slot_;
+ };
+
+
+ } // end namespace detail
+ } // end namespace signals2
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_TRACKED_OBJECTS_VISITOR_HPP
+
diff --git a/3rdParty/Boost/src/boost/signals2/detail/unique_lock.hpp b/3rdParty/Boost/src/boost/signals2/detail/unique_lock.hpp
new file mode 100644
index 0000000..13fecf2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/unique_lock.hpp
@@ -0,0 +1,42 @@
+/*
+ Provides a basic subset of boost::unique_lock functionality. Provided only because
+ including boost/thread/locks.hpp requires linking to thread library
+*/
+// Copyright Frank Mori Hess 2008.
+// 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)
+
+// See http://www.boost.org/libs/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_UNIQUE_LOCK_HPP
+#define BOOST_SIGNALS2_UNIQUE_LOCK_HPP
+
+#include <boost/noncopyable.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ template<typename Mutex>
+ class unique_lock: public noncopyable
+ {
+ public:
+ unique_lock(Mutex &m): _mutex(m)
+ {
+ _mutex.lock();
+ }
+ ~unique_lock()
+ {
+ _mutex.unlock();
+ }
+ private:
+ Mutex &_mutex;
+ };
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+#endif // BOOST_SIGNALS2_UNIQUE_LOCK_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/variadic_arg_type.hpp b/3rdParty/Boost/src/boost/signals2/detail/variadic_arg_type.hpp
new file mode 100644
index 0000000..14d54b2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/variadic_arg_type.hpp
@@ -0,0 +1,49 @@
+// Copyright Frank Mori Hess 2009
+//
+// 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_SIGNALS2_DETAIL_VARIADIC_ARG_TYPE_HPP
+#define BOOST_SIGNALS2_DETAIL_VARIADIC_ARG_TYPE_HPP
+
+#include <functional>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ template<unsigned, typename ... Args> class variadic_arg_type;
+
+ template<typename T, typename ... Args> class variadic_arg_type<0, T, Args...>
+ {
+ public:
+ typedef T type;
+ };
+
+ template<unsigned n, typename T, typename ... Args> class variadic_arg_type<n, T, Args...>
+ {
+ public:
+ typedef typename variadic_arg_type<n - 1, Args...>::type type;
+ };
+
+ template <typename R, typename ... Args>
+ struct std_functional_base
+ {};
+ template <typename R, typename T1>
+ struct std_functional_base<R, T1>: public std::unary_function<T1, R>
+ {};
+ template <typename R, typename T1, typename T2>
+ struct std_functional_base<R, T1, T2>: public std::binary_function<T1, T2, R>
+ {};
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+
+#endif // BOOST_SIGNALS2_DETAIL_VARIADIC_ARG_TYPE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/detail/variadic_slot_invoker.hpp b/3rdParty/Boost/src/boost/signals2/detail/variadic_slot_invoker.hpp
new file mode 100644
index 0000000..6d9227e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/variadic_slot_invoker.hpp
@@ -0,0 +1,139 @@
+/*
+ Helper class used by variadic implementation of variadic boost::signals2::signal.
+
+ Author: Frank Mori Hess <fmhess@users.sourceforge.net>
+ Begin: 2009-05-27
+*/
+// Copyright Frank Mori Hess 2009
+// 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_SIGNALS2_DETAIL_VARIADIC_SLOT_INVOKER_HPP
+#define BOOST_SIGNALS2_DETAIL_VARIADIC_SLOT_INVOKER_HPP
+
+#if defined(_MSVC_VER)
+# pragma warning(push)
+# pragma warning(disable:4100) // unreferenced formal parameter
+#endif
+
+#include <boost/mpl/size_t.hpp>
+#include <boost/signals2/detail/variadic_arg_type.hpp>
+
+// if compiler has std::tuple use it instead of boost::tuple
+// because boost::tuple does not have variadic template support at present.
+#ifdef BOOST_NO_CXX11_HDR_TUPLE
+#include <boost/tuple/tuple.hpp>
+#define BOOST_SIGNALS2_TUPLE boost::tuple
+#define BOOST_SIGNALS2_GET boost::get
+#else
+#include <tuple>
+#define BOOST_SIGNALS2_TUPLE std::tuple
+#define BOOST_SIGNALS2_GET std::get
+#endif
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ template<unsigned ... values> class unsigned_meta_array {};
+
+ template<typename UnsignedMetaArray, unsigned n> class unsigned_meta_array_appender;
+
+ template<unsigned n, unsigned ... Args>
+ class unsigned_meta_array_appender<unsigned_meta_array<Args...>, n>
+ {
+ public:
+ typedef unsigned_meta_array<Args..., n> type;
+ };
+
+ template<unsigned n> class make_unsigned_meta_array;
+
+ template<> class make_unsigned_meta_array<0>
+ {
+ public:
+ typedef unsigned_meta_array<> type;
+ };
+
+ template<> class make_unsigned_meta_array<1>
+ {
+ public:
+ typedef unsigned_meta_array<0> type;
+ };
+
+ template<unsigned n> class make_unsigned_meta_array
+ {
+ public:
+ typedef typename unsigned_meta_array_appender<typename make_unsigned_meta_array<n-1>::type, n - 1>::type type;
+ };
+
+ template<typename R>
+ class call_with_tuple_args
+ {
+ public:
+ typedef R result_type;
+
+ template<typename Func, typename ... Args, std::size_t N>
+ R operator()(Func &func, BOOST_SIGNALS2_TUPLE<Args...> args, mpl::size_t<N>) const
+ {
+ typedef typename make_unsigned_meta_array<N>::type indices_type;
+ typename Func::result_type *resolver = 0;
+ return m_invoke(resolver, func, indices_type(), args);
+ }
+ private:
+ template<typename T, typename Func, unsigned ... indices, typename ... Args>
+ R m_invoke(T *, Func &func, unsigned_meta_array<indices...>, BOOST_SIGNALS2_TUPLE<Args...> args) const
+ {
+ return func(BOOST_SIGNALS2_GET<indices>(args)...);
+ }
+ template<typename Func, unsigned ... indices, typename ... Args>
+ R m_invoke(void *, Func &func, unsigned_meta_array<indices...>, BOOST_SIGNALS2_TUPLE<Args...> args) const
+ {
+ func(BOOST_SIGNALS2_GET<indices>(args)...);
+ return R();
+ }
+ };
+
+ template<typename R, typename ... Args>
+ class variadic_slot_invoker
+ {
+ public:
+ typedef R result_type;
+
+ variadic_slot_invoker(Args & ... args): _args(args...)
+ {}
+ template<typename ConnectionBodyType>
+ result_type operator ()(const ConnectionBodyType &connectionBody) const
+ {
+ result_type *resolver = 0;
+ return m_invoke(connectionBody,
+ resolver);
+ }
+ private:
+ template<typename ConnectionBodyType>
+ result_type m_invoke(const ConnectionBodyType &connectionBody,
+ const void_type *) const
+ {
+ return call_with_tuple_args<result_type>()(connectionBody->slot.slot_function(), _args, mpl::size_t<sizeof...(Args)>());
+ }
+ template<typename ConnectionBodyType>
+ result_type m_invoke(const ConnectionBodyType &connectionBody, ...) const
+ {
+ return call_with_tuple_args<result_type>()(connectionBody->slot.slot_function(), _args, mpl::size_t<sizeof...(Args)>());
+ }
+ BOOST_SIGNALS2_TUPLE<Args& ...> _args;
+ };
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+#if defined(_MSVC_VER)
+# pragma warning(pop)
+#endif
+
+#endif // BOOST_SIGNALS2_DETAIL_VARIADIC_SLOT_INVOKER_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/dummy_mutex.hpp b/3rdParty/Boost/src/boost/signals2/dummy_mutex.hpp
new file mode 100644
index 0000000..f2600f1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/dummy_mutex.hpp
@@ -0,0 +1,28 @@
+// A model of the Lockable concept from Boost.Thread which
+// does nothing. It can be passed as the Mutex template parameter
+// for a signal, if the user wishes to disable thread-safety
+// (presumably for performance reasons).
+
+// Copyright Frank Mori Hess 2008.
+// 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)
+
+// See http://www.boost.org/libs/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_DUMMY_MUTEX_HPP
+#define BOOST_SIGNALS2_DUMMY_MUTEX_HPP
+
+namespace boost {
+ namespace signals2 {
+ class dummy_mutex
+ {
+ public:
+ void lock() {}
+ bool try_lock() {return true;}
+ void unlock() {}
+ };
+ } // end namespace signals2
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_DUMMY_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/expired_slot.hpp b/3rdParty/Boost/src/boost/signals2/expired_slot.hpp
new file mode 100644
index 0000000..fa6db22
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/expired_slot.hpp
@@ -0,0 +1,31 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2010.
+// 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_SIGNALS2_EXPIRED_SLOT_HPP
+#define BOOST_SIGNALS2_EXPIRED_SLOT_HPP
+
+#include <boost/smart_ptr/bad_weak_ptr.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ class expired_slot: public bad_weak_ptr
+ {
+ public:
+ virtual char const * what() const throw()
+ {
+ return "boost::signals2::expired_slot";
+ }
+ };
+ }
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_EXPIRED_SLOT_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/last_value.hpp b/3rdParty/Boost/src/boost/signals2/last_value.hpp
new file mode 100644
index 0000000..51cc541
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/last_value.hpp
@@ -0,0 +1,78 @@
+// last_value function object (documented as part of Boost.Signals)
+
+// Copyright Frank Mori Hess 2007.
+// 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_SIGNALS2_LAST_VALUE_HPP
+#define BOOST_SIGNALS2_LAST_VALUE_HPP
+
+#include <boost/optional.hpp>
+#include <boost/signals2/expired_slot.hpp>
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+
+namespace boost {
+ namespace signals2 {
+
+ // no_slots_error is thrown when we are unable to generate a return value
+ // due to no slots being connected to the signal.
+ class no_slots_error: public std::exception
+ {
+ public:
+ virtual const char* what() const throw() {return "boost::signals2::no_slots_error";}
+ };
+
+ template<typename T>
+ class last_value {
+ public:
+ typedef T result_type;
+
+ template<typename InputIterator>
+ T operator()(InputIterator first, InputIterator last) const
+ {
+ if(first == last)
+ {
+ boost::throw_exception(no_slots_error());
+ }
+ optional<T> value;
+ while (first != last)
+ {
+ try
+ {
+ value = *first;
+ }
+ catch(const expired_slot &) {}
+ ++first;
+ }
+ if(value) return value.get();
+ boost::throw_exception(no_slots_error());
+ }
+ };
+
+ template<>
+ class last_value<void> {
+ public:
+ typedef void result_type;
+ template<typename InputIterator>
+ result_type operator()(InputIterator first, InputIterator last) const
+ {
+ while (first != last)
+ {
+ try
+ {
+ *first;
+ }
+ catch(const expired_slot &) {}
+ ++first;
+ }
+ return;
+ }
+ };
+ } // namespace signals2
+} // namespace boost
+#endif // BOOST_SIGNALS2_LAST_VALUE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/mutex.hpp b/3rdParty/Boost/src/boost/signals2/mutex.hpp
new file mode 100644
index 0000000..e58aca1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/mutex.hpp
@@ -0,0 +1,38 @@
+//
+// boost/signals2/mutex.hpp - header-only mutex
+//
+// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
+// Copyright (c) 2008 Frank Mori Hess
+//
+// 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)
+//
+// boost::signals2::mutex is a modification of
+// boost::detail::lightweight_mutex to follow the newer Lockable
+// concept of Boost.Thread.
+//
+
+#ifndef BOOST_SIGNALS2_MUTEX_HPP
+#define BOOST_SIGNALS2_MUTEX_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+# include <boost/signals2/detail/lwm_nop.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+# include <boost/signals2/detail/lwm_pthreads.hpp>
+#elif defined(BOOST_HAS_WINTHREADS)
+# include <boost/signals2/detail/lwm_win32_cs.hpp>
+#else
+// Use #define BOOST_DISABLE_THREADS to avoid the error
+# error Unrecognized threading platform
+#endif
+
+#endif // #ifndef BOOST_SIGNALS2_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/optional_last_value.hpp b/3rdParty/Boost/src/boost/signals2/optional_last_value.hpp
new file mode 100644
index 0000000..766e99b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/optional_last_value.hpp
@@ -0,0 +1,65 @@
+// optional_last_value function object (documented as part of Boost.Signals2)
+
+// Copyright Frank Mori Hess 2007-2008.
+// Copyright Douglas Gregor 2001-2003.
+// 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)
+
+// See http://www.boost.org/libs/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_OPTIONAL_LAST_VALUE_HPP
+#define BOOST_SIGNALS2_OPTIONAL_LAST_VALUE_HPP
+
+#include <boost/optional.hpp>
+#include <boost/signals2/expired_slot.hpp>
+
+namespace boost {
+ namespace signals2 {
+
+ template<typename T>
+ class optional_last_value
+ {
+ public:
+ typedef optional<T> result_type;
+
+ template<typename InputIterator>
+ optional<T> operator()(InputIterator first, InputIterator last) const
+ {
+ optional<T> value;
+ while (first != last)
+ {
+ try
+ {
+ value = *first;
+ }
+ catch(const expired_slot &) {}
+ ++first;
+ }
+ return value;
+ }
+ };
+
+ template<>
+ class optional_last_value<void>
+ {
+ public:
+ typedef void result_type;
+ template<typename InputIterator>
+ result_type operator()(InputIterator first, InputIterator last) const
+ {
+ while (first != last)
+ {
+ try
+ {
+ *first;
+ }
+ catch(const expired_slot &) {}
+ ++first;
+ }
+ return;
+ }
+ };
+ } // namespace signals2
+} // namespace boost
+#endif // BOOST_SIGNALS2_OPTIONAL_LAST_VALUE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/postconstructible.hpp b/3rdParty/Boost/src/boost/signals2/postconstructible.hpp
new file mode 100644
index 0000000..faa1444
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/postconstructible.hpp
@@ -0,0 +1,55 @@
+// DEPRECATED in favor of adl_postconstruct with deconstruct<T>().
+// A simple framework for creating objects with postconstructors.
+// The objects must inherit from boost::signals2::postconstructible, and
+// have their lifetimes managed by
+// boost::shared_ptr created with the boost::signals2::deconstruct_ptr()
+// function.
+//
+// Copyright Frank Mori Hess 2007-2008.
+//
+// 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)
+
+#ifndef BOOST_SIGNALS2_POSTCONSTRUCTIBLE_HPP
+#define BOOST_SIGNALS2_POSTCONSTRUCTIBLE_HPP
+
+namespace boost
+{
+ template<typename T> class shared_ptr;
+
+ namespace signals2
+ {
+ namespace postconstructible_adl_barrier
+ {
+ class postconstructible;
+ }
+ namespace detail
+ {
+ void do_postconstruct(const boost::signals2::postconstructible_adl_barrier::postconstructible *ptr);
+ } // namespace detail
+
+ namespace postconstructible_adl_barrier
+ {
+ class postconstructible
+ {
+ public:
+ friend void detail::do_postconstruct(const postconstructible *ptr);
+ template<typename T>
+ friend void adl_postconstruct(const shared_ptr<T> &sp, postconstructible *p)
+ {
+ p->postconstruct();
+ }
+ protected:
+ postconstructible() {}
+ virtual ~postconstructible() {}
+ virtual void postconstruct() = 0;
+ };
+ } // namespace postconstructible_adl_barrier
+ using postconstructible_adl_barrier::postconstructible;
+
+ }
+}
+
+#endif // BOOST_SIGNALS2_POSTCONSTRUCTIBLE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/predestructible.hpp b/3rdParty/Boost/src/boost/signals2/predestructible.hpp
new file mode 100644
index 0000000..0f6806d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/predestructible.hpp
@@ -0,0 +1,46 @@
+// DEPRECATED in favor of adl_predestruct with deconstruct<T>().
+// A simple framework for creating objects with predestructors.
+// The objects must inherit from boost::signals2::predestructible, and
+// have their lifetimes managed by
+// boost::shared_ptr created with the boost::signals2::deconstruct_ptr()
+// function.
+//
+// Copyright Frank Mori Hess 2007-2008.
+//
+//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)
+
+#ifndef BOOST_SIGNALS2_PREDESTRUCTIBLE_HPP
+#define BOOST_SIGNALS2_PREDESTRUCTIBLE_HPP
+
+namespace boost
+{
+ namespace signals2
+ {
+ template<typename T> class predestructing_deleter;
+
+ namespace predestructible_adl_barrier
+ {
+ class predestructible
+ {
+ protected:
+ predestructible() {}
+ public:
+ template<typename T>
+ friend void adl_postconstruct(const shared_ptr<T> &, ...)
+ {}
+ friend void adl_predestruct(predestructible *p)
+ {
+ p->predestruct();
+ }
+ virtual ~predestructible() {}
+ virtual void predestruct() = 0;
+ };
+ } // namespace predestructible_adl_barrier
+ using predestructible_adl_barrier::predestructible;
+ }
+}
+
+#endif // BOOST_SIGNALS2_PREDESTRUCTIBLE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/preprocessed_signal.hpp b/3rdParty/Boost/src/boost/signals2/preprocessed_signal.hpp
new file mode 100644
index 0000000..28471ba
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/preprocessed_signal.hpp
@@ -0,0 +1,59 @@
+/*
+ A thread-safe version of Boost.Signals.
+
+ Author: Frank Mori Hess <fmhess@users.sourceforge.net>
+ Begin: 2007-01-23
+*/
+// Copyright Frank Mori Hess 2007-2008
+// 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_SIGNALS2_PREPROCESSED_SIGNAL_HPP
+#define BOOST_SIGNALS2_PREPROCESSED_SIGNAL_HPP
+
+#include <boost/preprocessor/arithmetic.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/control/expr_if.hpp>
+#include <boost/preprocessor/iteration.hpp>
+#include <boost/preprocessor/repetition.hpp>
+#include <boost/signals2/detail/preprocessed_arg_type.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#define BOOST_PP_ITERATION_LIMITS (0, BOOST_SIGNALS2_MAX_ARGS)
+#define BOOST_PP_FILENAME_1 <boost/signals2/detail/signal_template.hpp>
+#include BOOST_PP_ITERATE()
+
+namespace boost
+{
+ namespace signals2
+ {
+ template<typename Signature,
+ typename Combiner = optional_last_value<typename boost::function_traits<Signature>::result_type>,
+ typename Group = int,
+ typename GroupCompare = std::less<Group>,
+ typename SlotFunction = function<Signature>,
+ typename ExtendedSlotFunction = typename detail::extended_signature<function_traits<Signature>::arity, Signature>::function_type,
+ typename Mutex = mutex >
+ class signal: public detail::signalN<function_traits<Signature>::arity,
+ Signature, Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex>::type
+ {
+ private:
+ typedef typename detail::signalN<boost::function_traits<Signature>::arity,
+ Signature, Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex>::type base_type;
+ public:
+ signal(const Combiner &combiner_arg = Combiner(), const GroupCompare &group_compare = GroupCompare()):
+ base_type(combiner_arg, group_compare)
+ {}
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+ signal(signal && other) : base_type(std::move(other)) {}
+ signal & operator=(signal && other) { base_type::operator=(std::move(other)); return *this; }
+#endif
+ };
+ }
+}
+
+#endif // BOOST_SIGNALS2_PREPROCESSED_SIGNAL_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/preprocessed_slot.hpp b/3rdParty/Boost/src/boost/signals2/preprocessed_slot.hpp
new file mode 100644
index 0000000..322b1a1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/preprocessed_slot.hpp
@@ -0,0 +1,72 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2009.
+// Copyright Timmo Stange 2007.
+// 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_SIGNALS2_PREPROCESSED_SLOT_HPP
+#define BOOST_SIGNALS2_PREPROCESSED_SLOT_HPP
+
+#include <boost/preprocessor/repetition.hpp>
+#include <boost/signals2/detail/preprocessed_arg_type.hpp>
+#include <boost/type_traits/function_traits.hpp>
+
+#ifndef BOOST_SIGNALS2_SLOT_MAX_BINDING_ARGS
+#define BOOST_SIGNALS2_SLOT_MAX_BINDING_ARGS 10
+#endif
+
+
+// template<typename Func, typename BindArgT0, typename BindArgT1, ..., typename BindArgTN-1> slotN(...
+#define BOOST_SIGNALS2_SLOT_N_BINDING_CONSTRUCTOR(z, n, data) \
+ template<typename Func, BOOST_SIGNALS2_PREFIXED_ARGS_TEMPLATE_DECL(n, BindArg)> \
+ BOOST_SIGNALS2_SLOT_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)( \
+ const Func &func, BOOST_SIGNALS2_PREFIXED_FULL_REF_ARGS(n, const BindArg)) \
+ { \
+ init_slot_function(boost::bind(func, BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(n))); \
+ }
+#define BOOST_SIGNALS2_SLOT_N_BINDING_CONSTRUCTORS \
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_SIGNALS2_SLOT_MAX_BINDING_ARGS, BOOST_SIGNALS2_SLOT_N_BINDING_CONSTRUCTOR, ~)
+
+
+#define BOOST_PP_ITERATION_LIMITS (0, BOOST_PP_INC(BOOST_SIGNALS2_MAX_ARGS))
+#define BOOST_PP_FILENAME_1 <boost/signals2/detail/slot_template.hpp>
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_SIGNALS2_SLOT_N_BINDING_CONSTRUCTOR
+#undef BOOST_SIGNALS2_SLOT_N_BINDING_CONSTRUCTORS
+
+namespace boost
+{
+ namespace signals2
+ {
+ template<typename Signature,
+ typename SlotFunction = boost::function<Signature> >
+ class slot: public detail::slotN<function_traits<Signature>::arity,
+ Signature, SlotFunction>::type
+ {
+ private:
+ typedef typename detail::slotN<boost::function_traits<Signature>::arity,
+ Signature, SlotFunction>::type base_type;
+ public:
+ template<typename F>
+ slot(const F& f): base_type(f)
+ {}
+ // bind syntactic sugar
+// template<typename F, typename BindArgT0, typename BindArgT1, ..., typename BindArgTn-1> slot(...
+#define BOOST_SIGNALS2_SLOT_BINDING_CONSTRUCTOR(z, n, data) \
+ template<typename Func, BOOST_SIGNALS2_PREFIXED_ARGS_TEMPLATE_DECL(n, BindArg)> \
+ slot(const Func &func, BOOST_SIGNALS2_PREFIXED_FULL_REF_ARGS(n, const BindArg)): \
+ base_type(func, BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(n)) \
+ {}
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_SIGNALS2_SLOT_MAX_BINDING_ARGS, BOOST_SIGNALS2_SLOT_BINDING_CONSTRUCTOR, ~)
+#undef BOOST_SIGNALS2_SLOT_BINDING_CONSTRUCTOR
+ };
+ } // namespace signals2
+}
+
+#endif // BOOST_SIGNALS2_PREPROCESSED_SLOT_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/shared_connection_block.hpp b/3rdParty/Boost/src/boost/signals2/shared_connection_block.hpp
new file mode 100644
index 0000000..c16bf9b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/shared_connection_block.hpp
@@ -0,0 +1,64 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2008.
+// 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_SIGNALS2_SHARED_CONNECTION_BLOCK_HPP
+#define BOOST_SIGNALS2_SHARED_CONNECTION_BLOCK_HPP
+
+#include <boost/shared_ptr.hpp>
+#include <boost/signals2/connection.hpp>
+#include <boost/weak_ptr.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ class shared_connection_block
+ {
+ public:
+ shared_connection_block(const signals2::connection &conn = signals2::connection(),
+ bool initially_blocked = true):
+ _weak_connection_body(conn._weak_connection_body)
+ {
+ if(initially_blocked) block();
+ }
+ void block()
+ {
+ if(blocking()) return;
+ boost::shared_ptr<detail::connection_body_base> connection_body(_weak_connection_body.lock());
+ if(connection_body == 0)
+ {
+ // Make _blocker non-empty so the blocking() method still returns the correct value
+ // after the connection has expired.
+ _blocker.reset(static_cast<int*>(0));
+ return;
+ }
+ _blocker = connection_body->get_blocker();
+ }
+ void unblock()
+ {
+ _blocker.reset();
+ }
+ bool blocking() const
+ {
+ shared_ptr<void> empty;
+ return _blocker < empty || empty < _blocker;
+ }
+ signals2::connection connection() const
+ {
+ return signals2::connection(_weak_connection_body);
+ }
+ private:
+ boost::weak_ptr<detail::connection_body_base> _weak_connection_body;
+ shared_ptr<void> _blocker;
+ };
+ }
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_SHARED_CONNECTION_BLOCK_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/signal.hpp b/3rdParty/Boost/src/boost/signals2/signal.hpp
new file mode 100644
index 0000000..c04c9e6
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/signal.hpp
@@ -0,0 +1,62 @@
+// A thread-safe version of Boost.Signals.
+
+// Copyright Frank Mori Hess 2007-2009
+//
+// 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_SIGNALS2_SIGNAL_HPP
+#define BOOST_SIGNALS2_SIGNAL_HPP
+
+#include <algorithm>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/function.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/detail/unique_lock.hpp>
+#include <boost/signals2/detail/replace_slot_function.hpp>
+#include <boost/signals2/detail/result_type_wrapper.hpp>
+#include <boost/signals2/detail/signals_common.hpp>
+#include <boost/signals2/detail/signals_common_macros.hpp>
+#include <boost/signals2/detail/slot_groups.hpp>
+#include <boost/signals2/detail/slot_call_iterator.hpp>
+#include <boost/signals2/optional_last_value.hpp>
+#include <boost/signals2/mutex.hpp>
+#include <boost/signals2/slot.hpp>
+#include <boost/throw_exception.hpp>
+#include <functional>
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#include <boost/signals2/preprocessed_signal.hpp>
+#else
+#include <boost/signals2/variadic_signal.hpp>
+#endif
+
+namespace boost
+{
+ namespace signals2
+ {
+ // free swap function, findable by ADL
+ 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> &sig1,
+ signal<Signature, Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex> &sig2)
+ {
+ sig1.swap(sig2);
+ }
+ }
+}
+
+#endif // BOOST_SIGNALS2_SIGNAL_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/signal_base.hpp b/3rdParty/Boost/src/boost/signals2/signal_base.hpp
new file mode 100644
index 0000000..05b6b5f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/signal_base.hpp
@@ -0,0 +1,33 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2008.
+// 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_SIGNALS2_SIGNAL_BASE_HPP
+#define BOOST_SIGNALS2_SIGNAL_BASE_HPP
+
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace boost {
+ namespace signals2 {
+ class slot_base;
+
+ class signal_base : public noncopyable
+ {
+ public:
+ friend class slot_base;
+
+ virtual ~signal_base() {}
+ protected:
+ virtual shared_ptr<void> lock_pimpl() const = 0;
+ };
+ } // end namespace signals2
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_SIGNAL_BASE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/signal_type.hpp b/3rdParty/Boost/src/boost/signals2/signal_type.hpp
new file mode 100644
index 0000000..4de5396
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/signal_type.hpp
@@ -0,0 +1,144 @@
+/*
+ A meta function which supports using named template type parameters
+ via Boost.Parameter to specify the template type parameters for
+ the boost::signals2::signal class.
+
+ Author: Frank Mori Hess <fmhess@users.sourceforge.net>
+ Begin: 2009-01-22
+*/
+// Copyright Frank Mori Hess 2009
+// 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_SIGNALS2_SIGNAL_TYPE_HPP
+#define BOOST_SIGNALS2_SIGNAL_TYPE_HPP
+
+// support for function types is currently broken in Boost.Parameter
+// #define BOOST_SIGNALS2_NAMED_SIGNATURE_PARAMETER
+
+#include <boost/signals2/signal.hpp>
+
+#if !defined(BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_PARAMETER_MAX_ARITY 7
+#else
+#if BOOST_PARAMETER_MAX_ARITY < 7
+#error This header requires BOOST_PARAMETER_MAX_ARITY to be defined as 7 or greater prior to including Boost.Parameter headers
+#endif // BOOST_PARAMETER_MAX_ARITY < 7
+#endif // !defined(BOOST_PARAMETER_MAX_ARITY)
+#include <boost/parameter.hpp>
+
+#include <boost/type_traits/is_function.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace keywords
+ {
+#ifdef BOOST_SIGNALS2_NAMED_SIGNATURE_PARAMETER
+ BOOST_PARAMETER_TEMPLATE_KEYWORD(signature_type)
+#endif
+ BOOST_PARAMETER_TEMPLATE_KEYWORD(combiner_type)
+ BOOST_PARAMETER_TEMPLATE_KEYWORD(group_type)
+ BOOST_PARAMETER_TEMPLATE_KEYWORD(group_compare_type)
+ BOOST_PARAMETER_TEMPLATE_KEYWORD(slot_function_type)
+ BOOST_PARAMETER_TEMPLATE_KEYWORD(extended_slot_function_type)
+ BOOST_PARAMETER_TEMPLATE_KEYWORD(mutex_type)
+ } // namespace keywords
+
+ template <
+#ifdef BOOST_SIGNALS2_NAMED_SIGNATURE_PARAMETER
+ typename A0,
+#else
+ typename Signature,
+#endif
+ typename A1 = parameter::void_,
+ typename A2 = parameter::void_,
+ typename A3 = parameter::void_,
+ typename A4 = parameter::void_,
+ typename A5 = parameter::void_,
+ typename A6 = parameter::void_
+ >
+ class signal_type
+ {
+ typedef parameter::parameters<
+#ifdef BOOST_SIGNALS2_NAMED_SIGNATURE_PARAMETER
+ parameter::required<keywords::tag::signature_type, is_function<boost::mpl::_> >,
+#endif
+ parameter::optional<keywords::tag::combiner_type>,
+ parameter::optional<keywords::tag::group_type>,
+ parameter::optional<keywords::tag::group_compare_type>,
+ parameter::optional<keywords::tag::slot_function_type>,
+ parameter::optional<keywords::tag::extended_slot_function_type>,
+ parameter::optional<keywords::tag::mutex_type>
+ > parameter_spec;
+
+ public:
+ // ArgumentPack
+ typedef typename
+ parameter_spec::bind<
+#ifdef BOOST_SIGNALS2_NAMED_SIGNATURE_PARAMETER
+ A0,
+#endif
+ A1, A2, A3, A4, A5, A6>::type
+ args;
+
+#ifdef BOOST_SIGNALS2_NAMED_SIGNATURE_PARAMETER
+ typedef typename parameter::value_type<args, keywords::tag::signature_type>::type
+ signature_type;
+#else
+ typedef Signature signature_type;
+#endif
+
+ typedef typename parameter::value_type
+ <
+ args,
+ keywords::tag::combiner_type,
+ optional_last_value
+ <
+ typename boost::function_traits<signature_type>::result_type
+ >
+ >::type combiner_type;
+
+ typedef typename
+ parameter::value_type<args, keywords::tag::group_type, int>::type group_type;
+
+ typedef typename
+ parameter::value_type<args, keywords::tag::group_compare_type, std::less<group_type> >::type
+ group_compare_type;
+
+ typedef typename
+ parameter::value_type<args, keywords::tag::slot_function_type, function<signature_type> >::type
+ slot_function_type;
+
+ typedef typename
+ parameter::value_type
+ <
+ args,
+ keywords::tag::extended_slot_function_type,
+ typename detail::extended_signature<function_traits<signature_type>::arity, signature_type>::function_type
+ >::type
+ extended_slot_function_type;
+
+ typedef typename
+ parameter::value_type<args, keywords::tag::mutex_type, mutex>::type mutex_type;
+
+ typedef signal
+ <
+ signature_type,
+ combiner_type,
+ group_type,
+ group_compare_type,
+ slot_function_type,
+ extended_slot_function_type,
+ mutex_type
+ > type;
+ };
+ } // namespace signals2
+} // namespace boost
+
+#endif // BOOST_SIGNALS2_SIGNAL_TYPE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/slot.hpp b/3rdParty/Boost/src/boost/signals2/slot.hpp
new file mode 100644
index 0000000..b6ec4d7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/slot.hpp
@@ -0,0 +1,33 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2009.
+//
+// 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_SIGNALS2_SLOT_HPP
+#define BOOST_SIGNALS2_SLOT_HPP
+
+#include <boost/bind.hpp>
+#include <boost/config.hpp>
+#include <boost/function.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/ref.hpp>
+#include <boost/signals2/detail/signals_common.hpp>
+#include <boost/signals2/detail/signals_common_macros.hpp>
+#include <boost/signals2/detail/tracked_objects_visitor.hpp>
+#include <boost/signals2/slot_base.hpp>
+#include <boost/visit_each.hpp>
+#include <boost/weak_ptr.hpp>
+
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#include <boost/signals2/preprocessed_slot.hpp>
+#else
+#include <boost/signals2/variadic_slot.hpp>
+#endif
+
+#endif // BOOST_SIGNALS2_SLOT_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/slot_base.hpp b/3rdParty/Boost/src/boost/signals2/slot_base.hpp
new file mode 100644
index 0000000..d2dd946
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/slot_base.hpp
@@ -0,0 +1,100 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007-2008.
+// Copyright Timmo Stange 2007.
+// 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_SIGNALS2_SLOT_BASE_HPP
+#define BOOST_SIGNALS2_SLOT_BASE_HPP
+
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/signals2/detail/foreign_ptr.hpp>
+#include <boost/signals2/expired_slot.hpp>
+#include <boost/signals2/signal_base.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/variant.hpp>
+#include <vector>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ class tracked_objects_visitor;
+
+ typedef boost::variant<boost::weak_ptr<void>, detail::foreign_void_weak_ptr > void_weak_ptr_variant;
+ typedef boost::variant<boost::shared_ptr<void>, detail::foreign_void_shared_ptr > void_shared_ptr_variant;
+ class lock_weak_ptr_visitor
+ {
+ public:
+ typedef void_shared_ptr_variant result_type;
+ template<typename WeakPtr>
+ result_type operator()(const WeakPtr &wp) const
+ {
+ return wp.lock();
+ }
+ };
+ class expired_weak_ptr_visitor
+ {
+ public:
+ typedef bool result_type;
+ template<typename WeakPtr>
+ bool operator()(const WeakPtr &wp) const
+ {
+ return wp.expired();
+ }
+ };
+ }
+
+ class slot_base
+ {
+ public:
+ typedef std::vector<detail::void_weak_ptr_variant> tracked_container_type;
+ typedef std::vector<detail::void_shared_ptr_variant> locked_container_type;
+
+ const tracked_container_type& tracked_objects() const {return _tracked_objects;}
+ locked_container_type lock() const
+ {
+ locked_container_type locked_objects;
+ tracked_container_type::const_iterator it;
+ for(it = tracked_objects().begin(); it != tracked_objects().end(); ++it)
+ {
+ locked_objects.push_back(apply_visitor(detail::lock_weak_ptr_visitor(), *it));
+ if(apply_visitor(detail::expired_weak_ptr_visitor(), *it))
+ {
+ boost::throw_exception(expired_slot());
+ }
+ }
+ return locked_objects;
+ }
+ bool expired() const
+ {
+ tracked_container_type::const_iterator it;
+ for(it = tracked_objects().begin(); it != tracked_objects().end(); ++it)
+ {
+ if(apply_visitor(detail::expired_weak_ptr_visitor(), *it)) return true;
+ }
+ return false;
+ }
+ protected:
+ friend class detail::tracked_objects_visitor;
+
+ void track_signal(const signal_base &signal)
+ {
+ _tracked_objects.push_back(signal.lock_pimpl());
+ }
+
+ tracked_container_type _tracked_objects;
+ };
+ }
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_SLOT_BASE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/trackable.hpp b/3rdParty/Boost/src/boost/signals2/trackable.hpp
new file mode 100644
index 0000000..d6a6014
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/trackable.hpp
@@ -0,0 +1,49 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2007,2009.
+// Copyright Timmo Stange 2007.
+// 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)
+
+// Compatibility class to ease porting from the original
+// Boost.Signals library. However,
+// boost::signals2::trackable is NOT thread-safe.
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_SIGNALS2_TRACKABLE_HPP
+#define BOOST_SIGNALS2_TRACKABLE_HPP
+
+#include <boost/assert.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace boost {
+ namespace signals2 {
+ namespace detail
+ {
+ class tracked_objects_visitor;
+ }
+ class trackable {
+ protected:
+ trackable(): _tracked_ptr(static_cast<int*>(0)) {}
+ trackable(const trackable &): _tracked_ptr(static_cast<int*>(0)) {}
+ trackable& operator=(const trackable &)
+ {
+ return *this;
+ }
+ ~trackable() {}
+ private:
+ friend class detail::tracked_objects_visitor;
+ const shared_ptr<void>& get_shared_ptr() const
+ {
+ return _tracked_ptr;
+ }
+
+ shared_ptr<void> _tracked_ptr;
+ };
+ } // end namespace signals2
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_TRACKABLE_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/variadic_signal.hpp b/3rdParty/Boost/src/boost/signals2/variadic_signal.hpp
new file mode 100644
index 0000000..d7d2619
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/variadic_signal.hpp
@@ -0,0 +1,44 @@
+/*
+ A variadic implementation of variadic boost::signals2::signal, used when variadic
+ template support is detected in the compiler.
+
+ Author: Frank Mori Hess <fmhess@users.sourceforge.net>
+ Begin: 2009-05-26
+*/
+// Copyright Frank Mori Hess 2009
+// 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_SIGNALS2_VARIADIC_SIGNAL_HPP
+#define BOOST_SIGNALS2_VARIADIC_SIGNAL_HPP
+
+#include <boost/preprocessor/control/expr_if.hpp>
+#include <boost/signals2/detail/variadic_arg_type.hpp>
+#include <boost/signals2/detail/variadic_slot_invoker.hpp>
+#include <boost/type_traits/function_traits.hpp>
+
+namespace boost
+{
+ namespace signals2
+ {
+ namespace detail
+ {
+ template<typename Signature> class variadic_extended_signature;
+ // partial template specialization
+ template<typename R, typename ... Args>
+ class variadic_extended_signature<R (Args...)>
+ {
+ public:
+ typedef boost::function<R (const boost::signals2::connection &, Args...)> function_type;
+ };
+ } // namespace detail
+ } // namespace signals2
+} // namespace boost
+
+#include <boost/signals2/detail/signal_template.hpp>
+
+#endif // BOOST_SIGNALS2_VARIADIC_SIGNAL_HPP
diff --git a/3rdParty/Boost/src/boost/signals2/variadic_slot.hpp b/3rdParty/Boost/src/boost/signals2/variadic_slot.hpp
new file mode 100644
index 0000000..59ae176
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/variadic_slot.hpp
@@ -0,0 +1,25 @@
+// Boost.Signals2 library
+
+// Copyright Frank Mori Hess 2009.
+//
+// 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_SIGNALS2_VARIADIC_SLOT_HPP
+#define BOOST_SIGNALS2_VARIADIC_SLOT_HPP
+
+#include <boost/signals2/detail/variadic_arg_type.hpp>
+
+#define BOOST_SIGNALS2_SLOT_N_BINDING_CONSTRUCTORS \
+ template<typename A1, typename A2, typename ... BindArgs> \
+ slot(const A1 &arg1, const A2 &arg2, const BindArgs & ... args) \
+ { \
+ init_slot_function(boost::bind(arg1, arg2, args...)); \
+ }
+
+
+#include <boost/signals2/detail/slot_template.hpp>
+#endif // BOOST_SIGNALS2_VARIADIC_SLOT_HPP
diff --git a/3rdParty/Boost/src/boost/smart_ptr.hpp b/3rdParty/Boost/src/boost/smart_ptr.hpp
deleted file mode 100644
index b5e569d..0000000
--- a/3rdParty/Boost/src/boost/smart_ptr.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef BOOST_SMART_PTR_HPP_INCLUDED
-#define BOOST_SMART_PTR_HPP_INCLUDED
-
-//
-// smart_ptr.hpp
-//
-// For convenience, this header includes the rest of the smart
-// pointer library headers.
-//
-// Copyright (c) 2003 Peter Dimov 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)
-//
-// http://www.boost.org/libs/smart_ptr/smart_ptr.htm
-//
-
-#include <boost/config.hpp>
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/scoped_array.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/shared_array.hpp>
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-# include <boost/weak_ptr.hpp>
-# include <boost/intrusive_ptr.hpp>
-# include <boost/enable_shared_from_this.hpp>
-# include <boost/make_shared.hpp>
-#endif
-
-#endif // #ifndef BOOST_SMART_PTR_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/timer.hpp b/3rdParty/Boost/src/boost/timer.hpp
new file mode 100644
index 0000000..1e3571e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/timer.hpp
@@ -0,0 +1,72 @@
+// boost timer.hpp header file ---------------------------------------------//
+
+// Copyright Beman Dawes 1994-99. 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)
+
+// See http://www.boost.org/libs/timer for documentation.
+
+// Revision History
+// 01 Apr 01 Modified to use new <boost/limits.hpp> header. (JMaddock)
+// 12 Jan 01 Change to inline implementation to allow use without library
+// builds. See docs for more rationale. (Beman Dawes)
+// 25 Sep 99 elapsed_max() and elapsed_min() added (John Maddock)
+// 16 Jul 99 Second beta
+// 6 Jul 99 Initial boost version
+
+#ifndef BOOST_TIMER_HPP
+#define BOOST_TIMER_HPP
+
+#include <boost/config.hpp>
+#include <ctime>
+#include <boost/limits.hpp>
+
+# ifdef BOOST_NO_STDC_NAMESPACE
+ namespace std { using ::clock_t; using ::clock; }
+# endif
+
+
+namespace boost {
+
+// timer -------------------------------------------------------------------//
+
+// A timer object measures elapsed time.
+
+// It is recommended that implementations measure wall clock rather than CPU
+// time since the intended use is performance measurement on systems where
+// total elapsed time is more important than just process or CPU time.
+
+// Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
+// due to implementation limitations. The accuracy of timings depends on the
+// accuracy of timing information provided by the underlying platform, and
+// this varies a great deal from platform to platform.
+
+class timer
+{
+ public:
+ timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
+// timer( const timer& src ); // post: elapsed()==src.elapsed()
+// ~timer(){}
+// timer& operator=( const timer& src ); // post: elapsed()==src.elapsed()
+ void restart() { _start_time = std::clock(); } // post: elapsed()==0
+ double elapsed() const // return elapsed time in seconds
+ { return double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
+
+ double elapsed_max() const // return estimated maximum value for elapsed()
+ // Portability warning: elapsed_max() may return too high a value on systems
+ // where std::clock_t overflows or resets at surprising values.
+ {
+ return (double((std::numeric_limits<std::clock_t>::max)())
+ - double(_start_time)) / double(CLOCKS_PER_SEC);
+ }
+
+ double elapsed_min() const // return minimum value for elapsed()
+ { return double(1)/double(CLOCKS_PER_SEC); }
+
+ private:
+ std::clock_t _start_time;
+}; // timer
+
+} // namespace boost
+
+#endif // BOOST_TIMER_HPP
diff --git a/3rdParty/Boost/src/libs/atomic/README.md b/3rdParty/Boost/src/libs/atomic/README.md
new file mode 100644
index 0000000..9c82949
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/README.md
@@ -0,0 +1,19 @@
+#![Boost.Atomic](doc/logo.png)
+
+Boost.Atomic, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), implements atomic operations for various CPU architectures, reflecting the standard interface defined in C++11.
+
+### Directories
+
+* **build** - Boost.Atomic build scripts
+* **doc** - QuickBook documentation sources
+* **include** - Interface headers of Boost.Atomic
+* **src** - Compilable source code of Boost.Atomic
+* **test** - Boost.Atomic unit tests
+
+### More information
+
+* [Documentation](http://boost.org/libs/atomic)
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
diff --git a/3rdParty/Boost/src/libs/atomic/doc/Jamfile.v2 b/3rdParty/Boost/src/libs/atomic/doc/Jamfile.v2
new file mode 100644
index 0000000..c293a66
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/doc/Jamfile.v2
@@ -0,0 +1,26 @@
+# Boost.Atomic library documentation Jamfile
+#
+# Copyright Helge Bahmann 2011.
+# Copyright Tim Blechmann 2012.
+# 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)
+
+import quickbook ;
+import boostbook : boostbook ;
+
+xml atomic : atomic.qbk ;
+
+boostbook standalone
+ : atomic
+ : <xsl:param>boost.root=../../../..
+ <xsl:param>boost.libraries=../../../libraries.htm
+ <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/atomic/doc/html
+ ;
+
+install css : [ glob $(BOOST_ROOT)/doc/src/*.css ]
+ : <location>html ;
+install images : [ glob $(BOOST_ROOT)/doc/src/images/*.png ]
+ : <location>html/images ;
+explicit css ;
+explicit images ;
diff --git a/3rdParty/Boost/src/libs/atomic/doc/atomic.hpp b/3rdParty/Boost/src/libs/atomic/doc/atomic.hpp
new file mode 100644
index 0000000..60e61c2
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/doc/atomic.hpp
@@ -0,0 +1,547 @@
+/** \file boost/atomic.hpp */
+
+// Copyright (c) 2009 Helge Bahmann
+//
+// 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)
+
+/* this is just a pseudo-header file fed to doxygen
+to more easily generate the class documentation; will
+be replaced by proper documentation down the road */
+
+namespace boost {
+
+/**
+ \brief Memory ordering constraints
+
+ This defines the relative order of one atomic operation
+ and other memory operations (loads, stores, other atomic operations)
+ executed by the same thread.
+
+ The order of operations specified by the programmer in the
+ source code ("program order") does not necessarily match
+ the order in which they are actually executed on the target system:
+ Both compiler as well as processor may reorder operations
+ quite arbitrarily. <B>Specifying the wrong ordering
+ constraint will therefore generally result in an incorrect program.</B>
+*/
+enum memory_order {
+ /**
+ \brief No constraint
+ Atomic operation and other memory operations may be reordered freely.
+ */
+ memory_order_relaxed,
+ /**
+ \brief Data dependence constraint
+ Atomic operation must strictly precede any memory operation that
+ computationally depends on the outcome of the atomic operation.
+ */
+ memory_order_consume,
+ /**
+ \brief Acquire memory
+ Atomic operation must strictly precede all memory operations that
+ follow in program order.
+ */
+ memory_order_acquire,
+ /**
+ \brief Release memory
+ Atomic operation must strictly follow all memory operations that precede
+ in program order.
+ */
+ memory_order_release,
+ /**
+ \brief Acquire and release memory
+ Combines the effects of \ref memory_order_acquire and \ref memory_order_release
+ */
+ memory_order_acq_rel,
+ /**
+ \brief Sequentially consistent
+ Produces the same result \ref memory_order_acq_rel, but additionally
+ enforces globally sequential consistent execution
+ */
+ memory_order_seq_cst
+};
+
+/**
+ \brief Atomic datatype
+
+ An atomic variable. Provides methods to modify this variable atomically.
+ Valid template parameters are:
+
+ - integral data types (char, short, int, ...)
+ - pointer data types
+ - any other data type that has a non-throwing default
+ constructor and that can be copied via <TT>memcpy</TT>
+
+ Unless specified otherwise, any memory ordering constraint can be used
+ with any of the atomic operations.
+*/
+template<typename Type>
+class atomic {
+public:
+ /**
+ \brief Create uninitialized atomic variable
+ Creates an atomic variable. Its initial value is undefined.
+ */
+ atomic();
+ /**
+ \brief Create an initialize atomic variable
+ \param value Initial value
+ Creates and initializes an atomic variable.
+ */
+ explicit atomic(Type value);
+
+ /**
+ \brief Read the current value of the atomic variable
+ \param order Memory ordering constraint, see \ref memory_order
+ \return Current value of the variable
+
+ Valid memory ordering constraints are:
+ - @c memory_order_relaxed
+ - @c memory_order_consume
+ - @c memory_order_acquire
+ - @c memory_order_seq_cst
+ */
+ Type load(memory_order order=memory_order_seq_cst) const;
+
+ /**
+ \brief Write new value to atomic variable
+ \param value New value
+ \param order Memory ordering constraint, see \ref memory_order
+
+ Valid memory ordering constraints are:
+ - @c memory_order_relaxed
+ - @c memory_order_release
+ - @c memory_order_seq_cst
+ */
+ void store(Type value, memory_order order=memory_order_seq_cst);
+
+ /**
+ \brief Atomically compare and exchange variable
+ \param expected Expected old value
+ \param desired Desired new value
+ \param order Memory ordering constraint, see \ref memory_order
+ \return @c true if value was changed
+
+ Atomically performs the following operation
+
+ \code
+ if (variable==expected) {
+ variable=desired;
+ return true;
+ } else {
+ expected=variable;
+ return false;
+ }
+ \endcode
+
+ This operation may fail "spuriously", i.e. the state of the variable
+ is unchanged even though the expected value was found (this is the
+ case on architectures using "load-linked"/"store conditional" to
+ implement the operation).
+
+ The established memory order will be @c order if the operation
+ is successful. If the operation is unsuccessful, the
+ memory order will be
+
+ - @c memory_order_relaxed if @c order is @c memory_order_acquire ,
+ @c memory_order_relaxed or @c memory_order_consume
+ - @c memory_order_release if @c order is @c memory_order_acq_release
+ or @c memory_order_release
+ - @c memory_order_seq_cst if @c order is @c memory_order_seq_cst
+ */
+ bool compare_exchange_weak(
+ Type &expected,
+ Type desired,
+ memory_order order=memory_order_seq_cst);
+
+ /**
+ \brief Atomically compare and exchange variable
+ \param expected Expected old value
+ \param desired Desired new value
+ \param success_order Memory ordering constraint if operation
+ is successful
+ \param failure_order Memory ordering constraint if operation is unsuccessful
+ \return @c true if value was changed
+
+ Atomically performs the following operation
+
+ \code
+ if (variable==expected) {
+ variable=desired;
+ return true;
+ } else {
+ expected=variable;
+ return false;
+ }
+ \endcode
+
+ This operation may fail "spuriously", i.e. the state of the variable
+ is unchanged even though the expected value was found (this is the
+ case on architectures using "load-linked"/"store conditional" to
+ implement the operation).
+
+ The constraint imposed by @c success_order may not be
+ weaker than the constraint imposed by @c failure_order.
+ */
+ bool compare_exchange_weak(
+ Type &expected,
+ Type desired,
+ memory_order success_order,
+ memory_order failure_order);
+ /**
+ \brief Atomically compare and exchange variable
+ \param expected Expected old value
+ \param desired Desired new value
+ \param order Memory ordering constraint, see \ref memory_order
+ \return @c true if value was changed
+
+ Atomically performs the following operation
+
+ \code
+ if (variable==expected) {
+ variable=desired;
+ return true;
+ } else {
+ expected=variable;
+ return false;
+ }
+ \endcode
+
+ In contrast to \ref compare_exchange_weak, this operation will never
+ fail spuriously. Since compare-and-swap must generally be retried
+ in a loop, implementors are advised to prefer \ref compare_exchange_weak
+ where feasible.
+
+ The established memory order will be @c order if the operation
+ is successful. If the operation is unsuccessful, the
+ memory order will be
+
+ - @c memory_order_relaxed if @c order is @c memory_order_acquire ,
+ @c memory_order_relaxed or @c memory_order_consume
+ - @c memory_order_release if @c order is @c memory_order_acq_release
+ or @c memory_order_release
+ - @c memory_order_seq_cst if @c order is @c memory_order_seq_cst
+ */
+ bool compare_exchange_strong(
+ Type &expected,
+ Type desired,
+ memory_order order=memory_order_seq_cst);
+
+ /**
+ \brief Atomically compare and exchange variable
+ \param expected Expected old value
+ \param desired Desired new value
+ \param success_order Memory ordering constraint if operation
+ is successful
+ \param failure_order Memory ordering constraint if operation is unsuccessful
+ \return @c true if value was changed
+
+ Atomically performs the following operation
+
+ \code
+ if (variable==expected) {
+ variable=desired;
+ return true;
+ } else {
+ expected=variable;
+ return false;
+ }
+ \endcode
+
+ In contrast to \ref compare_exchange_weak, this operation will never
+ fail spuriously. Since compare-and-swap must generally be retried
+ in a loop, implementors are advised to prefer \ref compare_exchange_weak
+ where feasible.
+
+ The constraint imposed by @c success_order may not be
+ weaker than the constraint imposed by @c failure_order.
+ */
+ bool compare_exchange_strong(
+ Type &expected,
+ Type desired,
+ memory_order success_order,
+ memory_order failure_order);
+ /**
+ \brief Atomically exchange variable
+ \param value New value
+ \param order Memory ordering constraint, see \ref memory_order
+ \return Old value of the variable
+
+ Atomically exchanges the value of the variable with the new
+ value and returns its old value.
+ */
+ Type exchange(Type value, memory_order order=memory_order_seq_cst);
+
+ /**
+ \brief Atomically add and return old value
+ \param operand Operand
+ \param order Memory ordering constraint, see \ref memory_order
+ \return Old value of the variable
+
+ Atomically adds operand to the variable and returns its
+ old value.
+ */
+ Type fetch_add(Type operand, memory_order order=memory_order_seq_cst);
+ /**
+ \brief Atomically subtract and return old value
+ \param operand Operand
+ \param order Memory ordering constraint, see \ref memory_order
+ \return Old value of the variable
+
+ Atomically subtracts operand from the variable and returns its
+ old value.
+
+ This method is available only if \c Type is an integral type
+ or a non-void pointer type. If it is a pointer type,
+ @c operand is of type @c ptrdiff_t and the operation
+ is performed following the rules for pointer arithmetic
+ in C++.
+ */
+ Type fetch_sub(Type operand, memory_order order=memory_order_seq_cst);
+
+ /**
+ \brief Atomically perform bitwise "AND" and return old value
+ \param operand Operand
+ \param order Memory ordering constraint, see \ref memory_order
+ \return Old value of the variable
+
+ Atomically performs bitwise "AND" with the variable and returns its
+ old value.
+
+ This method is available only if \c Type is an integral type
+ or a non-void pointer type. If it is a pointer type,
+ @c operand is of type @c ptrdiff_t and the operation
+ is performed following the rules for pointer arithmetic
+ in C++.
+ */
+ Type fetch_and(Type operand, memory_order order=memory_order_seq_cst);
+
+ /**
+ \brief Atomically perform bitwise "OR" and return old value
+ \param operand Operand
+ \param order Memory ordering constraint, see \ref memory_order
+ \return Old value of the variable
+
+ Atomically performs bitwise "OR" with the variable and returns its
+ old value.
+
+ This method is available only if \c Type is an integral type.
+ */
+ Type fetch_or(Type operand, memory_order order=memory_order_seq_cst);
+
+ /**
+ \brief Atomically perform bitwise "XOR" and return old value
+ \param operand Operand
+ \param order Memory ordering constraint, see \ref memory_order
+ \return Old value of the variable
+
+ Atomically performs bitwise "XOR" with the variable and returns its
+ old value.
+
+ This method is available only if \c Type is an integral type.
+ */
+ Type fetch_xor(Type operand, memory_order order=memory_order_seq_cst);
+
+ /**
+ \brief Implicit load
+ \return Current value of the variable
+
+ The same as <tt>load(memory_order_seq_cst)</tt>. Avoid using
+ the implicit conversion operator, use \ref load with
+ an explicit memory ordering constraint.
+ */
+ operator Type(void) const;
+ /**
+ \brief Implicit store
+ \param value New value
+ \return Copy of @c value
+
+ The same as <tt>store(value, memory_order_seq_cst)</tt>. Avoid using
+ the implicit conversion operator, use \ref store with
+ an explicit memory ordering constraint.
+ */
+ Type operator=(Type v);
+
+ /**
+ \brief Atomically perform bitwise "AND" and return new value
+ \param operand Operand
+ \return New value of the variable
+
+ The same as <tt>fetch_and(operand, memory_order_seq_cst)&operand</tt>.
+ Avoid using the implicit bitwise "AND" operator, use \ref fetch_and
+ with an explicit memory ordering constraint.
+ */
+ Type operator&=(Type operand);
+
+ /**
+ \brief Atomically perform bitwise "OR" and return new value
+ \param operand Operand
+ \return New value of the variable
+
+ The same as <tt>fetch_or(operand, memory_order_seq_cst)|operand</tt>.
+ Avoid using the implicit bitwise "OR" operator, use \ref fetch_or
+ with an explicit memory ordering constraint.
+
+ This method is available only if \c Type is an integral type.
+ */
+ Type operator|=(Type operand);
+
+ /**
+ \brief Atomically perform bitwise "XOR" and return new value
+ \param operand Operand
+ \return New value of the variable
+
+ The same as <tt>fetch_xor(operand, memory_order_seq_cst)^operand</tt>.
+ Avoid using the implicit bitwise "XOR" operator, use \ref fetch_xor
+ with an explicit memory ordering constraint.
+
+ This method is available only if \c Type is an integral type.
+ */
+ Type operator^=(Type operand);
+
+ /**
+ \brief Atomically add and return new value
+ \param operand Operand
+ \return New value of the variable
+
+ The same as <tt>fetch_add(operand, memory_order_seq_cst)+operand</tt>.
+ Avoid using the implicit add operator, use \ref fetch_add
+ with an explicit memory ordering constraint.
+
+ This method is available only if \c Type is an integral type
+ or a non-void pointer type. If it is a pointer type,
+ @c operand is of type @c ptrdiff_t and the operation
+ is performed following the rules for pointer arithmetic
+ in C++.
+ */
+ Type operator+=(Type operand);
+
+ /**
+ \brief Atomically subtract and return new value
+ \param operand Operand
+ \return New value of the variable
+
+ The same as <tt>fetch_sub(operand, memory_order_seq_cst)-operand</tt>.
+ Avoid using the implicit subtract operator, use \ref fetch_sub
+ with an explicit memory ordering constraint.
+
+ This method is available only if \c Type is an integral type
+ or a non-void pointer type. If it is a pointer type,
+ @c operand is of type @c ptrdiff_t and the operation
+ is performed following the rules for pointer arithmetic
+ in C++.
+ */
+ Type operator-=(Type operand);
+
+ /**
+ \brief Atomically increment and return new value
+ \return New value of the variable
+
+ The same as <tt>fetch_add(1, memory_order_seq_cst)+1</tt>.
+ Avoid using the implicit increment operator, use \ref fetch_add
+ with an explicit memory ordering constraint.
+
+ This method is available only if \c Type is an integral type
+ or a non-void pointer type. If it is a pointer type,
+ the operation
+ is performed following the rules for pointer arithmetic
+ in C++.
+ */
+ Type operator++(void);
+ /**
+ \brief Atomically increment and return old value
+ \return Old value of the variable
+
+ The same as <tt>fetch_add(1, memory_order_seq_cst)</tt>.
+ Avoid using the implicit increment operator, use \ref fetch_add
+ with an explicit memory ordering constraint.
+
+ This method is available only if \c Type is an integral type
+ or a non-void pointer type. If it is a pointer type,
+ the operation
+ is performed following the rules for pointer arithmetic
+ in C++.
+ */
+ Type operator++(int);
+ /**
+ \brief Atomically subtract and return new value
+ \return New value of the variable
+
+ The same as <tt>fetch_sub(1, memory_order_seq_cst)-1</tt>.
+ Avoid using the implicit increment operator, use \ref fetch_sub
+ with an explicit memory ordering constraint.
+
+ This method is available only if \c Type is an integral type
+ or a non-void pointer type. If it is a pointer type,
+ the operation
+ is performed following the rules for pointer arithmetic
+ in C++.
+ */
+ Type operator--(void);
+ /**
+ \brief Atomically subtract and return old value
+ \return Old value of the variable
+
+ The same as <tt>fetch_sub(1, memory_order_seq_cst)</tt>.
+ Avoid using the implicit increment operator, use \ref fetch_sub
+ with an explicit memory ordering constraint.
+
+ This method is available only if \c Type is an integral type
+ or a non-void pointer type. If it is a pointer type,
+ the operation
+ is performed following the rules for pointer arithmetic
+ in C++.
+ */
+ Type operator--(int);
+
+ /** \brief Deleted copy constructor */
+ atomic(const atomic &) = delete;
+ /** \brief Deleted copy assignment */
+ const atomic & operator=(const atomic &) = delete;
+};
+
+/**
+ \brief Insert explicit fence for thread synchronization
+ \param order Memory ordering constraint
+
+ Inserts an explicit fence. The exact semantic depends on the
+ type of fence inserted:
+
+ - \c memory_order_relaxed: No operation
+ - \c memory_order_release: Performs a "release" operation
+ - \c memory_order_acquire or \c memory_order_consume: Performs an
+ "acquire" operation
+ - \c memory_order_acq_rel: Performs both an "acquire" and a "release"
+ operation
+ - \c memory_order_seq_cst: Performs both an "acquire" and a "release"
+ operation and in addition there exists a global total order of
+ all \c memory_order_seq_cst operations
+
+*/
+void atomic_thread_fence(memory_order order);
+
+/**
+ \brief Insert explicit fence for synchronization with a signal handler
+ \param order Memory ordering constraint
+
+ Inserts an explicit fence to synchronize with a signal handler called within
+ the context of the same thread. The fence ensures the corresponding operations
+ around it are complete and/or not started. The exact semantic depends on the
+ type of fence inserted:
+
+ - \c memory_order_relaxed: No operation
+ - \c memory_order_release: Ensures the operations before the fence are complete
+ - \c memory_order_acquire or \c memory_order_consume: Ensures the operations
+ after the fence are not started.
+ - \c memory_order_acq_rel or \c memory_order_seq_cst: Ensures the operations
+ around the fence do not cross it.
+
+ Note that this call does not affect visibility order of the memory operations
+ to other threads. It is functionally similar to \c atomic_thread_fence, only
+ it does not generate any instructions to synchronize hardware threads.
+*/
+void atomic_signal_fence(memory_order order);
+
+}
diff --git a/3rdParty/Boost/src/libs/atomic/doc/atomic.qbk b/3rdParty/Boost/src/libs/atomic/doc/atomic.qbk
new file mode 100644
index 0000000..880fab5
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/doc/atomic.qbk
@@ -0,0 +1,828 @@
+[/
+ / Copyright (c) 2009 Helge Bahmann
+ / Copyright (c) 2014 Andrey Semashev
+ /
+ / 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)
+ /]
+
+[library Boost.Atomic
+ [quickbook 1.4]
+ [authors [Bahmann, Helge][Semashev, Andrey]]
+ [copyright 2011 Helge Bahmann]
+ [copyright 2012 Tim Blechmann]
+ [copyright 2013 Andrey Semashev]
+ [id atomic]
+ [dirname atomic]
+ [purpose Atomic operations]
+ [license
+ 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])
+ ]
+]
+
+[section:introduction Introduction]
+
+[section:introduction_presenting Presenting Boost.Atomic]
+
+[*Boost.Atomic] is a library that provides [^atomic]
+data types and operations on these data types, as well as memory
+ordering constraints required for coordinating multiple threads through
+atomic variables. It implements the interface as defined by the C++11
+standard, but makes this feature available for platforms lacking
+system/compiler support for this particular C++11 feature.
+
+Users of this library should already be familiar with concurrency
+in general, as well as elementary concepts such as "mutual exclusion".
+
+The implementation makes use of processor-specific instructions where
+possible (via inline assembler, platform libraries or compiler
+intrinsics), and falls back to "emulating" atomic operations through
+locking.
+
+[endsect]
+
+[section:introduction_purpose Purpose]
+
+Operations on "ordinary" variables are not guaranteed to be atomic.
+This means that with [^int n=0] initially, two threads concurrently
+executing
+
+[c++]
+
+ void function()
+ {
+ n ++;
+ }
+
+might result in [^n==1] instead of 2: Each thread will read the
+old value into a processor register, increment it and write the result
+back. Both threads may therefore write [^1], unaware that the other thread
+is doing likewise.
+
+Declaring [^atomic<int> n=0] instead, the same operation on
+this variable will always result in [^n==2] as each operation on this
+variable is ['atomic]: This means that each operation behaves as if it
+were strictly sequentialized with respect to the other.
+
+Atomic variables are useful for two purposes:
+
+* as a means for coordinating multiple threads via custom
+ coordination protocols
+* as faster alternatives to "locked" access to simple variables
+
+Take a look at the [link atomic.usage_examples examples] section
+for common patterns.
+
+[endsect]
+
+[endsect]
+
+[section:thread_coordination Thread coordination using Boost.Atomic]
+
+The most common use of [*Boost.Atomic] is to realize custom
+thread synchronization protocols: The goal is to coordinate
+accesses of threads to shared variables in order to avoid
+"conflicts". The
+programmer must be aware of the fact that
+compilers, CPUs and the cache
+hierarchies may generally reorder memory references at will.
+As a consequence a program such as:
+
+[c++]
+
+ int x = 0, int y = 0;
+
+ thread1:
+ x = 1;
+ y = 1;
+
+ thread2
+ if (y == 1) {
+ assert(x == 1);
+ }
+
+might indeed fail as there is no guarantee that the read of `x`
+by thread2 "sees" the write by thread1.
+
+[*Boost.Atomic] uses a synchronisation concept based on the
+['happens-before] relation to describe the guarantees under
+which situations such as the above one cannot occur.
+
+The remainder of this section will discuss ['happens-before] in
+a "hands-on" way instead of giving a fully formalized definition.
+The reader is encouraged to additionally have a
+look at the discussion of the correctness of a few of the
+[link atomic.usage_examples examples] afterwards.
+
+[section:mutex Enforcing ['happens-before] through mutual exclusion]
+
+As an introductory example to understand how arguing using
+['happens-before] works, consider two threads synchronizing
+using a common mutex:
+
+[c++]
+
+ mutex m;
+
+ thread1:
+ m.lock();
+ ... /* A */
+ m.unlock();
+
+ thread2:
+ m.lock();
+ ... /* B */
+ m.unlock();
+
+The "lockset-based intuition" would be to argue that A and B
+cannot be executed concurrently as the code paths require a
+common lock to be held.
+
+One can however also arrive at the same conclusion using
+['happens-before]: Either thread1 or thread2 will succeed first
+at [^m.lock()]. If this is be thread1, then as a consequence,
+thread2 cannot succeed at [^m.lock()] before thread1 has executed
+[^m.unlock()], consequently A ['happens-before] B in this case.
+By symmetry, if thread2 succeeds at [^m.lock()] first, we can
+conclude B ['happens-before] A.
+
+Since this already exhausts all options, we can conclude that
+either A ['happens-before] B or B ['happens-before] A must
+always hold. Obviously cannot state ['which] of the two relationships
+holds, but either one is sufficient to conclude that A and B
+cannot conflict.
+
+Compare the [link boost_atomic.usage_examples.example_spinlock spinlock]
+implementation to see how the mutual exclusion concept can be
+mapped to [*Boost.Atomic].
+
+[endsect]
+
+[section:release_acquire ['happens-before] through [^release] and [^acquire]]
+
+The most basic pattern for coordinating threads via [*Boost.Atomic]
+uses [^release] and [^acquire] on an atomic variable for coordination: If ...
+
+* ... thread1 performs an operation A,
+* ... thread1 subsequently writes (or atomically
+ modifies) an atomic variable with [^release] semantic,
+* ... thread2 reads (or atomically reads-and-modifies)
+ the value this value from the same atomic variable with
+ [^acquire] semantic and
+* ... thread2 subsequently performs an operation B,
+
+... then A ['happens-before] B.
+
+Consider the following example
+
+[c++]
+
+ atomic<int> a(0);
+
+ thread1:
+ ... /* A */
+ a.fetch_add(1, memory_order_release);
+
+ thread2:
+ int tmp = a.load(memory_order_acquire);
+ if (tmp == 1) {
+ ... /* B */
+ } else {
+ ... /* C */
+ }
+
+In this example, two avenues for execution are possible:
+
+* The [^store] operation by thread1 precedes the [^load] by thread2:
+ In this case thread2 will execute B and "A ['happens-before] B"
+ holds as all of the criteria above are satisfied.
+* The [^load] operation by thread2 precedes the [^store] by thread1:
+ In this case, thread2 will execute C, but "A ['happens-before] C"
+ does ['not] hold: thread2 does not read the value written by
+ thread1 through [^a].
+
+Therefore, A and B cannot conflict, but A and C ['can] conflict.
+
+[endsect]
+
+[section:fences Fences]
+
+Ordering constraints are generally specified together with an access to
+an atomic variable. It is however also possible to issue "fence"
+operations in isolation, in this case the fence operates in
+conjunction with preceding (for `acquire`, `consume` or `seq_cst`
+operations) or succeeding (for `release` or `seq_cst`) atomic
+operations.
+
+The example from the previous section could also be written in
+the following way:
+
+[c++]
+
+ atomic<int> a(0);
+
+ thread1:
+ ... /* A */
+ atomic_thread_fence(memory_order_release);
+ a.fetch_add(1, memory_order_relaxed);
+
+ thread2:
+ int tmp = a.load(memory_order_relaxed);
+ if (tmp == 1) {
+ atomic_thread_fence(memory_order_acquire);
+ ... /* B */
+ } else {
+ ... /* C */
+ }
+
+This provides the same ordering guarantees as previously, but
+elides a (possibly expensive) memory ordering operation in
+the case C is executed.
+
+[endsect]
+
+[section:release_consume ['happens-before] through [^release] and [^consume]]
+
+The second pattern for coordinating threads via [*Boost.Atomic]
+uses [^release] and [^consume] on an atomic variable for coordination: If ...
+
+* ... thread1 performs an operation A,
+* ... thread1 subsequently writes (or atomically modifies) an
+ atomic variable with [^release] semantic,
+* ... thread2 reads (or atomically reads-and-modifies)
+ the value this value from the same atomic variable with [^consume] semantic and
+* ... thread2 subsequently performs an operation B that is ['computationally
+ dependent on the value of the atomic variable],
+
+... then A ['happens-before] B.
+
+Consider the following example
+
+[c++]
+
+ atomic<int> a(0);
+ complex_data_structure data[2];
+
+ thread1:
+ data[1] = ...; /* A */
+ a.store(1, memory_order_release);
+
+ thread2:
+ int index = a.load(memory_order_consume);
+ complex_data_structure tmp = data[index]; /* B */
+
+In this example, two avenues for execution are possible:
+
+* The [^store] operation by thread1 precedes the [^load] by thread2:
+ In this case thread2 will read [^data\[1\]] and "A ['happens-before] B"
+ holds as all of the criteria above are satisfied.
+* The [^load] operation by thread2 precedes the [^store] by thread1:
+ In this case thread2 will read [^data\[0\]] and "A ['happens-before] B"
+ does ['not] hold: thread2 does not read the value written by
+ thread1 through [^a].
+
+Here, the ['happens-before] relationship helps ensure that any
+accesses (presumable writes) to [^data\[1\]] by thread1 happen before
+before the accesses (presumably reads) to [^data\[1\]] by thread2:
+Lacking this relationship, thread2 might see stale/inconsistent
+data.
+
+Note that in this example, the fact that operation B is computationally
+dependent on the atomic variable, therefore the following program would
+be erroneous:
+
+[c++]
+
+ atomic<int> a(0);
+ complex_data_structure data[2];
+
+ thread1:
+ data[1] = ...; /* A */
+ a.store(1, memory_order_release);
+
+ thread2:
+ int index = a.load(memory_order_consume);
+ complex_data_structure tmp;
+ if (index == 0)
+ tmp = data[0];
+ else
+ tmp = data[1];
+
+[^consume] is most commonly (and most safely! see
+[link atomic.limitations limitations]) used with
+pointers, compare for example the
+[link boost_atomic.usage_examples.singleton singleton with double-checked locking].
+
+[endsect]
+
+[section:seq_cst Sequential consistency]
+
+The third pattern for coordinating threads via [*Boost.Atomic]
+uses [^seq_cst] for coordination: If ...
+
+* ... thread1 performs an operation A,
+* ... thread1 subsequently performs any operation with [^seq_cst],
+* ... thread1 subsequently performs an operation B,
+* ... thread2 performs an operation C,
+* ... thread2 subsequently performs any operation with [^seq_cst],
+* ... thread2 subsequently performs an operation D,
+
+then either "A ['happens-before] D" or "C ['happens-before] B" holds.
+
+In this case it does not matter whether thread1 and thread2 operate
+on the same or different atomic variables, or use a "stand-alone"
+[^atomic_thread_fence] operation.
+
+[endsect]
+
+[endsect]
+
+[section:interface Programming interfaces]
+
+[section:configuration Configuration and building]
+
+The library contains header-only and compiled parts. The library is
+header-only for lock-free cases but requires a separate binary to
+implement the lock-based emulation. Users are able to detect whether
+linking to the compiled part is required by checking the
+[link atomic.interface.feature_macros feature macros].
+
+The following macros affect library behavior:
+
+[table
+ [[Macro] [Description]]
+ [[`BOOST_ATOMIC_NO_CMPXCHG16B`] [Affects 64-bit x86 MSVC builds. When defined,
+ the library assumes the target CPU does not support `cmpxchg16b` instruction used
+ to support 128-bit atomic operations. This is the case with some early 64-bit AMD CPUs,
+ all Intel CPUs and current AMD CPUs support this instruction. The library does not
+ perform runtime detection of this instruction, so running the code that uses 128-bit
+ atomics on such CPUs will result in crashes, unless this macro is defined. Note that
+ the macro does not affect GCC and compatible compilers because the library infers
+ this information from the compiler-defined macros.]]
+ [[`BOOST_ATOMIC_FORCE_FALLBACK`] [When defined, all operations are implemented with locks.
+ This is mostly used for testing and should not be used in real world projects.]]
+ [[`BOOST_ATOMIC_DYN_LINK` and `BOOST_ALL_DYN_LINK`] [Control library linking. If defined,
+ the library assumes dynamic linking, otherwise static. The latter macro affects all Boost
+ libraries, not just [*Boost.Atomic].]]
+ [[`BOOST_ATOMIC_NO_LIB` and `BOOST_ALL_NO_LIB`] [Control library auto-linking on Windows.
+ When defined, disables auto-linking. The latter macro affects all Boost libraries,
+ not just [*Boost.Atomic].]]
+]
+
+Besides macros, it is important to specify the correct compiler options for the target CPU.
+With GCC and compatible compilers this affects whether particular atomic operations are
+lock-free or not.
+
+Boost building process is described in the [@http://www.boost.org/doc/libs/release/more/getting_started/ Getting Started guide].
+For example, you can build [*Boost.Atomic] with the following command line:
+
+[pre
+ bjam --with-atomic variant=release instruction-set=core2 stage
+]
+
+[endsect]
+
+[section:interface_memory_order Memory order]
+
+ #include <boost/memory_order.hpp>
+
+The enumeration [^boost::memory_order] defines the following
+values to represent memory ordering constraints:
+
+[table
+ [[Constant] [Description]]
+ [[`memory_order_relaxed`] [No ordering constraint.
+ Informally speaking, following operations may be reordered before,
+ preceding operations may be reordered after the atomic
+ operation. This constraint is suitable only when
+ either a) further operations do not depend on the outcome
+ of the atomic operation or b) ordering is enforced through
+ stand-alone `atomic_thread_fence` operations. The operation on
+ the atomic value itself is still atomic though.
+ ]]
+ [[`memory_order_release`] [
+ Perform `release` operation. Informally speaking,
+ prevents all preceding memory operations to be reordered
+ past this point.
+ ]]
+ [[`memory_order_acquire`] [
+ Perform `acquire` operation. Informally speaking,
+ prevents succeeding memory operations to be reordered
+ before this point.
+ ]]
+ [[`memory_order_consume`] [
+ Perform `consume` operation. More relaxed (and
+ on some architectures more efficient) than `memory_order_acquire`
+ as it only affects succeeding operations that are
+ computationally-dependent on the value retrieved from
+ an atomic variable.
+ ]]
+ [[`memory_order_acq_rel`] [Perform both `release` and `acquire` operation]]
+ [[`memory_order_seq_cst`] [
+ Enforce sequential consistency. Implies `memory_order_acq_rel`, but
+ additionally enforces total order for all operations such qualified.
+ ]]
+]
+
+See section [link atomic.thread_coordination ['happens-before]] for explanation
+of the various ordering constraints.
+
+[endsect]
+
+[section:interface_atomic_object Atomic objects]
+
+ #include <boost/atomic/atomic.hpp>
+
+[^boost::atomic<['T]>] provides methods for atomically accessing
+variables of a suitable type [^['T]]. The type is suitable if
+it is /trivially copyable/ (3.9/9 \[basic.types\]). Following are
+examples of the types compatible with this requirement:
+
+* a scalar type (e.g. integer, boolean, enum or pointer type)
+* a [^class] or [^struct] that has no non-trivial copy or move
+ constructors or assignment operators, has a trivial destructor,
+ and that is comparable via [^memcmp].
+
+Note that classes with virtual functions or virtual base classes
+do not satisfy the requirements. Also be warned
+that structures with "padding" between data members may compare
+non-equal via [^memcmp] even though all members are equal.
+
+[section:interface_atomic_generic [^boost::atomic<['T]>] template class]
+
+All atomic objects supports the following operations:
+
+[table
+ [[Syntax] [Description]]
+ [
+ [`atomic()`]
+ [Initialize to an unspecified value]
+ ]
+ [
+ [`atomic(T initial_value)`]
+ [Initialize to [^initial_value]]
+ ]
+ [
+ [`bool is_lock_free()`]
+ [Checks if the atomic object is lock-free]
+ ]
+ [
+ [`T load(memory_order order)`]
+ [Return current value]
+ ]
+ [
+ [`void store(T value, memory_order order)`]
+ [Write new value to atomic variable]
+ ]
+ [
+ [`T exchange(T new_value, memory_order order)`]
+ [Exchange current value with `new_value`, returning current value]
+ ]
+ [
+ [`bool compare_exchange_weak(T & expected, T desired, memory_order order)`]
+ [Compare current value with `expected`, change it to `desired` if matches.
+ Returns `true` if an exchange has been performed, and always writes the
+ previous value back in `expected`. May fail spuriously, so must generally be
+ retried in a loop.]
+ ]
+ [
+ [`bool compare_exchange_weak(T & expected, T desired, memory_order success_order, memory_order failure_order)`]
+ [Compare current value with `expected`, change it to `desired` if matches.
+ Returns `true` if an exchange has been performed, and always writes the
+ previous value back in `expected`. May fail spuriously, so must generally be
+ retried in a loop.]
+ ]
+ [
+ [`bool compare_exchange_strong(T & expected, T desired, memory_order order)`]
+ [Compare current value with `expected`, change it to `desired` if matches.
+ Returns `true` if an exchange has been performed, and always writes the
+ previous value back in `expected`.]
+ ]
+ [
+ [`bool compare_exchange_strong(T & expected, T desired, memory_order success_order, memory_order failure_order))`]
+ [Compare current value with `expected`, change it to `desired` if matches.
+ Returns `true` if an exchange has been performed, and always writes the
+ previous value back in `expected`.]
+ ]
+]
+
+`order` always has `memory_order_seq_cst` as default parameter.
+
+The `compare_exchange_weak`/`compare_exchange_strong` variants
+taking four parameters differ from the three parameter variants
+in that they allow a different memory ordering constraint to
+be specified in case the operation fails.
+
+In addition to these explicit operations, each
+[^atomic<['T]>] object also supports
+implicit [^store] and [^load] through the use of "assignment"
+and "conversion to [^T]" operators. Avoid using these operators,
+as they do not allow explicit specification of a memory ordering
+constraint.
+
+[endsect]
+
+[section:interface_atomic_integral [^boost::atomic<['integral]>] template class]
+
+In addition to the operations listed in the previous section,
+[^boost::atomic<['I]>] for integral
+types [^['I]] supports the following operations:
+
+[table
+ [[Syntax] [Description]]
+ [
+ [`T fetch_add(T v, memory_order order)`]
+ [Add `v` to variable, returning previous value]
+ ]
+ [
+ [`T fetch_sub(T v, memory_order order)`]
+ [Subtract `v` from variable, returning previous value]
+ ]
+ [
+ [`T fetch_and(T v, memory_order order)`]
+ [Apply bit-wise "and" with `v` to variable, returning previous value]
+ ]
+ [
+ [`T fetch_or(T v, memory_order order)`]
+ [Apply bit-wise "or" with `v` to variable, returning previous value]
+ ]
+ [
+ [`T fetch_xor(T v, memory_order order)`]
+ [Apply bit-wise "xor" with `v` to variable, returning previous value]
+ ]
+]
+
+`order` always has `memory_order_seq_cst` as default parameter.
+
+In addition to these explicit operations, each
+[^boost::atomic<['I]>] object also
+supports implicit pre-/post- increment/decrement, as well
+as the operators `+=`, `-=`, `&=`, `|=` and `^=`.
+Avoid using these operators,
+as they do not allow explicit specification of a memory ordering
+constraint.
+
+[endsect]
+
+[section:interface_atomic_pointer [^boost::atomic<['pointer]>] template class]
+
+In addition to the operations applicable to all atomic object,
+[^boost::atomic<['P]>] for pointer
+types [^['P]] (other than [^void] pointers) support the following operations:
+
+[table
+ [[Syntax] [Description]]
+ [
+ [`T fetch_add(ptrdiff_t v, memory_order order)`]
+ [Add `v` to variable, returning previous value]
+ ]
+ [
+ [`T fetch_sub(ptrdiff_t v, memory_order order)`]
+ [Subtract `v` from variable, returning previous value]
+ ]
+]
+
+`order` always has `memory_order_seq_cst` as default parameter.
+
+In addition to these explicit operations, each
+[^boost::atomic<['P]>] object also
+supports implicit pre-/post- increment/decrement, as well
+as the operators `+=`, `-=`. Avoid using these operators,
+as they do not allow explicit specification of a memory ordering
+constraint.
+
+[endsect]
+
+[endsect]
+
+[section:interface_fences Fences]
+
+ #include <boost/atomic/fences.hpp>
+
+[table
+ [[Syntax] [Description]]
+ [
+ [`void atomic_thread_fence(memory_order order)`]
+ [Issue fence for coordination with other threads.]
+ ]
+ [
+ [`void atomic_signal_fence(memory_order order)`]
+ [Issue fence for coordination with signal handler (only in same thread).]
+ ]
+]
+
+[endsect]
+
+[section:feature_macros Feature testing macros]
+
+ #include <boost/atomic/capabilities.hpp>
+
+[*Boost.Atomic] defines a number of macros to allow compile-time
+detection whether an atomic data type is implemented using
+"true" atomic operations, or whether an internal "lock" is
+used to provide atomicity. The following macros will be
+defined to `0` if operations on the data type always
+require a lock, to `1` if operations on the data type may
+sometimes require a lock, and to `2` if they are always lock-free:
+
+[table
+ [[Macro] [Description]]
+ [
+ [`BOOST_ATOMIC_FLAG_LOCK_FREE`]
+ [Indicate whether `atomic_flag` is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_BOOL_LOCK_FREE`]
+ [Indicate whether `atomic<bool>` is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_CHAR_LOCK_FREE`]
+ [Indicate whether `atomic<char>` (including signed/unsigned variants) is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_CHAR16_T_LOCK_FREE`]
+ [Indicate whether `atomic<char16_t>` (including signed/unsigned variants) is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_CHAR32_T_LOCK_FREE`]
+ [Indicate whether `atomic<char32_t>` (including signed/unsigned variants) is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_WCHAR_T_LOCK_FREE`]
+ [Indicate whether `atomic<wchar_t>` (including signed/unsigned variants) is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_SHORT_LOCK_FREE`]
+ [Indicate whether `atomic<short>` (including signed/unsigned variants) is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_INT_LOCK_FREE`]
+ [Indicate whether `atomic<int>` (including signed/unsigned variants) is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_LONG_LOCK_FREE`]
+ [Indicate whether `atomic<long>` (including signed/unsigned variants) is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_LLONG_LOCK_FREE`]
+ [Indicate whether `atomic<long long>` (including signed/unsigned variants) is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_ADDRESS_LOCK_FREE` or `BOOST_ATOMIC_POINTER_LOCK_FREE`]
+ [Indicate whether `atomic<T *>` is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_THREAD_FENCE`]
+ [Indicate whether `atomic_thread_fence` function is lock-free]
+ ]
+ [
+ [`BOOST_ATOMIC_SIGNAL_FENCE`]
+ [Indicate whether `atomic_signal_fence` function is lock-free]
+ ]
+]
+
+In addition to these standard macros, [*Boost.Atomic] also defines a number of extension macros,
+which can also be useful. Like the standard ones, these macros are defined to values `0`, `1` and `2`
+to indicate whether the corresponding operations are lock-free or not.
+
+[table
+ [[Macro] [Description]]
+ [
+ [`BOOST_ATOMIC_INT8_LOCK_FREE`]
+ [Indicate whether `atomic<int8_type>` is lock-free.]
+ ]
+ [
+ [`BOOST_ATOMIC_INT16_LOCK_FREE`]
+ [Indicate whether `atomic<int16_type>` is lock-free.]
+ ]
+ [
+ [`BOOST_ATOMIC_INT32_LOCK_FREE`]
+ [Indicate whether `atomic<int32_type>` is lock-free.]
+ ]
+ [
+ [`BOOST_ATOMIC_INT64_LOCK_FREE`]
+ [Indicate whether `atomic<int64_type>` is lock-free.]
+ ]
+ [
+ [`BOOST_ATOMIC_INT128_LOCK_FREE`]
+ [Indicate whether `atomic<int128_type>` is lock-free.]
+ ]
+ [
+ [`BOOST_ATOMIC_NO_ATOMIC_FLAG_INIT`]
+ [Defined after including `atomic_flag.hpp`, if the implementation
+ does not support the `BOOST_ATOMIC_FLAG_INIT` macro for static
+ initialization of `atomic_flag`. This macro is typically defined
+ for pre-C++11 compilers.]
+ ]
+]
+
+In the table above, `intN_type` is a type that fits storage of contiguous `N` bits, suitably aligned for atomic operations.
+
+[endsect]
+
+[endsect]
+
+[section:usage_examples Usage examples]
+
+[include examples.qbk]
+
+[endsect]
+
+[/
+[section:platform_support Implementing support for additional platforms]
+
+[include platform.qbk]
+
+[endsect]
+]
+
+[/ [xinclude autodoc.xml] ]
+
+[section:limitations Limitations]
+
+While [*Boost.Atomic] strives to implement the atomic operations
+from C++11 as faithfully as possible, there are a few
+limitations that cannot be lifted without compiler support:
+
+* [*Using non-POD-classes as template parameter to `atomic<T>` results
+ in undefined behavior]: This means that any class containing a
+ constructor, destructor, virtual methods or access control
+ specifications is not a valid argument in C++98. C++11 relaxes
+ this slightly by allowing "trivial" classes containing only
+ empty constructors. [*Advise]: Use only POD types.
+* [*C++98 compilers may transform computation- to control-dependency]:
+ Crucially, `memory_order_consume` only affects computationally-dependent
+ operations, but in general there is nothing preventing a compiler
+ from transforming a computation dependency into a control dependency.
+ A C++11 compiler would be forbidden from such a transformation.
+ [*Advise]: Use `memory_order_consume` only in conjunction with
+ pointer values, as the compiler cannot speculate and transform
+ these into control dependencies.
+* [*Fence operations enforce "too strong" compiler ordering]:
+ Semantically, `memory_order_acquire`/`memory_order_consume`
+ and `memory_order_release` need to restrain reordering of
+ memory operations only in one direction. Since there is no
+ way to express this constraint to the compiler, these act
+ as "full compiler barriers" in this implementation. In corner
+ cases this may result in a less efficient code than a C++11 compiler
+ could generate.
+* [*No interprocess fallback]: using `atomic<T>` in shared memory only works
+ correctly, if `atomic<T>::is_lock_free() == true`.
+
+[endsect]
+
+[section:porting Porting]
+
+[section:unit_tests Unit tests]
+
+[*Boost.Atomic] provides a unit test suite to verify that the
+implementation behaves as expected:
+
+* [*fallback_api.cpp] verifies that the fallback-to-locking aspect
+ of [*Boost.Atomic] compiles and has correct value semantics.
+* [*native_api.cpp] verifies that all atomic operations have correct
+ value semantics (e.g. "fetch_add" really adds the desired value,
+ returning the previous). It is a rough "smoke-test" to help weed
+ out the most obvious mistakes (for example width overflow,
+ signed/unsigned extension, ...).
+* [*lockfree.cpp] verifies that the [*BOOST_ATOMIC_*_LOCKFREE] macros
+ are set properly according to the expectations for a given
+ platform, and that they match up with the [*is_lock_free] member
+ functions of the [*atomic] object instances.
+* [*atomicity.cpp] lets two threads race against each other modifying
+ a shared variable, verifying that the operations behave atomic
+ as appropriate. By nature, this test is necessarily stochastic, and
+ the test self-calibrates to yield 99% confidence that a
+ positive result indicates absence of an error. This test is
+ very useful on uni-processor systems with preemption already.
+* [*ordering.cpp] lets two threads race against each other accessing
+ multiple shared variables, verifying that the operations
+ exhibit the expected ordering behavior. By nature, this test is
+ necessarily stochastic, and the test attempts to self-calibrate to
+ yield 99% confidence that a positive result indicates absence
+ of an error. This only works on true multi-processor (or multi-core)
+ systems. It does not yield any result on uni-processor systems
+ or emulators (due to there being no observable reordering even
+ the order=relaxed case) and will report that fact.
+
+[endsect]
+
+[section:tested_compilers Tested compilers]
+
+[*Boost.Atomic] has been tested on and is known to work on
+the following compilers/platforms:
+
+* gcc 4.x: i386, x86_64, ppc32, ppc64, sparcv9, armv6, alpha
+* Visual Studio Express 2008/Windows XP, x86, x64, ARM
+
+[endsect]
+
+[section:acknowledgements Acknowledgements]
+
+* Adam Wulkiewicz created the logo used on the [@https://github.com/boostorg/atomic GitHub project page]. The logo was taken from his [@https://github.com/awulkiew/boost-logos collection] of Boost logos.
+
+[endsect]
+
+[endsect]
diff --git a/3rdParty/Boost/src/libs/atomic/doc/examples.qbk b/3rdParty/Boost/src/libs/atomic/doc/examples.qbk
new file mode 100644
index 0000000..e34c402
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/doc/examples.qbk
@@ -0,0 +1,398 @@
+[/
+ / Copyright (c) 2009 Helge Bahmann
+ /
+ / 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)
+ /]
+
+[section:example_reference_counters Reference counting]
+
+The purpose of a ['reference counter] is to count the number
+of pointers to an object. The object can be destroyed as
+soon as the reference counter reaches zero.
+
+[section Implementation]
+
+[c++]
+
+ #include <boost/intrusive_ptr.hpp>
+ #include <boost/atomic.hpp>
+
+ class X {
+ public:
+ typedef boost::intrusive_ptr<X> pointer;
+ X() : refcount_(0) {}
+
+ private:
+ mutable boost::atomic<int> refcount_;
+ friend void intrusive_ptr_add_ref(const X * x)
+ {
+ x->refcount_.fetch_add(1, boost::memory_order_relaxed);
+ }
+ friend void intrusive_ptr_release(const X * x)
+ {
+ if (x->refcount_.fetch_sub(1, boost::memory_order_release) == 1) {
+ boost::atomic_thread_fence(boost::memory_order_acquire);
+ delete x;
+ }
+ }
+ };
+
+[endsect]
+
+[section Usage]
+
+[c++]
+
+ X::pointer x = new X;
+
+[endsect]
+
+[section Discussion]
+
+Increasing the reference counter can always be done with
+[^memory_order_relaxed]: New references to an object can only
+be formed from an existing reference, and passing an existing
+reference from one thread to another must already provide any
+required synchronization.
+
+It is important to enforce any possible access to the object in
+one thread (through an existing reference) to ['happen before]
+deleting the object in a different thread. This is achieved
+by a "release" operation after dropping a reference (any
+access to the object through this reference must obviously
+happened before), and an "acquire" operation before
+deleting the object.
+
+It would be possible to use [^memory_order_acq_rel] for the
+[^fetch_sub] operation, but this results in unneeded "acquire"
+operations when the reference counter does not yet reach zero
+and may impose a performance penalty.
+
+[endsect]
+
+[endsect]
+
+[section:example_spinlock Spinlock]
+
+The purpose of a ['spin lock] is to prevent multiple threads
+from concurrently accessing a shared data structure. In contrast
+to a mutex, threads will busy-wait and waste CPU cycles instead
+of yielding the CPU to another thread. ['Do not use spinlocks
+unless you are certain that you understand the consequences.]
+
+[section Implementation]
+
+[c++]
+
+ #include <boost/atomic.hpp>
+
+ class spinlock {
+ private:
+ typedef enum {Locked, Unlocked} LockState;
+ boost::atomic<LockState> state_;
+
+ public:
+ spinlock() : state_(Unlocked) {}
+
+ void lock()
+ {
+ while (state_.exchange(Locked, boost::memory_order_acquire) == Locked) {
+ /* busy-wait */
+ }
+ }
+ void unlock()
+ {
+ state_.store(Unlocked, boost::memory_order_release);
+ }
+ };
+
+[endsect]
+
+[section Usage]
+
+[c++]
+
+ spinlock s;
+
+ s.lock();
+ // access data structure here
+ s.unlock();
+
+[endsect]
+
+[section Discussion]
+
+The purpose of the spinlock is to make sure that one access
+to the shared data structure always strictly "happens before"
+another. The usage of acquire/release in lock/unlock is required
+and sufficient to guarantee this ordering.
+
+It would be correct to write the "lock" operation in the following
+way:
+
+[c++]
+
+ lock()
+ {
+ while (state_.exchange(Locked, boost::memory_order_relaxed) == Locked) {
+ /* busy-wait */
+ }
+ atomic_thread_fence(boost::memory_order_acquire);
+ }
+
+This "optimization" is however a) useless and b) may in fact hurt:
+a) Since the thread will be busily spinning on a blocked spinlock,
+it does not matter if it will waste the CPU cycles with just
+"exchange" operations or with both useless "exchange" and "acquire"
+operations. b) A tight "exchange" loop without any
+memory-synchronizing instruction introduced through an "acquire"
+operation will on some systems monopolize the memory subsystem
+and degrade the performance of other system components.
+
+[endsect]
+
+[endsect]
+
+[section:singleton Singleton with double-checked locking pattern]
+
+The purpose of the ['Singleton with double-checked locking pattern] is to ensure
+that at most one instance of a particular object is created.
+If one instance has been created already, access to the existing
+object should be as light-weight as possible.
+
+[section Implementation]
+
+[c++]
+
+ #include <boost/atomic.hpp>
+ #include <boost/thread/mutex.hpp>
+
+ class X {
+ public:
+ static X * instance()
+ {
+ X * tmp = instance_.load(boost::memory_order_consume);
+ if (!tmp) {
+ boost::mutex::scoped_lock guard(instantiation_mutex);
+ tmp = instance_.load(boost::memory_order_consume);
+ if (!tmp) {
+ tmp = new X;
+ instance_.store(tmp, boost::memory_order_release);
+ }
+ }
+ return tmp;
+ }
+ private:
+ static boost::atomic<X *> instance_;
+ static boost::mutex instantiation_mutex;
+ };
+
+ boost::atomic<X *> X::instance_(0);
+
+[endsect]
+
+[section Usage]
+
+[c++]
+
+ X * x = X::instance();
+ // dereference x
+
+[endsect]
+
+[section Discussion]
+
+The mutex makes sure that only one instance of the object is
+ever created. The [^instance] method must make sure that any
+dereference of the object strictly "happens after" creating
+the instance in another thread. The use of [^memory_order_release]
+after creating and initializing the object and [^memory_order_consume]
+before dereferencing the object provides this guarantee.
+
+It would be permissible to use [^memory_order_acquire] instead of
+[^memory_order_consume], but this provides a stronger guarantee
+than is required since only operations depending on the value of
+the pointer need to be ordered.
+
+[endsect]
+
+[endsect]
+
+[section:example_ringbuffer Wait-free ring buffer]
+
+A ['wait-free ring buffer] provides a mechanism for relaying objects
+from one single "producer" thread to one single "consumer" thread without
+any locks. The operations on this data structure are "wait-free" which
+means that each operation finishes within a constant number of steps.
+This makes this data structure suitable for use in hard real-time systems
+or for communication with interrupt/signal handlers.
+
+[section Implementation]
+
+[c++]
+
+ #include <boost/atomic.hpp>
+
+ template<typename T, size_t Size>
+ class ringbuffer {
+ public:
+ ringbuffer() : head_(0), tail_(0) {}
+
+ bool push(const T & value)
+ {
+ size_t head = head_.load(boost::memory_order_relaxed);
+ size_t next_head = next(head);
+ if (next_head == tail_.load(boost::memory_order_acquire))
+ return false;
+ ring_[head] = value;
+ head_.store(next_head, boost::memory_order_release);
+ return true;
+ }
+ bool pop(T & value)
+ {
+ size_t tail = tail_.load(boost::memory_order_relaxed);
+ if (tail == head_.load(boost::memory_order_acquire))
+ return false;
+ value = ring_[tail];
+ tail_.store(next(tail), boost::memory_order_release);
+ return true;
+ }
+ private:
+ size_t next(size_t current)
+ {
+ return (current + 1) % Size;
+ }
+ T ring_[Size];
+ boost::atomic<size_t> head_, tail_;
+ };
+
+[endsect]
+
+[section Usage]
+
+[c++]
+
+ ringbuffer<int, 32> r;
+
+ // try to insert an element
+ if (r.push(42)) { /* succeeded */ }
+ else { /* buffer full */ }
+
+ // try to retrieve an element
+ int value;
+ if (r.pop(value)) { /* succeeded */ }
+ else { /* buffer empty */ }
+
+[endsect]
+
+[section Discussion]
+
+The implementation makes sure that the ring indices do
+not "lap-around" each other to ensure that no elements
+are either lost or read twice.
+
+Furthermore it must guarantee that read-access to a
+particular object in [^pop] "happens after" it has been
+written in [^push]. This is achieved by writing [^head_ ]
+with "release" and reading it with "acquire". Conversely
+the implementation also ensures that read access to
+a particular ring element "happens before" before
+rewriting this element with a new value by accessing [^tail_]
+with appropriate ordering constraints.
+
+[endsect]
+
+[endsect]
+
+[section:mp_queue Wait-free multi-producer queue]
+
+The purpose of the ['wait-free multi-producer queue] is to allow
+an arbitrary number of producers to enqueue objects which are
+retrieved and processed in FIFO order by a single consumer.
+
+[section Implementation]
+
+[c++]
+
+ template<typename T>
+ class waitfree_queue {
+ public:
+ struct node {
+ T data;
+ node * next;
+ };
+ void push(const T &data)
+ {
+ node * n = new node;
+ n->data = data;
+ node * stale_head = head_.load(boost::memory_order_relaxed);
+ do {
+ n->next = stale_head;
+ } while (!head_.compare_exchange_weak(stale_head, n, boost::memory_order_release));
+ }
+
+ node * pop_all(void)
+ {
+ T * last = pop_all_reverse(), * first = 0;
+ while(last) {
+ T * tmp = last;
+ last = last->next;
+ tmp->next = first;
+ first = tmp;
+ }
+ return first;
+ }
+
+ waitfree_queue() : head_(0) {}
+
+ // alternative interface if ordering is of no importance
+ node * pop_all_reverse(void)
+ {
+ return head_.exchange(0, boost::memory_order_consume);
+ }
+ private:
+ boost::atomic<node *> head_;
+ };
+
+[endsect]
+
+[section Usage]
+
+[c++]
+
+ waitfree_queue<int> q;
+
+ // insert elements
+ q.push(42);
+ q.push(2);
+
+ // pop elements
+ waitfree_queue<int>::node * x = q.pop_all()
+ while(x) {
+ X * tmp = x;
+ x = x->next;
+ // process tmp->data, probably delete it afterwards
+ delete tmp;
+ }
+
+[endsect]
+
+[section Discussion]
+
+The implementation guarantees that all objects enqueued are
+processed in the order they were enqueued by building a singly-linked
+list of object in reverse processing order. The queue is atomically
+emptied by the consumer and brought into correct order.
+
+It must be guaranteed that any access to an object to be enqueued
+by the producer "happens before" any access by the consumer. This
+is assured by inserting objects into the list with ['release] and
+dequeuing them with ['consume] memory order. It is not
+necessary to use ['acquire] memory order in [^waitfree_queue::pop_all]
+because all operations involved depend on the value of
+the atomic pointer through dereference
+
+[endsect]
+
+[endsect]
diff --git a/3rdParty/Boost/src/libs/atomic/doc/logo.png b/3rdParty/Boost/src/libs/atomic/doc/logo.png
new file mode 100644
index 0000000..8b12104
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/doc/logo.png
Binary files differ
diff --git a/3rdParty/Boost/src/libs/atomic/doc/logo.svg b/3rdParty/Boost/src/libs/atomic/doc/logo.svg
new file mode 100644
index 0000000..50d078e
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/doc/logo.svg
@@ -0,0 +1,1053 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:xlink="http://www.w3.org/1999/xlink"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="744.09448819"
+ height="1052.3622047"
+ id="svg7933"
+ version="1.1"
+ inkscape:version="0.48.4 r9939"
+ sodipodi:docname="atomic.svg">
+ <defs
+ id="defs7935">
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4453-7-8-6-7-87"
+ id="linearGradient10687-9"
+ gradientUnits="userSpaceOnUse"
+ x1="753.02301"
+ y1="3132.0801"
+ x2="1146.25"
+ y2="3132.0801" />
+ <linearGradient
+ id="linearGradient4453-7-8-6-7-87">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop4455-61-8-7-1-8" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop4457-4-1-9-1-4" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4453-7-8-6-7-87"
+ id="linearGradient10685-44"
+ gradientUnits="userSpaceOnUse"
+ x1="753.02301"
+ y1="3132.0801"
+ x2="1146.25"
+ y2="3132.0801" />
+ <linearGradient
+ id="linearGradient7822">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop7824" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop7826" />
+ </linearGradient>
+ <clipPath
+ clipPathUnits="userSpaceOnUse"
+ id="clipPath3387-3-6-4-2-3">
+ <path
+ inkscape:connector-curvature="0"
+ d="m 862.109,3289.75 -109.086,-190.45 69.122,-124.42 164.511,-0.47 c 0,0 111.044,188.28 116.564,197.63 7.66,0 43.03,0 43.03,0 l -67.03,117.71 -217.111,0 z"
+ id="path3389-2-0-7-7-58" />
+ </clipPath>
+ <linearGradient
+ y2="3132.0801"
+ x2="1146.25"
+ y1="3132.0801"
+ x1="753.02301"
+ gradientUnits="userSpaceOnUse"
+ id="linearGradient4492-0"
+ xlink:href="#linearGradient4453-7-8-6-7-87"
+ inkscape:collect="always" />
+ <linearGradient
+ id="linearGradient7831">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop7833" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop7835" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4453-7-8-6-7-87"
+ id="linearGradient10691-2"
+ gradientUnits="userSpaceOnUse"
+ x1="1026.6899"
+ y1="2937.73"
+ x2="1463.14"
+ y2="2937.73" />
+ <linearGradient
+ id="linearGradient7838">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop7840" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop7842" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4453-7-8-6-7-87"
+ id="linearGradient10689-9"
+ gradientUnits="userSpaceOnUse"
+ x1="1026.6899"
+ y1="2937.73"
+ x2="1463.14"
+ y2="2937.73" />
+ <linearGradient
+ id="linearGradient7845">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop7847" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop7849" />
+ </linearGradient>
+ <clipPath
+ clipPathUnits="userSpaceOnUse"
+ id="clipPath3369-1-5-6-1-49">
+ <path
+ inkscape:connector-curvature="0"
+ d="m 1131.64,3128.5 -104.95,-181.12 116.38,-200.42 208.05,0.94 112.02,191.63 -112.08,188.97 -219.42,0 z"
+ id="path3371-89-4-1-6-8" />
+ </clipPath>
+ <linearGradient
+ y2="2937.73"
+ x2="1463.14"
+ y1="2937.73"
+ x1="1026.6899"
+ gradientUnits="userSpaceOnUse"
+ id="linearGradient4498-3"
+ xlink:href="#linearGradient4453-7-8-6-7-87"
+ inkscape:collect="always" />
+ <linearGradient
+ id="linearGradient7854">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop7856" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop7858" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4459-1-2-8-9-0"
+ id="linearGradient10695-5"
+ gradientUnits="userSpaceOnUse"
+ x1="646.55499"
+ y1="2736.25"
+ x2="1088.27"
+ y2="2736.25" />
+ <linearGradient
+ id="linearGradient4459-1-2-8-9-0">
+ <stop
+ id="stop4461-2-1-5-2-43"
+ offset="0"
+ style="stop-color:#839bc2;stop-opacity:1;" />
+ <stop
+ id="stop4463-3-2-8-7-5"
+ offset="1"
+ style="stop-color:#9fb6d4;stop-opacity:1;" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4459-1-2-8-9-0"
+ id="linearGradient10693-2"
+ gradientUnits="userSpaceOnUse"
+ x1="646.55499"
+ y1="2736.25"
+ x2="1088.27"
+ y2="2736.25" />
+ <linearGradient
+ id="linearGradient7865">
+ <stop
+ id="stop7867"
+ offset="0"
+ style="stop-color:#839bc2;stop-opacity:1;" />
+ <stop
+ id="stop7869"
+ offset="1"
+ style="stop-color:#9fb6d4;stop-opacity:1;" />
+ </linearGradient>
+ <clipPath
+ clipPathUnits="userSpaceOnUse"
+ id="clipPath3351-4-7-3-5-57">
+ <path
+ inkscape:connector-curvature="0"
+ d="m 757.242,2926.25 -110.687,-189.11 110.656,-190.89 219.437,0 111.622,189.1 -111.59,190.9 -219.438,0 z"
+ id="path3353-1-9-3-4-77" />
+ </clipPath>
+ <linearGradient
+ y2="2736.25"
+ x2="1088.27"
+ y1="2736.25"
+ x1="646.55499"
+ gradientUnits="userSpaceOnUse"
+ id="linearGradient4510-4"
+ xlink:href="#linearGradient4459-1-2-8-9-0"
+ inkscape:collect="always" />
+ <linearGradient
+ id="linearGradient7874">
+ <stop
+ id="stop7876"
+ offset="0"
+ style="stop-color:#839bc2;stop-opacity:1;" />
+ <stop
+ id="stop7878"
+ offset="1"
+ style="stop-color:#9fb6d4;stop-opacity:1;" />
+ </linearGradient>
+ <radialGradient
+ inkscape:collect="always"
+ xlink:href="#radialGradient3327-8-4-8-0-0"
+ id="radialGradient10699-4"
+ gradientUnits="userSpaceOnUse"
+ cx="997.46997"
+ cy="2896.25"
+ fx="997.46997"
+ fy="2896.25"
+ r="583.73999" />
+ <radialGradient
+ fx="0"
+ fy="0"
+ cx="0"
+ cy="0"
+ r="1"
+ gradientUnits="userSpaceOnUse"
+ gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
+ spreadMethod="pad"
+ id="radialGradient3327-8-4-8-0-0">
+ <stop
+ style="stop-opacity:1;stop-color:#aeaeb3"
+ offset="0"
+ id="stop3329-7-0-1-0-4" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="0.949438"
+ id="stop3331-4-3-0-0-11" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="1"
+ id="stop3333-2-4-9-7-54" />
+ </radialGradient>
+ <radialGradient
+ r="583.73999"
+ fy="2896.25"
+ fx="997.46997"
+ cy="2896.25"
+ cx="997.46997"
+ gradientUnits="userSpaceOnUse"
+ id="radialGradient15837"
+ xlink:href="#radialGradient3327-8-4-8-0-0"
+ inkscape:collect="always" />
+ <radialGradient
+ fx="0"
+ fy="0"
+ cx="0"
+ cy="0"
+ r="1"
+ gradientUnits="userSpaceOnUse"
+ gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
+ spreadMethod="pad"
+ id="radialGradient7886">
+ <stop
+ style="stop-opacity:1;stop-color:#aeaeb3"
+ offset="0"
+ id="stop7888" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="0.949438"
+ id="stop7890" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="1"
+ id="stop7892" />
+ </radialGradient>
+ <clipPath
+ clipPathUnits="userSpaceOnUse"
+ id="clipPath3323-7-2-4-5-2">
+ <path
+ inkscape:connector-curvature="0"
+ d="m 997.469,2312.51 c -322.379,0 -583.739,261.36 -583.739,583.74 0,322.38 261.36,583.74 583.739,583.74 322.381,0 583.741,-261.36 583.741,-583.74 0,-322.38 -261.36,-583.74 -583.741,-583.74"
+ id="path3325-9-2-9-5-8" />
+ </clipPath>
+ <radialGradient
+ r="583.73999"
+ fy="2896.25"
+ fx="997.46997"
+ cy="2896.25"
+ cx="997.46997"
+ gradientUnits="userSpaceOnUse"
+ id="radialGradient4516-6"
+ xlink:href="#radialGradient3327-8-4-8-0-0"
+ inkscape:collect="always" />
+ <radialGradient
+ fx="0"
+ fy="0"
+ cx="0"
+ cy="0"
+ r="1"
+ gradientUnits="userSpaceOnUse"
+ gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
+ spreadMethod="pad"
+ id="radialGradient7897">
+ <stop
+ style="stop-opacity:1;stop-color:#aeaeb3"
+ offset="0"
+ id="stop7899" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="0.949438"
+ id="stop7901" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="1"
+ id="stop7903" />
+ </radialGradient>
+ <radialGradient
+ r="583.73999"
+ fy="2896.25"
+ fx="997.46997"
+ cy="2896.25"
+ cx="997.46997"
+ gradientUnits="userSpaceOnUse"
+ id="radialGradient7931"
+ xlink:href="#radialGradient3327-8-4-8-0-0"
+ inkscape:collect="always" />
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4453-7-8-6-7-87-7"
+ id="linearGradient10687-9-1"
+ gradientUnits="userSpaceOnUse"
+ x1="753.02301"
+ y1="3132.0801"
+ x2="1146.25"
+ y2="3132.0801" />
+ <linearGradient
+ id="linearGradient4453-7-8-6-7-87-7">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop4455-61-8-7-1-8-4" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop4457-4-1-9-1-4-0" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4453-7-8-6-7-87-7"
+ id="linearGradient10685-44-9"
+ gradientUnits="userSpaceOnUse"
+ x1="753.02301"
+ y1="3132.0801"
+ x2="1146.25"
+ y2="3132.0801" />
+ <linearGradient
+ id="linearGradient3083">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop3085" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop3087" />
+ </linearGradient>
+ <clipPath
+ clipPathUnits="userSpaceOnUse"
+ id="clipPath3387-3-6-4-2-3-4">
+ <path
+ inkscape:connector-curvature="0"
+ d="m 862.109,3289.75 -109.086,-190.45 69.122,-124.42 164.511,-0.47 c 0,0 111.044,188.28 116.564,197.63 7.66,0 43.03,0 43.03,0 l -67.03,117.71 -217.111,0 z"
+ id="path3389-2-0-7-7-58-8" />
+ </clipPath>
+ <linearGradient
+ y2="3132.0801"
+ x2="1146.25"
+ y1="3132.0801"
+ x1="753.02301"
+ gradientUnits="userSpaceOnUse"
+ id="linearGradient4492-0-8"
+ xlink:href="#linearGradient4453-7-8-6-7-87-7"
+ inkscape:collect="always" />
+ <linearGradient
+ id="linearGradient3092">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop3094" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop3096" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4453-7-8-6-7-87-7"
+ id="linearGradient10691-2-2"
+ gradientUnits="userSpaceOnUse"
+ x1="1026.6899"
+ y1="2937.73"
+ x2="1463.14"
+ y2="2937.73" />
+ <linearGradient
+ id="linearGradient3099">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop3101" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop3103" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4453-7-8-6-7-87-7"
+ id="linearGradient10689-9-4"
+ gradientUnits="userSpaceOnUse"
+ x1="1026.6899"
+ y1="2937.73"
+ x2="1463.14"
+ y2="2937.73" />
+ <linearGradient
+ id="linearGradient3106">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop3108" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop3110" />
+ </linearGradient>
+ <clipPath
+ clipPathUnits="userSpaceOnUse"
+ id="clipPath3369-1-5-6-1-49-5">
+ <path
+ inkscape:connector-curvature="0"
+ d="m 1131.64,3128.5 -104.95,-181.12 116.38,-200.42 208.05,0.94 112.02,191.63 -112.08,188.97 -219.42,0 z"
+ id="path3371-89-4-1-6-8-5" />
+ </clipPath>
+ <linearGradient
+ y2="2937.73"
+ x2="1463.14"
+ y1="2937.73"
+ x1="1026.6899"
+ gradientUnits="userSpaceOnUse"
+ id="linearGradient4498-3-1"
+ xlink:href="#linearGradient4453-7-8-6-7-87-7"
+ inkscape:collect="always" />
+ <linearGradient
+ id="linearGradient3115">
+ <stop
+ style="stop-color:#aac4dd;stop-opacity:1;"
+ offset="0"
+ id="stop3117" />
+ <stop
+ style="stop-color:#c2dbe9;stop-opacity:1;"
+ offset="1"
+ id="stop3119" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4459-1-2-8-9-0-1"
+ id="linearGradient10695-5-7"
+ gradientUnits="userSpaceOnUse"
+ x1="646.55499"
+ y1="2736.25"
+ x2="1088.27"
+ y2="2736.25" />
+ <linearGradient
+ id="linearGradient4459-1-2-8-9-0-1">
+ <stop
+ id="stop4461-2-1-5-2-43-1"
+ offset="0"
+ style="stop-color:#839bc2;stop-opacity:1;" />
+ <stop
+ id="stop4463-3-2-8-7-5-5"
+ offset="1"
+ style="stop-color:#9fb6d4;stop-opacity:1;" />
+ </linearGradient>
+ <linearGradient
+ inkscape:collect="always"
+ xlink:href="#linearGradient4459-1-2-8-9-0-1"
+ id="linearGradient10693-2-2"
+ gradientUnits="userSpaceOnUse"
+ x1="646.55499"
+ y1="2736.25"
+ x2="1088.27"
+ y2="2736.25" />
+ <linearGradient
+ id="linearGradient3126">
+ <stop
+ id="stop3128"
+ offset="0"
+ style="stop-color:#839bc2;stop-opacity:1;" />
+ <stop
+ id="stop3130"
+ offset="1"
+ style="stop-color:#9fb6d4;stop-opacity:1;" />
+ </linearGradient>
+ <clipPath
+ clipPathUnits="userSpaceOnUse"
+ id="clipPath3351-4-7-3-5-57-7">
+ <path
+ inkscape:connector-curvature="0"
+ d="m 757.242,2926.25 -110.687,-189.11 110.656,-190.89 219.437,0 111.622,189.1 -111.59,190.9 -219.438,0 z"
+ id="path3353-1-9-3-4-77-6" />
+ </clipPath>
+ <linearGradient
+ y2="2736.25"
+ x2="1088.27"
+ y1="2736.25"
+ x1="646.55499"
+ gradientUnits="userSpaceOnUse"
+ id="linearGradient4510-4-1"
+ xlink:href="#linearGradient4459-1-2-8-9-0-1"
+ inkscape:collect="always" />
+ <linearGradient
+ id="linearGradient3135">
+ <stop
+ id="stop3137"
+ offset="0"
+ style="stop-color:#839bc2;stop-opacity:1;" />
+ <stop
+ id="stop3139"
+ offset="1"
+ style="stop-color:#9fb6d4;stop-opacity:1;" />
+ </linearGradient>
+ <radialGradient
+ inkscape:collect="always"
+ xlink:href="#radialGradient3327-8-4-8-0-0-2"
+ id="radialGradient10699-4-4"
+ gradientUnits="userSpaceOnUse"
+ cx="997.46997"
+ cy="2896.25"
+ fx="997.46997"
+ fy="2896.25"
+ r="583.73999" />
+ <radialGradient
+ fx="0"
+ fy="0"
+ cx="0"
+ cy="0"
+ r="1"
+ gradientUnits="userSpaceOnUse"
+ gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
+ spreadMethod="pad"
+ id="radialGradient3327-8-4-8-0-0-2">
+ <stop
+ style="stop-opacity:1;stop-color:#aeaeb3"
+ offset="0"
+ id="stop3329-7-0-1-0-4-3" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="0.949438"
+ id="stop3331-4-3-0-0-11-2" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="1"
+ id="stop3333-2-4-9-7-54-2" />
+ </radialGradient>
+ <radialGradient
+ r="583.73999"
+ fy="2896.25"
+ fx="997.46997"
+ cy="2896.25"
+ cx="997.46997"
+ gradientUnits="userSpaceOnUse"
+ id="radialGradient7931-1"
+ xlink:href="#radialGradient3327-8-4-8-0-0-2"
+ inkscape:collect="always" />
+ <radialGradient
+ fx="0"
+ fy="0"
+ cx="0"
+ cy="0"
+ r="1"
+ gradientUnits="userSpaceOnUse"
+ gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
+ spreadMethod="pad"
+ id="radialGradient3147">
+ <stop
+ style="stop-opacity:1;stop-color:#aeaeb3"
+ offset="0"
+ id="stop3149" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="0.949438"
+ id="stop3151" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="1"
+ id="stop3153" />
+ </radialGradient>
+ <clipPath
+ clipPathUnits="userSpaceOnUse"
+ id="clipPath3323-7-2-4-5-2-6">
+ <path
+ inkscape:connector-curvature="0"
+ d="m 997.469,2312.51 c -322.379,0 -583.739,261.36 -583.739,583.74 0,322.38 261.36,583.74 583.739,583.74 322.381,0 583.741,-261.36 583.741,-583.74 0,-322.38 -261.36,-583.74 -583.741,-583.74"
+ id="path3325-9-2-9-5-8-8" />
+ </clipPath>
+ <radialGradient
+ r="583.73999"
+ fy="2896.25"
+ fx="997.46997"
+ cy="2896.25"
+ cx="997.46997"
+ gradientUnits="userSpaceOnUse"
+ id="radialGradient4516-6-5"
+ xlink:href="#radialGradient3327-8-4-8-0-0-2"
+ inkscape:collect="always" />
+ <radialGradient
+ fx="0"
+ fy="0"
+ cx="0"
+ cy="0"
+ r="1"
+ gradientUnits="userSpaceOnUse"
+ gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
+ spreadMethod="pad"
+ id="radialGradient3158">
+ <stop
+ style="stop-opacity:1;stop-color:#aeaeb3"
+ offset="0"
+ id="stop3160" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="0.949438"
+ id="stop3162" />
+ <stop
+ style="stop-opacity:1;stop-color:#ffffff"
+ offset="1"
+ id="stop3164" />
+ </radialGradient>
+ <radialGradient
+ r="583.73999"
+ fy="2896.25"
+ fx="997.46997"
+ cy="2896.25"
+ cx="997.46997"
+ gradientUnits="userSpaceOnUse"
+ id="radialGradient3192"
+ xlink:href="#radialGradient3327-8-4-8-0-0-2"
+ inkscape:collect="always" />
+ </defs>
+ <sodipodi:namedview
+ id="base"
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1.0"
+ inkscape:pageopacity="0.0"
+ inkscape:pageshadow="2"
+ inkscape:zoom="0.98994949"
+ inkscape:cx="194.37763"
+ inkscape:cy="577.68232"
+ inkscape:document-units="px"
+ inkscape:current-layer="layer1"
+ showgrid="false"
+ inkscape:window-width="1680"
+ inkscape:window-height="982"
+ inkscape:window-x="-8"
+ inkscape:window-y="-8"
+ inkscape:window-maximized="1" />
+ <metadata
+ id="metadata7938">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title />
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <g
+ inkscape:label="Layer 1"
+ inkscape:groupmode="layer"
+ id="layer1">
+ <g
+ id="g3319-1-2-5-1-8"
+ transform="matrix(0.10419818,0,0,-0.10419818,149.49392,819.86044)"
+ style="fill:url(#radialGradient10699-4);fill-opacity:1"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <g
+ clip-path="url(#clipPath3323-7-2-4-5-2)"
+ id="g3321-9-2-7-4-14"
+ style="fill:url(#radialGradient7931);fill-opacity:1">
+ <path
+ id="path3335-8-7-3-8-7"
+ style="fill:url(#radialGradient4516-6);fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 997.469,2312.51 c -322.379,0 -583.739,261.36 -583.739,583.74 0,322.38 261.36,583.74 583.739,583.74 322.381,0 583.741,-261.36 583.741,-583.74 0,-322.38 -261.36,-583.74 -583.741,-583.74"
+ inkscape:connector-curvature="0" />
+ </g>
+ </g>
+ <g
+ id="g3347-6-8-3-7-64"
+ transform="matrix(0.125,0,0,-0.125,124.46742,882.67914)"
+ style="fill:url(#linearGradient10695-5);fill-opacity:1"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <g
+ clip-path="url(#clipPath3351-4-7-3-5-57)"
+ id="g3349-5-5-4-7-98"
+ style="fill:url(#linearGradient10693-2);fill-opacity:1">
+ <path
+ id="path3361-0-8-2-9-7"
+ style="fill:url(#linearGradient4510-4);fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 757.242,2926.25 -110.687,-189.11 110.656,-190.89 219.437,0 111.622,189.1 -111.59,190.9 -219.438,0"
+ inkscape:connector-curvature="0" />
+ </g>
+ </g>
+ <path
+ id="path3363-6-9-0-1-3"
+ style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 206.73253,540.54045 13.106,-22.3925 25.99649,0 13.21487,22.6087 -13.21487,22.39129 -25.99649,0 -13.106,-22.60749 z m 40.53761,-24.8925 -28.86524,0 -0.72412,1.2375 -13.106,22.3925 -0.73575,1.2563 0.73087,1.26 13.106,22.60739 0.72263,1.2464 28.86374,0 0.72512,-1.2289 13.215,-22.39119 0.74625,-1.265 -0.74,-1.2675 -13.21537,-22.6088 -0.72313,-1.2387"
+ inkscape:connector-curvature="0"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523" />
+ <g
+ id="g3365-0-4-1-9-8"
+ transform="matrix(0.125,0,0,-0.125,124.46742,882.67914)"
+ style="fill:url(#linearGradient10691-2);fill-opacity:1"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <g
+ clip-path="url(#clipPath3369-1-5-6-1-49)"
+ id="g3367-2-4-2-8-6"
+ style="fill:url(#linearGradient10689-9);fill-opacity:1">
+ <path
+ id="path3379-4-6-7-6-2"
+ style="fill:url(#linearGradient4498-3);fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 1131.64,3128.5 -104.95,-181.12 116.38,-200.42 208.05,0.94 112.02,191.63 -112.08,188.97 -219.42,0"
+ inkscape:connector-curvature="0" />
+ </g>
+ </g>
+ <path
+ id="path3381-6-8-0-0-8"
+ style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 254.24864,514.25665 12.3925,-21.3899 25.99625,0 13.27125,22.3762 -13.27125,22.7025 -24.56875,0.11 -13.82,-23.7988 z m 39.8125,-23.8899 -28.86125,0 -0.7225,1.2462 -12.3925,21.39 -0.72625,1.255 0.7275,1.2537 13.82,23.7988 0.7275,1.2513 1.44625,-0.01 24.56875,-0.11 1.4275,-0.01 0.72,-1.2325 13.27125,-22.7025 0.7425,-1.27 -0.75125,-1.2663 -13.27125,-22.3762 -0.72625,-1.225"
+ inkscape:connector-curvature="0"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523" />
+ <g
+ id="g3383-5-5-2-2-0"
+ transform="matrix(0.125,0,0,-0.125,124.46742,882.67914)"
+ style="fill:url(#linearGradient10687-9);fill-opacity:1"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <g
+ clip-path="url(#clipPath3387-3-6-4-2-3)"
+ id="g3385-0-6-4-8-9"
+ style="fill:url(#linearGradient10685-44);fill-opacity:1">
+ <path
+ id="path3397-9-6-1-6-8"
+ style="fill:url(#linearGradient4492-0);fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 862.109,3289.75 -109.086,-190.45 69.122,-124.42 164.511,-0.47 c 0,0 111.044,188.28 116.564,197.63 7.66,0 43.03,0 43.03,0 l -67.03,117.71 -217.111,0"
+ inkscape:connector-curvature="0" />
+ </g>
+ </g>
+ <path
+ id="path3399-6-7-3-2-04"
+ style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 220.0304,495.27665 12.92424,-22.5662 25.68775,0 6.95625,12.2138 -3.94375,0 -14.56837,24.7025 -19.11525,-0.055 -7.94087,-14.295 z m 40.06574,-25.0662 -28.59012,0 -0.71975,1.2575 -12.92537,22.5663 -0.70112,1.2237 0.68512,1.2325 7.94137,14.295 0.71087,1.2825 1.46638,0 19.11525,0.055 1.43212,0 0.729,-1.2338 13.84375,-23.4724 6.81625,0 -2.12875,-3.7375 -6.95625,-12.2138 -0.71875,-1.2625"
+ inkscape:connector-curvature="0"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523" />
+ <g
+ transform="matrix(1.25,0,0,-1.25,117.405,895.69964)"
+ id="g3465-0-9"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <text
+ id="text3467-9-6"
+ transform="matrix(1,0,-0.17627963,-1,0,0)"
+ x="116.98372"
+ y="-267.77499"
+ style="font-size:11.81779194px">
+ <tspan
+ id="tspan3469-0-8"
+ sodipodi:role="line"
+ style="font-size:46.39999771px;font-variant:normal;font-weight:normal;writing-mode:lr-tb;fill:#49608a;fill-opacity:1;fill-rule:nonzero;stroke:none;font-family:Denmark;-inkscape-font-specification:Denmark"
+ x="116.98372"
+ y="-267.77499">ATOMIC</tspan>
+ </text>
+ <text
+ id="text3471-0-2"
+ transform="matrix(0.99235617,0,-0.17763746,-1.0077027,0,0)"
+ style="font-size:38.40000153px"
+ x="112.74373"
+ y="-306.75479">
+ <tspan
+ id="tspan3473-6-8"
+ sodipodi:role="line"
+ style="font-size:38.40000153px;font-variant:normal;font-weight:normal;writing-mode:lr-tb;fill:#49608a;fill-opacity:1;fill-rule:nonzero;stroke:none;font-family:Denmark;-inkscape-font-specification:Denmark"
+ x="112.74373"
+ y="-306.75479">boost</tspan>
+ </text>
+ </g>
+ <path
+ sodipodi:type="arc"
+ style="fill:#0000a7;fill-opacity:1;stroke:#ffffff;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ id="path4821-47"
+ sodipodi:cx="160.35715"
+ sodipodi:cy="240.93361"
+ sodipodi:rx="10.114144"
+ sodipodi:ry="10.114144"
+ d="m 170.47129,240.93361 a 10.114144,10.114144 0 1 1 -20.22829,0 10.114144,10.114144 0 1 1 20.22829,0 z"
+ transform="translate(73.021973,299.26676)" />
+ <path
+ transform="matrix(0.74292732,0,0,0.74292732,160.9833,334.95876)"
+ sodipodi:type="arc"
+ style="fill:#00b000;fill-opacity:1;stroke:#ffffff;stroke-width:2.69205332;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ id="path4821-4-9"
+ sodipodi:cx="160.35715"
+ sodipodi:cy="240.93361"
+ sodipodi:rx="10.114144"
+ sodipodi:ry="10.114144"
+ d="m 170.47129,240.93361 a 10.114144,10.114144 0 1 1 -20.22829,0 10.114144,10.114144 0 1 1 20.22829,0 z" />
+ <path
+ transform="matrix(0.51798873,0,0,0.51798873,159.28596,366.74327)"
+ sodipodi:type="arc"
+ style="fill:#cb0000;fill-opacity:1;stroke:#ffffff;stroke-width:3.8610878;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ id="path4821-4-8-4"
+ sodipodi:cx="160.35715"
+ sodipodi:cy="240.93361"
+ sodipodi:rx="10.114144"
+ sodipodi:ry="10.114144"
+ d="m 170.47129,240.93361 a 10.114144,10.114144 0 1 1 -20.22829,0 10.114144,10.114144 0 1 1 20.22829,0 z" />
+ <path
+ style="fill:none;stroke:#808080;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ d="m 250.05288,487.74985 c 12.11436,-0.8226 21.99257,5.106 28.337,15.9431"
+ id="path16018"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cc" />
+ <path
+ style="fill:none;stroke:#808080;stroke-width:2;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ d="m 279.75705,526.03685 c -5.64547,24.9935 -31.79301,20.1257 -32.06907,20.0828"
+ id="path16020"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cc" />
+ <path
+ style="fill:none;stroke:#808080;stroke-width:1.70000005;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ d="m 233.21476,494.63695 c -16.70632,11.7511 -8.41283,33.4381 -8.77494,33.2356"
+ id="path16022"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cc" />
+ <g
+ id="g3319-1-2-5-1-8-7"
+ transform="matrix(0.10419818,0,0,-0.10419818,147.29097,965.23744)"
+ style="fill:url(#radialGradient10699-4-4);fill-opacity:1"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <g
+ clip-path="url(#clipPath3323-7-2-4-5-2-6)"
+ id="g3321-9-2-7-4-14-6"
+ style="fill:url(#radialGradient3192);fill-opacity:1">
+ <path
+ id="path3335-8-7-3-8-7-1"
+ style="fill:url(#radialGradient4516-6-5);fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 997.469,2312.51 c -322.379,0 -583.739,261.36 -583.739,583.74 0,322.38 261.36,583.74 583.739,583.74 322.381,0 583.741,-261.36 583.741,-583.74 0,-322.38 -261.36,-583.74 -583.741,-583.74"
+ inkscape:connector-curvature="0" />
+ </g>
+ </g>
+ <g
+ id="g3347-6-8-3-7-64-8"
+ transform="matrix(0.125,0,0,-0.125,122.26447,1028.0561)"
+ style="fill:url(#linearGradient10695-5-7);fill-opacity:1"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <g
+ clip-path="url(#clipPath3351-4-7-3-5-57-7)"
+ id="g3349-5-5-4-7-98-9"
+ style="fill:url(#linearGradient10693-2-2);fill-opacity:1">
+ <path
+ id="path3361-0-8-2-9-7-2"
+ style="fill:url(#linearGradient4510-4-1);fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 757.242,2926.25 -110.687,-189.11 110.656,-190.89 219.437,0 111.622,189.1 -111.59,190.9 -219.438,0"
+ inkscape:connector-curvature="0" />
+ </g>
+ </g>
+ <path
+ id="path3363-6-9-0-1-3-7"
+ style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 204.52958,685.91745 13.106,-22.3925 25.99649,0 13.21487,22.6087 -13.21487,22.39129 -25.99649,0 -13.106,-22.60749 z m 40.53761,-24.8925 -28.86524,0 -0.72412,1.2375 -13.106,22.3925 -0.73575,1.2563 0.73087,1.26 13.106,22.60739 0.72263,1.2464 28.86374,0 0.72512,-1.2289 13.215,-22.39119 0.74625,-1.265 -0.74,-1.2675 -13.21537,-22.6088 -0.72313,-1.2387"
+ inkscape:connector-curvature="0"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523" />
+ <g
+ id="g3365-0-4-1-9-8-9"
+ transform="matrix(0.125,0,0,-0.125,122.26447,1028.0561)"
+ style="fill:url(#linearGradient10691-2-2);fill-opacity:1"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <g
+ clip-path="url(#clipPath3369-1-5-6-1-49-5)"
+ id="g3367-2-4-2-8-6-5"
+ style="fill:url(#linearGradient10689-9-4);fill-opacity:1">
+ <path
+ id="path3379-4-6-7-6-2-4"
+ style="fill:url(#linearGradient4498-3-1);fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 1131.64,3128.5 -104.95,-181.12 116.38,-200.42 208.05,0.94 112.02,191.63 -112.08,188.97 -219.42,0"
+ inkscape:connector-curvature="0" />
+ </g>
+ </g>
+ <path
+ id="path3381-6-8-0-0-8-3"
+ style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 252.04569,659.63365 12.3925,-21.3899 25.99625,0 13.27125,22.3762 -13.27125,22.7025 -24.56875,0.11 -13.82,-23.7988 z m 39.8125,-23.8899 -28.86125,0 -0.7225,1.2462 -12.3925,21.39 -0.72625,1.255 0.7275,1.2537 13.82,23.7988 0.7275,1.2513 1.44625,-0.01 24.56875,-0.11 1.4275,-0.01 0.72,-1.2325 13.27125,-22.7025 0.7425,-1.27 -0.75125,-1.2663 -13.27125,-22.3762 -0.72625,-1.225"
+ inkscape:connector-curvature="0"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523" />
+ <g
+ id="g3383-5-5-2-2-0-1"
+ transform="matrix(0.125,0,0,-0.125,122.26447,1028.0561)"
+ style="fill:url(#linearGradient10687-9-1);fill-opacity:1"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <g
+ clip-path="url(#clipPath3387-3-6-4-2-3-4)"
+ id="g3385-0-6-4-8-9-2"
+ style="fill:url(#linearGradient10685-44-9);fill-opacity:1">
+ <path
+ id="path3397-9-6-1-6-8-3"
+ style="fill:url(#linearGradient4492-0-8);fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 862.109,3289.75 -109.086,-190.45 69.122,-124.42 164.511,-0.47 c 0,0 111.044,188.28 116.564,197.63 7.66,0 43.03,0 43.03,0 l -67.03,117.71 -217.111,0"
+ inkscape:connector-curvature="0" />
+ </g>
+ </g>
+ <path
+ id="path3399-6-7-3-2-04-3"
+ style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
+ d="m 217.82745,640.65365 12.92424,-22.5662 25.68775,0 6.95625,12.2138 -3.94375,0 -14.56837,24.7025 -19.11525,-0.055 -7.94087,-14.295 z m 40.06574,-25.0662 -28.59012,0 -0.71975,1.2575 -12.92537,22.5663 -0.70112,1.2237 0.68512,1.2325 7.94137,14.295 0.71087,1.2825 1.46638,0 19.11525,0.055 1.43212,0 0.729,-1.2338 13.84375,-23.4724 6.81625,0 -2.12875,-3.7375 -6.95625,-12.2138 -0.71875,-1.2625"
+ inkscape:connector-curvature="0"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523" />
+ <g
+ transform="matrix(1.25,0,0,-1.25,115.20205,1041.0766)"
+ id="g3465-0-9-4"
+ inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
+ inkscape:export-xdpi="63.625523"
+ inkscape:export-ydpi="63.625523">
+ <text
+ id="text3467-9-6-1"
+ transform="matrix(1,0,-0.17627963,-1,0,0)"
+ x="116.98372"
+ y="-267.77499"
+ style="font-size:11.81779194px">
+ <tspan
+ id="tspan3469-0-8-1"
+ sodipodi:role="line"
+ style="font-size:46.39999771px;font-variant:normal;font-weight:normal;writing-mode:lr-tb;fill:#49608a;fill-opacity:1;fill-rule:nonzero;stroke:none;font-family:Denmark;-inkscape-font-specification:Denmark"
+ x="116.98372"
+ y="-267.77499">Atomic</tspan>
+ </text>
+ <text
+ id="text3471-0-2-3"
+ transform="matrix(0.99235617,0,-0.17763746,-1.0077027,0,0)"
+ style="font-size:38.40000153px"
+ x="112.74373"
+ y="-306.75479">
+ <tspan
+ id="tspan3473-6-8-8"
+ sodipodi:role="line"
+ style="font-size:38.40000153px;font-variant:normal;font-weight:normal;writing-mode:lr-tb;fill:#49608a;fill-opacity:1;fill-rule:nonzero;stroke:none;font-family:Denmark;-inkscape-font-specification:Denmark"
+ x="112.74373"
+ y="-306.75479">Boost</tspan>
+ </text>
+ </g>
+ <path
+ sodipodi:type="arc"
+ style="fill:#ffffff;fill-opacity:1;stroke:#ffffff;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ id="path4821-47-7"
+ sodipodi:cx="160.35715"
+ sodipodi:cy="240.93361"
+ sodipodi:rx="10.114144"
+ sodipodi:ry="10.114144"
+ d="m 170.47129,240.93361 a 10.114144,10.114144 0 1 1 -20.22829,0 10.114144,10.114144 0 1 1 20.22829,0 z"
+ transform="matrix(0.53649776,0,0,0.53649776,136.31572,567.15057)" />
+ <path
+ transform="matrix(0.45553914,0,0,0.45553914,171.71781,574.06648)"
+ sodipodi:type="arc"
+ style="fill:#ffffff;fill-opacity:1;stroke:#ffffff;stroke-width:2.69205331999999990;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ id="path4821-4-9-4"
+ sodipodi:cx="160.35715"
+ sodipodi:cy="240.93361"
+ sodipodi:rx="10.114144"
+ sodipodi:ry="10.114144"
+ d="m 170.47129,240.93361 a 10.114144,10.114144 0 1 1 -20.22829,0 10.114144,10.114144 0 1 1 20.22829,0 z" />
+ <path
+ transform="matrix(0.33234221,0,0,0.33234221,173.35638,592.9985)"
+ sodipodi:type="arc"
+ style="fill:#ffffff;fill-opacity:1;stroke:#ffffff;stroke-width:3.86108780000000000;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ id="path4821-4-8-4-2"
+ sodipodi:cx="160.35715"
+ sodipodi:cy="240.93361"
+ sodipodi:rx="10.114144"
+ sodipodi:ry="10.114144"
+ d="m 170.47129,240.93361 a 10.114144,10.114144 0 1 1 -20.22829,0 10.114144,10.114144 0 1 1 20.22829,0 z" />
+ <path
+ style="fill:none;stroke:#ffffff;stroke-width:1;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ d="m 231.48167,671.25081 c 5.6438,-0.15431 8.79799,1.45226 12.0778,6.25882"
+ id="path16018-7"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cc" />
+ <path
+ style="fill:none;stroke:#ffffff;stroke-width:2;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ d="m 244.5941,690.50066 c -4.06373,10.90468 -15.39442,8.6554 -15.38328,8.74968"
+ id="path16020-7"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cc" />
+ <path
+ style="fill:none;stroke:#ffffff;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+ d="m 221.63678,674.9333 c -7.09591,5.63691 -3.2412,15.66119 -3.57792,15.56405"
+ id="path16022-9"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cc" />
+ </g>
+</svg>
diff --git a/3rdParty/Boost/src/libs/atomic/doc/platform.qbk b/3rdParty/Boost/src/libs/atomic/doc/platform.qbk
new file mode 100644
index 0000000..6b9a9ec
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/doc/platform.qbk
@@ -0,0 +1,312 @@
+[/
+ / Copyright (c) 2009 Helge Bahmann
+ /
+ / 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)
+ /]
+
+[section:template_organization Organization of class template layers]
+
+The implementation uses multiple layers of template classes that
+inherit from the next lower level each and refine or adapt the respective
+underlying class:
+
+* [^boost::atomic<T>] is the topmost-level, providing
+ the external interface. Implementation-wise, it does not add anything
+ (except for hiding copy constructor and assignment operator).
+
+* [^boost::detail::atomic::internal_atomic&<T,S=sizeof(T),I=is_integral_type<T> >]:
+ This layer is mainly responsible for providing the overloaded operators
+ mapping to API member functions (e.g. [^+=] to [^fetch_add]).
+ The defaulted template parameter [^I] allows
+ to expose the correct API functions (via partial template
+ specialization): For non-integral types, it only
+ publishes the various [^exchange] functions
+ as well as load and store, for integral types it
+ additionally exports arithmetic and logic operations.
+ [br]
+ Depending on whether the given type is integral, it
+ inherits from either [^boost::detail::atomic::platform_atomic<T,S=sizeof(T)>]
+ or [^boost::detail::atomic::platform_atomic_integral<T,S=sizeof(T)>].
+ There is however some special-casing: for non-integral types
+ of size 1, 2, 4 or 8, it will coerce the datatype into an integer representation
+ and delegate to [^boost::detail::atomic::platform_atomic_integral<T,S=sizeof(T)>]
+ -- the rationale is that platform implementors only need to provide
+ integer-type operations.
+
+* [^boost::detail::atomic::platform_atomic_integral<T,S=sizeof(T)>]
+ must provide the full set of operations for an integral type T
+ (i.e. [^load], [^store], [^exchange],
+ [^compare_exchange_weak], [^compare_exchange_strong],
+ [^fetch_add], [^fetch_sub], [^fetch_and],
+ [^fetch_or], [^fetch_xor], [^is_lock_free]).
+ The default implementation uses locking to emulate atomic operations, so
+ this is the level at which implementors should provide template specializations
+ to add support for platform-specific atomic operations.
+ [br]
+ The two separate template parameters allow separate specialization
+ on size and type (which, with fixed size, cannot
+ specify more than signedness/unsignedness). The rationale is that
+ most platform-specific atomic operations usually depend only on the
+ operand size, so that common implementations for signed/unsigned
+ types are possible. Signedness allows to properly to choose sign-extending
+ instructions for the [^load] operation, avoiding later
+ conversion. The expectation is that in most implementations this will
+ be a normal assignment in C, possibly accompanied by memory
+ fences, so that the compiler can automatically choose the correct
+ instruction.
+
+* At the lowest level, [^boost::detail::atomic::platform_atomic<T,S=sizeof(T)>]
+ provides the most basic atomic operations ([^load], [^store],
+ [^exchange], [^compare_exchange_weak],
+ [^compare_exchange_strong]) for arbitrarily generic data types.
+ The default implementation uses locking as a fallback mechanism.
+ Implementors generally do not have to specialize at this level
+ (since these will not be used for the common integral type sizes
+ of 1, 2, 4 and 8 bytes), but if s/he can if s/he so wishes to
+ provide truly atomic operations for "odd" data type sizes.
+ Some amount of care must be taken as the "raw" data type
+ passed in from the user through [^boost::atomic<T>]
+ is visible here -- it thus needs to be type-punned or otherwise
+ manipulated byte-by-byte to avoid using overloaded assignment,
+ comparison operators and copy constructors.
+
+[endsect]
+
+
+[section:platform_atomic_implementation Implementing platform-specific atomic operations]
+
+In principle implementors are responsible for providing the
+full range of named member functions of an atomic object
+(i.e. [^load], [^store], [^exchange],
+[^compare_exchange_weak], [^compare_exchange_strong],
+[^fetch_add], [^fetch_sub], [^fetch_and],
+[^fetch_or], [^fetch_xor], [^is_lock_free]).
+These must be implemented as partial template specializations for
+[^boost::detail::atomic::platform_atomic_integral<T,S=sizeof(T)>]:
+
+[c++]
+
+ template<typename T>
+ class platform_atomic_integral<T, 4>
+ {
+ public:
+ explicit platform_atomic_integral(T v) : i(v) {}
+ platform_atomic_integral(void) {}
+
+ T load(memory_order order=memory_order_seq_cst) const volatile
+ {
+ // platform-specific code
+ }
+ void store(T v, memory_order order=memory_order_seq_cst) volatile
+ {
+ // platform-specific code
+ }
+
+ private:
+ volatile T i;
+ };
+
+As noted above, it will usually suffice to specialize on the second
+template argument, indicating the size of the data type in bytes.
+
+[section:automatic_buildup Templates for automatic build-up]
+
+Often only a portion of the required operations can be
+usefully mapped to machine instructions. Several helper template
+classes are provided that can automatically synthesize missing methods to
+complete an implementation.
+
+At the minimum, an implementor must provide the
+[^load], [^store],
+[^compare_exchange_weak] and
+[^is_lock_free] methods:
+
+[c++]
+
+ template<typename T>
+ class my_atomic_32 {
+ public:
+ my_atomic_32() {}
+ my_atomic_32(T initial_value) : value(initial_value) {}
+
+ T load(memory_order order=memory_order_seq_cst) volatile const
+ {
+ // platform-specific code
+ }
+ void store(T new_value, memory_order order=memory_order_seq_cst) volatile
+ {
+ // platform-specific code
+ }
+ bool compare_exchange_weak(T &expected, T desired,
+ memory_order success_order,
+ memory_order_failure_order) volatile
+ {
+ // platform-specific code
+ }
+ bool is_lock_free() const volatile {return true;}
+ protected:
+ // typedef is required for classes inheriting from this
+ typedef T integral_type;
+ private:
+ T value;
+ };
+
+The template [^boost::detail::atomic::build_atomic_from_minimal]
+can then take care of the rest:
+
+[c++]
+
+ template<typename T>
+ class platform_atomic_integral<T, 4>
+ : public boost::detail::atomic::build_atomic_from_minimal<my_atomic_32<T> >
+ {
+ public:
+ typedef build_atomic_from_minimal<my_atomic_32<T> > super;
+
+ explicit platform_atomic_integral(T v) : super(v) {}
+ platform_atomic_integral(void) {}
+ };
+
+There are several helper classes to assist in building "complete"
+atomic implementations from different starting points:
+
+* [^build_atomic_from_minimal] requires
+ * [^load]
+ * [^store]
+ * [^compare_exchange_weak] (4-operand version)
+
+* [^build_atomic_from_exchange] requires
+ * [^load]
+ * [^store]
+ * [^compare_exchange_weak] (4-operand version)
+ * [^compare_exchange_strong] (4-operand version)
+ * [^exchange]
+
+* [^build_atomic_from_add] requires
+ * [^load]
+ * [^store]
+ * [^compare_exchange_weak] (4-operand version)
+ * [^compare_exchange_strong] (4-operand version)
+ * [^exchange]
+ * [^fetch_add]
+
+* [^build_atomic_from_typical] (<I>supported on gcc only</I>) requires
+ * [^load]
+ * [^store]
+ * [^compare_exchange_weak] (4-operand version)
+ * [^compare_exchange_strong] (4-operand version)
+ * [^exchange]
+ * [^fetch_add_var] (protected method)
+ * [^fetch_inc] (protected method)
+ * [^fetch_dec] (protected method)
+
+ This will generate a [^fetch_add] method
+ that calls [^fetch_inc]/[^fetch_dec]
+ when the given parameter is a compile-time constant
+ equal to +1 or -1 respectively, and [^fetch_add_var]
+ in all other cases. This provides a mechanism for
+ optimizing the extremely common case of an atomic
+ variable being used as a counter.
+
+ The prototypes for these methods to be implemented is:
+ [c++]
+
+ template<typename T>
+ class my_atomic {
+ public:
+ T fetch_inc(memory_order order) volatile;
+ T fetch_dec(memory_order order) volatile;
+ T fetch_add_var(T counter, memory_order order) volatile;
+ };
+
+These helper templates are defined in [^boost/atomic/detail/builder.hpp].
+
+[endsect]
+
+[section:automatic_buildup_small Build sub-word-sized atomic data types]
+
+There is one other helper template that can build sub-word-sized
+atomic data types even though the underlying architecture allows
+only word-sized atomic operations:
+
+[c++]
+
+ template<typename T>
+ class platform_atomic_integral<T, 1> :
+ public build_atomic_from_larger_type<my_atomic_32<uint32_t>, T>
+ {
+ public:
+ typedef build_atomic_from_larger_type<my_atomic_32<uint32_t>, T> super;
+
+ explicit platform_atomic_integral(T v) : super(v) {}
+ platform_atomic_integral(void) {}
+ };
+
+The above would create an atomic data type of 1 byte size, and
+use masking and shifts to map it to 32-bit atomic operations.
+The base type must implement [^load], [^store]
+and [^compare_exchange_weak] for this to work.
+
+[endsect]
+
+[section:other_sizes Atomic data types for unusual object sizes]
+
+In unusual circumstances, an implementor may also opt to specialize
+[^public boost::detail::atomic::platform_atomic<T,S=sizeof(T)>]
+to provide support for atomic objects not fitting an integral size.
+If you do that, keep the following things in mind:
+
+* There is no reason to ever do this for object sizes
+ of 1, 2, 4 and 8
+* Only the following methods need to be implemented:
+ * [^load]
+ * [^store]
+ * [^compare_exchange_weak] (4-operand version)
+ * [^compare_exchange_strong] (4-operand version)
+ * [^exchange]
+
+The type of the data to be stored in the atomic
+variable (template parameter [^T])
+is exposed to this class, and the type may have
+overloaded assignment and comparison operators --
+using these overloaded operators however will result
+in an error. The implementor is responsible for
+accessing the objects in a way that does not
+invoke either of these operators (using e.g.
+[^memcpy] or type-casts).
+
+[endsect]
+
+[endsect]
+
+[section:platform_atomic_fences Fences]
+
+Platform implementors need to provide a function performing
+the action required for [funcref boost::atomic_thread_fence atomic_thread_fence]
+(the fallback implementation will just perform an atomic operation
+on an integer object). This is achieved by specializing the
+[^boost::detail::atomic::platform_atomic_thread_fence] template
+function in the following way:
+
+[c++]
+
+ template<>
+ void platform_atomic_thread_fence(memory_order order)
+ {
+ // platform-specific code here
+ }
+
+[endsect]
+
+[section:platform_atomic_puttogether Putting it altogether]
+
+The template specializations should be put into a header file
+in the [^boost/atomic/detail] directory, preferably
+specifying supported compiler and architecture in its name.
+
+The file [^boost/atomic/detail/platform.hpp] must
+subsequently be modified to conditionally include the new
+header.
+
+[endsect]
diff --git a/3rdParty/Boost/src/libs/atomic/index.html b/3rdParty/Boost/src/libs/atomic/index.html
new file mode 100644
index 0000000..62a6c59
--- /dev/null
+++ b/3rdParty/Boost/src/libs/atomic/index.html
@@ -0,0 +1,13 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/atomic.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/atomic.html">../../doc/html/atomic.html</a> &nbsp;<hr>
+<p>&copy; Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>
diff --git a/3rdParty/Boost/src/libs/signals/src/connection.cpp b/3rdParty/Boost/src/libs/signals/src/connection.cpp
deleted file mode 100644
index b4ed8b4..0000000
--- a/3rdParty/Boost/src/libs/signals/src/connection.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-// 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
-
-#define BOOST_SIGNALS_SOURCE
-
-#include <boost/signals/connection.hpp>
-#include <cassert>
-
-namespace boost {
- namespace BOOST_SIGNALS_NAMESPACE {
-
- connection::connection(const connection& other) :
- con(other.con), controlling_connection(other.controlling_connection)
- {
- }
-
- connection::~connection()
- {
- if (controlling_connection) {
- disconnect();
- }
- }
-
- void
- connection::reset(BOOST_SIGNALS_NAMESPACE::detail::basic_connection* new_con)
- {
- con.reset(new_con);
- }
-
- bool connection::operator==(const connection& other) const
- {
- return con.get() == other.con.get();
- }
-
- bool connection::operator<(const connection& other) const
- {
- return con.get() < other.con.get();
- }
-
- connection& connection::operator=(const connection& other)
- {
- connection(other).swap(*this);
- return *this;
- }
-
- void connection::swap(connection& other)
- {
- this->con.swap(other.con);
- std::swap(this->controlling_connection, other.controlling_connection);
- }
-
- void swap(connection& c1, connection& c2)
- {
- c1.swap(c2);
- }
-
- scoped_connection::scoped_connection(const connection& other) :
- connection(other),
- released(false)
- {
- }
-
- scoped_connection::scoped_connection(const scoped_connection& other) :
- connection(other),
- released(other.released)
- {
- }
-
- scoped_connection::~scoped_connection()
- {
- if (!released) {
- this->disconnect();
- }
- }
-
- connection scoped_connection::release()
- {
- released = true;
- return *this;
- }
-
- void scoped_connection::swap(scoped_connection& other)
- {
- this->connection::swap(other);
- bool other_released = other.released;
- other.released = this->released;
- this->released = other_released;
- }
-
- void swap(scoped_connection& c1, scoped_connection& c2)
- {
- c1.swap(c2);
- }
-
- scoped_connection&
- scoped_connection::operator=(const connection& other)
- {
- scoped_connection(other).swap(*this);
- return *this;
- }
-
- scoped_connection&
- scoped_connection::operator=(const scoped_connection& other)
- {
- scoped_connection(other).swap(*this);
- return *this;
- }
-
- void
- connection::add_bound_object(const BOOST_SIGNALS_NAMESPACE::detail::bound_object& b)
- {
- assert(con.get() != 0);
- con->bound_objects.push_back(b);
- }
-
-
- void connection::disconnect() const
- {
- if (this->connected()) {
- // Make sure we have a reference to the basic_connection object,
- // because 'this' may disappear
- shared_ptr<detail::basic_connection> local_con = con;
-
- void (*signal_disconnect)(void*, void*) = local_con->signal_disconnect;
-
- // Note that this connection no longer exists
- // Order is important here: we could get into an infinite loop if this
- // isn't cleared before we try the disconnect.
- local_con->signal_disconnect = 0;
-
- // Disconnect signal
- signal_disconnect(local_con->signal, local_con->signal_data);
-
- // Disconnect all bound objects
- typedef std::list<BOOST_SIGNALS_NAMESPACE::detail::bound_object>::iterator iterator;
- for (iterator i = local_con->bound_objects.begin();
- i != local_con->bound_objects.end(); ++i) {
- assert(i->disconnect != 0);
- i->disconnect(i->obj, i->data);
- }
- }
- }
- } // end namespace boost
-} // end namespace boost
-
-#ifndef BOOST_MSVC
-// Explicit instantiations to keep everything in the library
-template class std::list<boost::BOOST_SIGNALS_NAMESPACE::detail::bound_object>;
-#endif
diff --git a/3rdParty/Boost/src/libs/signals/src/named_slot_map.cpp b/3rdParty/Boost/src/libs/signals/src/named_slot_map.cpp
deleted file mode 100644
index 2fe2790..0000000
--- a/3rdParty/Boost/src/libs/signals/src/named_slot_map.cpp
+++ /dev/null
@@ -1,134 +0,0 @@
-// 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
-
-#define BOOST_SIGNALS_SOURCE
-
-#include <boost/signals/detail/named_slot_map.hpp>
-#include <cassert>
-#include <map>
-#include <list>
-#include <typeinfo>
-
-namespace boost { namespace BOOST_SIGNALS_NAMESPACE { namespace detail {
-
-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;
-
-
-#if BOOST_WORKAROUND(_MSC_VER, <= 1900)
-void named_slot_map_iterator::decrement() { assert(false); }
-void named_slot_map_iterator::advance(difference_type) { assert(false); }
-#endif
-
-named_slot_map::named_slot_map(const compare_type& compare) : groups(compare)
-{
- clear();
-}
-
-void named_slot_map::clear()
-{
- groups.clear();
- groups[stored_group(stored_group::sk_front)];
- groups[stored_group(stored_group::sk_back)];
- back = groups.end();
- --back;
-}
-
-named_slot_map::iterator named_slot_map::begin()
-{
- return named_slot_map::iterator(groups.begin(), groups.end());
-}
-
-named_slot_map::iterator named_slot_map::end()
-{
- return named_slot_map::iterator(groups.end(), groups.end());
-}
-
-named_slot_map::iterator
-named_slot_map::insert(const stored_group& name, const connection& con,
- const any& slot, connect_position at)
-{
- group_iterator group;
- if (name.empty()) {
- switch (at) {
- case at_front: group = groups.begin(); break;
- case at_back: group = back; break;
- }
- } else {
- group = groups.find(name);
- if (group == groups.end()) {
- slot_container_type::value_type v(name, group_list());
- group = groups.insert(v).first;
- }
- }
- iterator it;
- it.group = group;
- it.last_group = groups.end();
-
- switch (at) {
- case at_back:
- group->second.push_back(connection_slot_pair(con, slot));
- it.slot_ = group->second.end();
- it.slot_assigned = true;
- --(it.slot_);
- break;
-
- case at_front:
- group->second.push_front(connection_slot_pair(con, slot));
- it.slot_ = group->second.begin();
- it.slot_assigned = true;
- break;
- }
- return it;
-}
-
-void named_slot_map::disconnect(const stored_group& name)
-{
- group_iterator group = groups.find(name);
- if (group != groups.end()) {
- slot_pair_iterator i = group->second.begin();
- while (i != group->second.end()) {
- slot_pair_iterator next = i;
- ++next;
- i->first.disconnect();
- i = next;
- }
- groups.erase((const_group_iterator) group);
- }
-}
-
-void named_slot_map::erase(iterator pos)
-{
- // Erase the slot
- pos.slot_->first.disconnect();
- pos.group->second.erase(pos.slot_);
-}
-
-void named_slot_map::remove_disconnected_slots()
-{
- // Remove any disconnected slots
- group_iterator g = groups.begin();
- while (g != groups.end()) {
- slot_pair_iterator s = g->second.begin();
- while (s != g->second.end()) {
- if (s->first.connected()) ++s;
- else g->second.erase(s++);
- }
-
- // Clear out empty groups
- if (empty(g)) groups.erase((const_group_iterator) g++);
- else ++g;
- }
-}
-
-
-} } }
diff --git a/3rdParty/Boost/src/libs/signals/src/signal_base.cpp b/3rdParty/Boost/src/libs/signals/src/signal_base.cpp
deleted file mode 100644
index 759672d..0000000
--- a/3rdParty/Boost/src/libs/signals/src/signal_base.cpp
+++ /dev/null
@@ -1,189 +0,0 @@
-// 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
-
-#define BOOST_SIGNALS_SOURCE
-
-#include <boost/signals/detail/signal_base.hpp>
-#include <cassert>
-
-namespace boost {
- namespace BOOST_SIGNALS_NAMESPACE {
- namespace detail {
- signal_base_impl::signal_base_impl(const compare_type& comp,
- const any& combiner)
- : call_depth(0),
- slots_(comp),
- combiner_(combiner)
- {
- flags.delayed_disconnect = false;
- flags.clearing = false;
- }
-
- signal_base_impl::~signal_base_impl()
- {
- // Set the "clearing" flag to ignore extraneous disconnect requests,
- // because all slots will be disconnected on destruction anyway.
- flags.clearing = true;
- }
-
- void signal_base_impl::disconnect_all_slots()
- {
- // Do nothing if we're already clearing the slot list
- if (flags.clearing)
- return;
-
- if (call_depth == 0) {
- // Clearing the slot list will disconnect all slots automatically
- temporarily_set_clearing set_clearing(this);
- slots_.clear();
- }
- else {
- // We can't actually remove elements from the slot list because there
- // are still iterators into the slot list that must not be
- // invalidated by this operation. So just disconnect each slot
- // without removing it from the slot list. When the call depth does
- // reach zero, the call list will be cleared.
- flags.delayed_disconnect = true;
- temporarily_set_clearing set_clearing(this);
- for (iterator i = slots_.begin(); i != slots_.end(); ++i) {
- i->first.disconnect();
- }
- }
- }
-
- connection
- signal_base_impl::
- connect_slot(const any& slot_,
- const stored_group& name,
- shared_ptr<slot_base::data_t> data,
- connect_position at)
- {
- // Transfer the burden of ownership to a local, scoped
- // connection.
- data->watch_bound_objects.set_controlling(false);
- scoped_connection safe_connection(data->watch_bound_objects);
-
- // Allocate storage for an iterator that will hold the point of
- // insertion of the slot into the list. This is used to later remove
- // the slot when it is disconnected.
- std::auto_ptr<iterator> saved_iter(new iterator);
-
- // Add the slot to the list.
- iterator pos =
- slots_.insert(name, data->watch_bound_objects, slot_, at);
-
- // The assignment operation here absolutely must not throw, which
- // intuitively makes sense (because any container's insert method
- // becomes impossible to use in an exception-safe manner without this
- // assumption), but doesn't appear to be mentioned in the standard.
- *saved_iter = pos;
-
- // Fill out the connection object appropriately. None of these
- // operations can throw
- data->watch_bound_objects.get_connection()->signal = this;
- data->watch_bound_objects.get_connection()->signal_data =
- saved_iter.release();
- data->watch_bound_objects.get_connection()->signal_disconnect =
- &signal_base_impl::slot_disconnected;
-
- // Make the copy of the connection in the list disconnect when it is
- // destroyed. The local, scoped connection is then released
- // because ownership has been transferred.
- pos->first.set_controlling();
- return safe_connection.release();
- }
-
- bool signal_base_impl::empty() const
- {
- // Disconnected slots may still be in the list of slots if
- // a) this is called while slots are being invoked (call_depth > 0)
- // b) an exception was thrown in remove_disconnected_slots
- for (iterator i = slots_.begin(); i != slots_.end(); ++i) {
- if (i->first.connected())
- return false;
- }
-
- return true;
- }
-
- std::size_t signal_base_impl::num_slots() const
- {
- // Disconnected slots may still be in the list of slots if
- // a) this is called while slots are being invoked (call_depth > 0)
- // b) an exception was thrown in remove_disconnected_slots
- std::size_t count = 0;
- for (iterator i = slots_.begin(); i != slots_.end(); ++i) {
- if (i->first.connected())
- ++count;
- }
- return count;
- }
-
- void signal_base_impl::disconnect(const stored_group& group)
- { slots_.disconnect(group); }
-
- void signal_base_impl::slot_disconnected(void* obj, void* data)
- {
- signal_base_impl* self = reinterpret_cast<signal_base_impl*>(obj);
-
- // We won't need the slot iterator after this
- std::auto_ptr<iterator> slot(reinterpret_cast<iterator*>(data));
-
- // If we're flags.clearing, we don't bother updating the list of slots
- if (!self->flags.clearing) {
- // If we're in a call, note the fact that a slot has been deleted so
- // we can come back later to remove the iterator
- if (self->call_depth > 0) {
- self->flags.delayed_disconnect = true;
- }
- else {
- // Just remove the slot now, it's safe
- self->slots_.erase(*slot);
- }
- }
- }
-
- void signal_base_impl::remove_disconnected_slots() const
- { slots_.remove_disconnected_slots(); }
-
- call_notification::
- call_notification(const shared_ptr<signal_base_impl>& b) :
- impl(b)
- {
- // A call will be made, so increment the call depth as a notification
- impl->call_depth++;
- }
-
- call_notification::~call_notification()
- {
- impl->call_depth--;
-
- // If the call depth is zero and we have some slots that have been
- // disconnected during the calls, remove those slots from the list
- if (impl->call_depth == 0 &&
- impl->flags.delayed_disconnect) {
- impl->remove_disconnected_slots();
- impl->flags.delayed_disconnect = false;
- }
- }
-
- signal_base::signal_base(const compare_type& comp, const any& combiner)
- : impl()
- {
- impl.reset(new signal_base_impl(comp, combiner));
- }
-
- signal_base::~signal_base()
- {
- }
-
- } // namespace detail
- } // namespace BOOST_SIGNALS_NAMESPACE
-} // namespace boost
-
diff --git a/3rdParty/Boost/src/libs/signals/src/slot.cpp b/3rdParty/Boost/src/libs/signals/src/slot.cpp
deleted file mode 100644
index 7c296d6..0000000
--- a/3rdParty/Boost/src/libs/signals/src/slot.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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
-
-#define BOOST_SIGNALS_SOURCE
-
-#include <boost/signals/slot.hpp>
-
-namespace boost {
- namespace BOOST_SIGNALS_NAMESPACE {
- namespace detail {
- void slot_base::create_connection()
- {
- // Create a new connection object
- basic_connection* con = new basic_connection();
-
- /* nothrow */ {
- // The signal portion isn't really necessary, except that we need a
- // signal for the connection to be connected.
- con->signal = static_cast<void*>(this);
- con->signal_data = 0;
- con->blocked_ = false ;
- con->signal_disconnect = &bound_object_destructed;
- }
-
- // This connection watches for destruction of bound objects. Note
- // that the reset routine will delete con if an allocation throws
- data->watch_bound_objects.reset(con);
-
- // We create a scoped connection, so that exceptions thrown while
- // adding bound objects will cause a cleanup of the bound objects
- // already connected.
- scoped_connection safe_connection(data->watch_bound_objects);
-
- // Now notify each of the bound objects that they are connected to this
- // slot.
- for(std::vector<const trackable*>::iterator i =
- data->bound_objects.begin();
- i != data->bound_objects.end(); ++i) {
- // Notify the object that the slot is connecting to it
- BOOST_SIGNALS_NAMESPACE::detail::bound_object binding;
- (*i)->signal_connected(data->watch_bound_objects, binding);
-
- // This will notify the bound object that the connection just made
- // should be disconnected if an exception is thrown before the
- // end of this iteration
- BOOST_SIGNALS_NAMESPACE::detail::auto_disconnect_bound_object
- disconnector(binding);
-
- // Add the binding to the list of bindings for the connection
- con->bound_objects.push_back(binding);
-
- // The connection object now knows about the bound object, so if an
- // exception is thrown later the connection object will notify the
- // bound object of the disconnection automatically
- disconnector.release();
- }
-
- // No exceptions will be thrown past this point.
- safe_connection.release();
-
- data->watch_bound_objects.set_controlling(true);
- }
- } // end namespace detail
- } // end namespace BOOST_SIGNALS_NAMESPACE
-} // end namespace boost
diff --git a/3rdParty/Boost/src/libs/signals/src/trackable.cpp b/3rdParty/Boost/src/libs/signals/src/trackable.cpp
deleted file mode 100644
index 4f63586..0000000
--- a/3rdParty/Boost/src/libs/signals/src/trackable.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-// 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
-
-#define BOOST_SIGNALS_SOURCE
-
-#include <boost/signals/trackable.hpp>
-#include <algorithm>
-
-namespace boost {
- namespace BOOST_SIGNALS_NAMESPACE {
- void trackable::signal_disconnected(void* obj, void* data)
- {
- trackable* self = reinterpret_cast<trackable*>(obj);
- connection_iterator* signal =
- reinterpret_cast<connection_iterator*>(data);
-
- // If we're dying, don't bother erasing the connection from the list;
- // it'll be gone anyway
- if (!self->dying) {
- self->connected_signals.erase(*signal);
- }
-
- // This iterator pointer won't ever be used again
- delete signal;
- }
-
- void
- trackable::signal_connected(connection c,
- BOOST_SIGNALS_NAMESPACE::detail::bound_object& binding) const
- {
- // Insert the connection
- connection_iterator pos =
- connected_signals.insert(connected_signals.end(), c);
-
- // Make this copy of the object disconnect when destroyed
- pos->set_controlling();
-
- binding.obj = const_cast<void*>(reinterpret_cast<const void*>(this));
- binding.data = reinterpret_cast<void*>(new connection_iterator(pos));
- binding.disconnect = &signal_disconnected;
- }
-
- trackable::~trackable()
- {
- dying = true;
- }
- } // end namespace BOOST_SIGNALS_NAMESPACE
-}
-
-#ifndef BOOST_MSVC
-// Explicit instantiations to keep in the library
-template class std::list<boost::BOOST_SIGNALS_NAMESPACE::connection>;
-#endif