FCL/sf/os/ossrv: comparison ossrv_pub/boost_apis/boost/function/function

equal deleted inserted replaced

--1:000000000000
+:e4d67989cc36
+// Boost.Function 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
+#ifndef BOOST_FUNCTION_BASE_HEADER
+#define BOOST_FUNCTION_BASE_HEADER
+#include <stdexcept>
+#include <string>
+#include <memory>
+#include <new>
+#include <typeinfo>
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/composite_traits.hpp>
+#include <boost/ref.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#ifndef BOOST_NO_SFINAE
+#  include "boost/utility/enable_if.hpp"
+#else
+#  include "boost/mpl/bool.hpp"
+#endif
+#include <boost/function_equal.hpp>
+// Borrowed from Boost.Python library: determines the cases where we
+// need to use std::type_info::name to compare instead of operator==.
+# if (defined(__GNUC__) && __GNUC__ >= 3) \
+|| defined(_AIX) \
+|| (   defined(__sgi) && defined(__host_mips))
+#  include <cstring>
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
+(std::strcmp((X).name(),(Y).name()) == 0)
+# else
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#endif
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
+#  define BOOST_FUNCTION_TARGET_FIX(x) x
+#else
+#  define BOOST_FUNCTION_TARGET_FIX(x)
+#endif // not MSVC
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+// Work around a compiler bug.
+// boost::python::objects::function has to be seen by the compiler before the
+// boost::function class template.
+namespace boost { namespace python { namespace objects {
+class function;
+}}}
+#endif
+#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
+|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+|| !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+#endif
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
+typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+(::boost::is_integral<Functor>::value)>::value), \
+Type>::type
+#else
+// BCC doesn't recognize this depends on a template argument and complains
+// about the use of 'typename'
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
+::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+(::boost::is_integral<Functor>::value)>::value), \
+Type>::type
+#endif
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+namespace boost {
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+// The library shipping with MIPSpro 7.3.1.3m has a broken allocator<void>
+class function_base;
+template<typename Signature,
+typename Allocator = std::allocator<function_base> >
+class function;
+#else
+template<typename Signature, typename Allocator = std::allocator<void> >
+class function;
+#endif
+template<typename Signature, typename Allocator>
+inline void swap(function<Signature, Allocator>& f1,
+function<Signature, Allocator>& f2)
+{
+f1.swap(f2);
+}
+} // end namespace boost
+#endif // have partial specialization
+namespace boost {
+namespace detail {
+namespace function {
+class X;
+/**
+* A buffer used to store small function objects in
+* boost::function. It is a union containing function pointers,
+* object pointers, and a structure that resembles a bound
+* member function pointer.
+*/
+union function_buffer
+{
+// For pointers to function objects
+void* obj_ptr;
+// For pointers to std::type_info objects
+// (get_functor_type_tag, check_functor_type_tag).
+const void* const_obj_ptr;
+// For function pointers of all kinds
+mutable void (*func_ptr)();
+// For bound member pointers
+struct bound_memfunc_ptr_t {
+void (X::*memfunc_ptr)(int);
+void* obj_ptr;
+} bound_memfunc_ptr;
+// To relax aliasing constraints
+mutable char data;
+};
+/**
+* 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 to
+* handle Boost.Function objects returning void.
+*/
+struct unusable
+{
+unusable() {}
+template<typename T> unusable(const T&) {}
+};
+/* Determine the return type. This supports compilers that do not support
+* void returns or partial specialization by silently changing the return
+* type to "unusable".
+*/
+template<typename T> struct function_return_type { typedef T type; };
+template<>
+struct function_return_type<void>
+{
+typedef unusable type;
+};
+// The operation type to perform on the given functor/function pointer
+enum functor_manager_operation_type {
+clone_functor_tag,
+destroy_functor_tag,
+check_functor_type_tag,
+get_functor_type_tag
+};
+// Tags used to decide between different types of functions
+struct function_ptr_tag {};
+struct function_obj_tag {};
+struct member_ptr_tag {};
+struct function_obj_ref_tag {};
+template<typename F>
+class get_function_tag
+{
+typedef typename mpl::if_c<(is_pointer<F>::value),
+function_ptr_tag,
+function_obj_tag>::type ptr_or_obj_tag;
+typedef typename mpl::if_c<(is_member_pointer<F>::value),
+member_ptr_tag,
+ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
+typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
+function_obj_ref_tag,
+ptr_or_obj_or_mem_tag>::type or_ref_tag;
+public:
+typedef or_ref_tag type;
+};
+// The trivial manager does nothing but return the same pointer (if we
+// are cloning) or return the null pointer (if we are deleting).
+template<typename F>
+struct reference_manager
+{
+static inline void
+get(const function_buffer& in_buffer, function_buffer& out_buffer,
+functor_manager_operation_type op)
+{
+switch (op) {
+case clone_functor_tag:
+out_buffer.obj_ptr = in_buffer.obj_ptr;
+return;
+case destroy_functor_tag:
+out_buffer.obj_ptr = 0;
+return;
+case check_functor_type_tag:
+{
+// DPG TBD: Since we're only storing a pointer, it's
+// possible that the user could ask for a base class or
+// derived class. Is that okay?
+const std::type_info& check_type =
+*static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
+if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
+out_buffer.obj_ptr = in_buffer.obj_ptr;
+else
+out_buffer.obj_ptr = 0;
+}
+return;
+case get_functor_type_tag:
+out_buffer.const_obj_ptr = &typeid(F);
+return;
+}
+}
+};
+/**
+* Determine if boost::function can use the small-object
+* optimization with the function object type F.
+*/
+template<typename F>
+struct function_allows_small_object_optimization
+{
+BOOST_STATIC_CONSTANT
+(bool,
+value = ((sizeof(F) <= sizeof(function_buffer) &&
+(alignment_of<function_buffer>::value
+% alignment_of<F>::value == 0))));
+};
+/**
+* The functor_manager class contains a static function "manage" which
+* can clone or destroy the given function/function object pointer.
+*/
+template<typename Functor, typename Allocator>
+struct functor_manager
+{
+private:
+typedef Functor functor_type;
+// For function pointers, the manager is trivial
+static inline void
+manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+functor_manager_operation_type op, function_ptr_tag)
+{
+if (op == clone_functor_tag)
+out_buffer.func_ptr = in_buffer.func_ptr;
+else if (op == destroy_functor_tag)
+out_buffer.func_ptr = 0;
+else /* op == check_functor_type_tag */ {
+const std::type_info& check_type =
+*static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
+if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+out_buffer.obj_ptr = &in_buffer.func_ptr;
+else
+out_buffer.obj_ptr = 0;
+}
+}
+// Function objects that fit in the small-object buffer.
+static inline void
+manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+functor_manager_operation_type op, mpl::true_)
+{
+if (op == clone_functor_tag) {
+const functor_type* in_functor =
+reinterpret_cast<const functor_type*>(&in_buffer.data);
+new ((void*)&out_buffer.data) functor_type(*in_functor);
+} else if (op == destroy_functor_tag) {
+// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
+reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
+} else /* op == check_functor_type_tag */ {
+const std::type_info& check_type =
+*static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
+if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+out_buffer.obj_ptr = &in_buffer.data;
+else
+out_buffer.obj_ptr = 0;
+}
+}
+// Function objects that require heap allocation
+static inline void
+manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+functor_manager_operation_type op, mpl::false_)
+{
+#ifndef BOOST_NO_STD_ALLOCATOR
+typedef typename Allocator::template rebind<functor_type>::other
+allocator_type;
+typedef typename allocator_type::pointer pointer_type;
+#else
+typedef functor_type* pointer_type;
+#endif // BOOST_NO_STD_ALLOCATOR
+#  ifndef BOOST_NO_STD_ALLOCATOR
+allocator_type allocator;
+#  endif // BOOST_NO_STD_ALLOCATOR
+if (op == clone_functor_tag) {
+// GCC 2.95.3 gets the CV qualifiers wrong here, so we
+// can't do the static_cast that we should do.
+const functor_type* f =
+(const functor_type*)(in_buffer.obj_ptr);
+// Clone the functor
+#  ifndef BOOST_NO_STD_ALLOCATOR
+pointer_type copy = allocator.allocate(1);
+allocator.construct(copy, *f);
+// Get back to the original pointer type
+functor_type* new_f = static_cast<functor_type*>(copy);
+#  else
+functor_type* new_f = new functor_type(*f);
+#  endif // BOOST_NO_STD_ALLOCATOR
+out_buffer.obj_ptr = new_f;
+} else if (op == destroy_functor_tag) {
+/* Cast from the void pointer to the functor pointer type */
+functor_type* f =
+static_cast<functor_type*>(out_buffer.obj_ptr);
+#  ifndef BOOST_NO_STD_ALLOCATOR
+/* Cast from the functor pointer type to the allocator's pointer
+type */
+pointer_type victim = static_cast<pointer_type>(f);
+// Destroy and deallocate the functor
+allocator.destroy(victim);
+allocator.deallocate(victim, 1);
+#  else
+delete f;
+#  endif // BOOST_NO_STD_ALLOCATOR
+out_buffer.obj_ptr = 0;
+} else /* op == check_functor_type_tag */ {
+const std::type_info& check_type =
+*static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
+if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+out_buffer.obj_ptr = in_buffer.obj_ptr;
+else
+out_buffer.obj_ptr = 0;
+}
+}
+// For function objects, we determine whether the function
+// object can use the small-object optimization buffer or
+// whether we need to allocate it on the heap.
+static inline void
+manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+functor_manager_operation_type op, function_obj_tag)
+{
+manager(in_buffer, out_buffer, op,
+mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+}
+public:
+/* Dispatch to an appropriate manager based on whether we have a
+function pointer or a function object pointer. */
+static inline void
+manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+functor_manager_operation_type op)
+{
+typedef typename get_function_tag<functor_type>::type tag_type;
+switch (op) {
+case get_functor_type_tag:
+out_buffer.const_obj_ptr = &typeid(functor_type);
+return;
+default:
+manager(in_buffer, out_buffer, op, tag_type());
+return;
+}
+}
+};
+// A type that is only used for comparisons against zero
+struct useless_clear_type {};
+#ifdef BOOST_NO_SFINAE
+// These routines perform comparisons between a Boost.Function
+// object and an arbitrary function object (when the last
+// parameter is mpl::bool_<false>) or against zero (when the
+// last parameter is mpl::bool_<true>). They are only necessary
+// for compilers that don't support SFINAE.
+template<typename Function, typename Functor>
+bool
+compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
+{ return f.empty(); }
+template<typename Function, typename Functor>
+bool
+compare_not_equal(const Function& f, const Functor&, int,
+mpl::bool_<true>)
+{ return !f.empty(); }
+template<typename Function, typename Functor>
+bool
+compare_equal(const Function& f, const Functor& g, long,
+mpl::bool_<false>)
+{
+if (const Functor* fp = f.template target<Functor>())
+return function_equal(*fp, g);
+else return false;
+}
+template<typename Function, typename Functor>
+bool
+compare_equal(const Function& f, const reference_wrapper<Functor>& g,
+int, mpl::bool_<false>)
+{
+if (const Functor* fp = f.template target<Functor>())
+return fp == g.get_pointer();
+else return false;
+}
+template<typename Function, typename Functor>
+bool
+compare_not_equal(const Function& f, const Functor& g, long,
+mpl::bool_<false>)
+{
+if (const Functor* fp = f.template target<Functor>())
+return !function_equal(*fp, g);
+else return true;
+}
+template<typename Function, typename Functor>
+bool
+compare_not_equal(const Function& f,
+const reference_wrapper<Functor>& g, int,
+mpl::bool_<false>)
+{
+if (const Functor* fp = f.template target<Functor>())
+return fp != g.get_pointer();
+else return true;
+}
+#endif // BOOST_NO_SFINAE
+/**
+* Stores the "manager" portion of the vtable for a
+* boost::function object.
+*/
+struct vtable_base
+{
+vtable_base() : manager(0) { }
+void (*manager)(const function_buffer& in_buffer,
+function_buffer& out_buffer,
+functor_manager_operation_type op);
+};
+} // end namespace function
+} // end namespace detail
+/**
+* The function_base class contains the basic elements needed for the
+* function1, function2, function3, etc. classes. It is common to all
+* functions (and as such can be used to tell if we have one of the
+* functionN objects).
+*/
+class function_base
+{
+public:
+function_base() : vtable(0) { }
+/** Determine if the function is empty (i.e., has no target). */
+bool empty() const { return !vtable; }
+/** Retrieve the type of the stored function object, or typeid(void)
+if this is empty. */
+const std::type_info& target_type() const
+{
+if (!vtable) return typeid(void);
+detail::function::function_buffer type;
+vtable->manager(functor, type, detail::function::get_functor_type_tag);
+return *static_cast<const std::type_info*>(type.const_obj_ptr);
+}
+template<typename Functor>
+Functor* target()
+{
+if (!vtable) return 0;
+detail::function::function_buffer type_result;
+type_result.const_obj_ptr = &typeid(Functor);
+vtable->manager(functor, type_result,
+detail::function::check_functor_type_tag);
+return static_cast<Functor*>(type_result.obj_ptr);
+}
+template<typename Functor>
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+const Functor* target( Functor * = 0 ) const
+#else
+const Functor* target() const
+#endif
+{
+if (!vtable) return 0;
+detail::function::function_buffer type_result;
+type_result.const_obj_ptr = &typeid(Functor);
+vtable->manager(functor, type_result,
+detail::function::check_functor_type_tag);
+// GCC 2.95.3 gets the CV qualifiers wrong here, so we
+// can't do the static_cast that we should do.
+return (const Functor*)(type_result.obj_ptr);
+}
+template<typename F>
+bool contains(const F& f) const
+{
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+if (const F* fp = this->target( (F*)0 ))
+#else
+if (const F* fp = this->template target<F>())
+#endif
+{
+return function_equal(*fp, f);
+} else {
+return false;
+}
+}
+#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
+// GCC 3.3 and newer cannot copy with the global operator==, due to
+// problems with instantiation of function return types before it
+// has been verified that the argument types match up.
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator==(Functor g) const
+{
+if (const Functor* fp = target<Functor>())
+return function_equal(*fp, g);
+else return false;
+}
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator!=(Functor g) const
+{
+if (const Functor* fp = target<Functor>())
+return !function_equal(*fp, g);
+else return true;
+}
+#endif
+public: // should be protected, but GCC 2.95.3 will fail to allow access
+detail::function::vtable_base* vtable;
+mutable detail::function::function_buffer functor;
+};
+/**
+* The bad_function_call exception class is thrown when a boost::function
+* object is invoked
+*/
+class bad_function_call : public std::runtime_error
+{
+public:
+bad_function_call() : std::runtime_error("call to empty boost::function") {}
+};
+#ifndef BOOST_NO_SFINAE
+inline bool operator==(const function_base& f,
+detail::function::useless_clear_type*)
+{
+return f.empty();
+}
+inline bool operator!=(const function_base& f,
+detail::function::useless_clear_type*)
+{
+return !f.empty();
+}
+inline bool operator==(detail::function::useless_clear_type*,
+const function_base& f)
+{
+return f.empty();
+}
+inline bool operator!=(detail::function::useless_clear_type*,
+const function_base& f)
+{
+return !f.empty();
+}
+#endif
+#ifdef BOOST_NO_SFINAE
+// Comparisons between boost::function objects and arbitrary function objects
+template<typename Functor>
+inline bool operator==(const function_base& f, Functor g)
+{
+typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+return detail::function::compare_equal(f, g, 0, integral());
+}
+template<typename Functor>
+inline bool operator==(Functor g, const function_base& f)
+{
+typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+return detail::function::compare_equal(f, g, 0, integral());
+}
+template<typename Functor>
+inline bool operator!=(const function_base& f, Functor g)
+{
+typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+return detail::function::compare_not_equal(f, g, 0, integral());
+}
+template<typename Functor>
+inline bool operator!=(Functor g, const function_base& f)
+{
+typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+return detail::function::compare_not_equal(f, g, 0, integral());
+}
+#else
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+// Comparisons between boost::function objects and arbitrary function
+// objects. GCC 3.3 and before has an obnoxious bug that prevents this
+// from working.
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator==(const function_base& f, Functor g)
+{
+if (const Functor* fp = f.template target<Functor>())
+return function_equal(*fp, g);
+else return false;
+}
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator==(Functor g, const function_base& f)
+{
+if (const Functor* fp = f.template target<Functor>())
+return function_equal(g, *fp);
+else return false;
+}
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator!=(const function_base& f, Functor g)
+{
+if (const Functor* fp = f.template target<Functor>())
+return !function_equal(*fp, g);
+else return true;
+}
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator!=(Functor g, const function_base& f)
+{
+if (const Functor* fp = f.template target<Functor>())
+return !function_equal(g, *fp);
+else return true;
+}
+#  endif
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator==(const function_base& f, reference_wrapper<Functor> g)
+{
+if (const Functor* fp = f.template target<Functor>())
+return fp == g.get_pointer();
+else return false;
+}
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator==(reference_wrapper<Functor> g, const function_base& f)
+{
+if (const Functor* fp = f.template target<Functor>())
+return g.get_pointer() == fp;
+else return false;
+}
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator!=(const function_base& f, reference_wrapper<Functor> g)
+{
+if (const Functor* fp = f.template target<Functor>())
+return fp != g.get_pointer();
+else return true;
+}
+template<typename Functor>
+BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+operator!=(reference_wrapper<Functor> g, const function_base& f)
+{
+if (const Functor* fp = f.template target<Functor>())
+return g.get_pointer() != fp;
+else return true;
+}
+#endif // Compiler supporting SFINAE
+namespace detail {
+namespace function {
+inline bool has_empty_target(const function_base* f)
+{
+return f->empty();
+}
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
+inline bool has_empty_target(const void*)
+{
+return false;
+}
+#else
+inline bool has_empty_target(...)
+{
+return false;
+}
+#endif
+} // end namespace function
+} // end namespace detail
+} // end namespace boost
+#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
+#undef BOOST_FUNCTION_COMPARE_TYPE_ID
+#endif // BOOST_FUNCTION_BASE_HEADER