[Boost-commit] svn:boost r52781 - sandbox/boost0x/boost/function

Subject: [Boost-commit] svn:boost r52781 - sandbox/boost0x/boost/function
From: sebastian.redl_at_[hidden]
Date: 2009-05-05 19:06:55

Author: cornedbee
Date: 2009-05-05 19:06:54 EDT (Tue, 05 May 2009)
New Revision: 52781
URL: http://svn.boost.org/trac/boost/changeset/52781

Log:
Complete variadic function
Text files modified: 
   sandbox/boost0x/boost/function/function_variadic.hpp |   259 ++++++++++++++++++++++++++++++++++++++- 
   1 files changed, 251 insertions(+), 8 deletions(-)

Modified: sandbox/boost0x/boost/function/function_variadic.hpp
==============================================================================
--- sandbox/boost0x/boost/function/function_variadic.hpp	(original)
+++ sandbox/boost0x/boost/function/function_variadic.hpp	2009-05-05 19:06:54 EDT (Tue, 05 May 2009)
@@ -8,7 +8,12 @@
 
 // For more information, see http://www.boost.org
 
+#ifndef BOOST_FUNCTION_FUNCTION_VARIADIC_HPP
+#define BOOST_FUNCTION_FUNCTION_VARIADIC_HPP
+
 #include <boost/function/detail/prologue.hpp>
+#include <boost/function/function_variadic_invoker.hpp>
+#include <boost/function/function_variadic_vtable.hpp>
 
 namespace boost
 {
@@ -37,11 +42,30 @@
     class function<R (Args...)> : public function_base,
         public detail::function::which_std_function<R, Args...>::type
     {
-        typedef function_base base_type;
         typedef function<R (Args...)> self_type;
         struct clear_type {};
 
+        typedef boost::detail::function::basic_vtable<R, Args...>
+            vtable_type;
+
+        vtable_type* get_vtable() const {
+            return reinterpret_cast<vtable_type*>(
+                reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
+        }
+
     public:
+        typedef R result_type;
+
+        BOOST_STATIC_CONSTANT(int, args = sizeof...(Args));
+        BOOST_STATIC_CONSTANT(int, arity = sizeof...(Args));
+
+        // add signature for boost::lambda
+        template<typename Args>
+        struct sig
+        {
+            typedef result_type type;
+        };
+        // Note: argN_type typedefs are gone
 
         function() : base_type() {}
 
@@ -52,8 +76,9 @@
                               (is_integral<Functor>::value)>::value),
                            int>::type = 0
                ) :
-        base_type(f)
+            function_base()
         {
+            this->assign_to(f);
         }
         template<typename Functor, typename Allocator>
         function(Functor f, Allocator a
@@ -62,19 +87,33 @@
                               (is_integral<Functor>::value)>::value),
                            int>::type = 0
                ) :
-        base_type(f,a)
+            function_base()
         {
+            this->assign_to_a(f, a);
         }
 
-        function(clear_type*) : base_type() {}
+        function(clear_type*) : function_base() {}
 
         function(const self_type& f)
-            : base_type(static_cast<const base_type&>(f))
-        {}
+            : function_base()
+        {
+            this->assign_to_own(f);
+        }
+
+        ~function() { clear(); }
 
         self_type& operator=(const self_type& f)
         {
-            self_type(f).swap(*this);
+            if (&f == this)
+                return *this;
+
+            this->clear();
+            try {
+                this->assign_to_own(f);
+            } catch (...) {
+                vtable = 0;
+                throw;
+            }
             return *this;
         }
 
@@ -85,7 +124,30 @@
                           self_type&>::type
         operator=(Functor f)
         {
-            self_type(f).swap(*this);
+            this->clear();
+            try {
+                this->assign_to(f);
+            } catch (...) {
+                vtable = 0;
+                throw;
+            }
+            return *this;
+        }
+
+        template<typename Functor>
+        typename enable_if_c<
+                                (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                          self_type&>::type
+        operator=(Functor f, Allocator a)
+        {
+            this->clear();
+            try {
+                this->assign_to_a(f, a);
+            } catch (...) {
+                vtable = 0;
+                throw;
+            }
             return *this;
         }
 
@@ -94,5 +156,186 @@
             this->clear();
             return *this;
         }
