Swiftdiff options
| author | Tobias Markmann <tm@ayena.de> | 2016-04-05 13:17:19 (GMT) |
|---|---|---|
| committer | Tobias Markmann <tm@ayena.de> | 2016-04-05 19:42:39 (GMT) |
| commit | 2b560b129b7a31fc8cc07f618e763c95a22bf832 (patch) | |
| tree | 73e72cdc758b79d01485dc28dcedd48b26859ae8 /3rdParty/Boost/src | |
| parent | 3c560e31b0f168da917e8d566db01fd1cd997d86 (diff) | |
| download | swift-2b560b129b7a31fc8cc07f618e763c95a22bf832.zip swift-2b560b129b7a31fc8cc07f618e763c95a22bf832.tar.bz2 | |
Migrate to Boost.Signals2 from Boost.Signals
Boost.Signals was deprecated and is not improved further.
This patch removes Boost.Signals from 3rdParty and adds
Boost.Signals2 and its dependencies.
Also removed the Qt signals compatibility file
Swiften/Base/boost_bsignals.h.
Test-Information:
Build and ran unit tests on OS X 10.11.4. Confirmed successful
login using Swift client.
Change-Id: Ie6e3b2d15aac2462cda95401582f5287a479fb54
Diffstat (limited to '3rdParty/Boost/src')
145 files changed, 15753 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/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, 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 Binary files differnew file mode 100644 index 0000000..8b12104 --- /dev/null +++ b/3rdParty/Boost/src/libs/atomic/doc/logo.png 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> <hr> +<p>© 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 |