+
+
+        void swap(self_type& other)
+        {
+            if (&other == this)
+                return;
+
+            self_type tmp;
+            tmp.move_assign(*this);
+            this->move_assign(other);
+            other.move_assign(tmp);
+        }
+
+        // Clear out a target, if there is one
+        void clear()
+        {
+            if (vtable) {
+                if (!this->has_trivial_copy_and_destroy())
+                    get_vtable()->clear(this->functor);
+                vtable = 0;
+            }
+        }
+
+    private:
+        struct dummy {
+            void nonnull() {};
+        };
+
+    typedef void (dummy::*safe_bool)();
+
+    public:
+        operator safe_bool () const
+        { return (this->empty())? 0 : &dummy::nonnull; }
+
+        bool operator!() const
+        { return this->empty(); }
+
+        result_type operator()(Args... args) const;
+
+    private:
+        void assign_to_own(const self_type& f)
+        {
+            if (!f.empty()) {
+                this->vtable = f.vtable;
+                if (this->has_trivial_copy_and_destroy())
+                    this->functor = f.functor;
+                else
+                    get_vtable()->base.manager(f.functor, this->functor,
+                        boost::detail::function::clone_functor_tag);
+            }
+        }
+
+        template<typename Functor>
+        void assign_to(Functor f)
+        {
+            using detail::function::vtable_base;
+
+            typedef typename
+                detail::function::get_function_tag<Functor>::type tag;
+            typedef detail::function::get_invoker<tag> get_invoker;
+            typedef typename
+                get_invoker::template apply<Functor, R, Args...>
+                handler_type;
+
+            typedef typename handler_type::invoker_type invoker_type;
+            typedef typename handler_type::manager_type manager_type;
+
+            // Note: it is extremely important that this initialization use
+            // static initialization. Otherwise, we will have a race
+            // condition here in multi-threaded code. See
+            // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
+            static vtable_type stored_vtable = 
+                { { &manager_type::manage }, &invoker_type::invoke };
+
+            if (stored_vtable.assign_to(f, functor)) {
+                std::size_t value = reinterpret_cast<std::size_t>(
+                    &stored_vtable.base);
+                if (boost::has_trivial_copy_constructor<Functor>::value &&
+                    boost::has_trivial_destructor<Functor>::value &&
+                    detail::function::
+                        function_allows_small_object_optimization<Functor>::
+                        value)
+                    value |= (std::size_t)0x01;
+                vtable = reinterpret_cast<detail::function::vtable_base *>(
+                    value);
+            } else
+                vtable = 0;
+        }
+
+        template<typename Functor, typename Allocator>
+        void assign_to_a(Functor f, Allocator a)
+        {
+            using detail::function::vtable_base;
+
+            typedef typename
+                detail::function::get_function_tag<Functor>::type tag;
+            typedef detail::function::get_invoker<tag> get_invoker;
+            typedef typename get_invoker::
+                template apply_a<Functor, Allocator, R, Args...>
+                handler_type;
+
+            typedef typename handler_type::invoker_type invoker_type;
+            typedef typename handler_type::manager_type manager_type;
+
+            // Note: it is extremely important that this initialization use
+            // static initialization. Otherwise, we will have a race
+            // condition here in multi-threaded code. See
+            // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
+            static vtable_type stored_vtable = 
+                { { &manager_type::manage }, &invoker_type::invoke };
+
+            if (stored_vtable.assign_to_a(f, functor, a)) {
+                std::size_t value = reinterpret_cast<std::size_t>(
+                    &stored_vtable.base);
+                if (boost::has_trivial_copy_constructor<Functor>::value &&
+                    boost::has_trivial_destructor<Functor>::value &&
+                    detail::function::
+                        function_allows_small_object_optimization<Functor>::
+                        value)
+                    value |= (std::size_t)0x01;
+                vtable = reinterpret_cast<detail::function::vtable_base *>(
+                    value);
+            } else
+                vtable = 0;
+        }
+
+        // Moves the value from the specified argument to *this. If the
+        // argument has its function object allocated on the heap,
+        // move_assign will pass its buffer to *this, and set the
+        // argument's buffer pointer to NULL.
+        void move_assign(BOOST_FUNCTION_FUNCTION& f)
+        {
+            if (&f == this)
+                return;
+
+#if !defined(BOOST_NO_EXCEPTIONS)      
+            try {
+#endif
+                if (!f.empty()) {
+                    this->vtable = f.vtable;
+                    if (this->has_trivial_copy_and_destroy())
+                        this->functor = f.functor;
+                    else
+                        get_vtable()->base.manager(f.functor,
+                            this->functor,
+                            boost::detail::function::move_functor_tag);
+                    f.vtable = 0;
+                } else {
+                    clear();
+                }
+#if !defined(BOOST_NO_EXCEPTIONS)      
+            } catch (...) {
+                vtable = 0;
+                throw;
+            }
+#endif
+        }
     };
+
+    template<typename Signature>
+    inline void swap(function<Signature>& f1, function<Signature>& f2)
+    {
+        f1.swap(f2);
+    }
+
+    template<typename R, typename... Args>
+    inline R
+    function<R, Args...>::operator()(Args ...args) const
+    {
+        if (this->empty())
+            boost::throw_exception(bad_function_call());
+
+        return get_vtable()->invoker(this->functor, args...);
+    }
+
+    // Poison comparisons between boost::function objects of the same type.
+    template<typename Signature>
+    void operator==(const function<Signature>&, const function<Signature>&);
+    template<typename Signature>
+    void operator!=(const function<Signature>&, const function<Signature>&);
 }
+
+#endif