Import.

author: Remko Tronçon <git@el-tramo.be> 2009-06-01 08:48:42 (GMT)
committer: Remko Tronçon <git@el-tramo.be> 2009-06-01 09:24:28 (GMT)
commit: 2812bddd81f8a1b804c7460f4e14cd0aa393d129 (patch)
tree: d46294f35150c4f0f43deaf2d31fceaf945ae715 /3rdParty/Boost/boost/asio/detail/strand_service.hpp
download: swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.zip
swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.tar.bz2
1 files changed, 532 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/asio/detail/strand_service.hpp b/3rdParty/Boost/boost/asio/detail/strand_service.hpp
new file mode 100644
index 0000000..2c89a61
--- /dev/null
+++ b/3rdParty/Boost/boost/asio/detail/strand_service.hpp
@@ -0,0 +1,532 @@
+//
+// strand_service.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot 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)
+//
+
+#ifndef BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/aligned_storage.hpp>
+#include <boost/assert.hpp>
+#include <boost/detail/atomic_count.hpp>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/call_stack.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/service_base.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Default service implementation for a strand.
+class strand_service
+  : public boost::asio::detail::service_base<strand_service>
+{
+public:
+  class handler_base;
+  class invoke_current_handler;
+  class post_next_waiter_on_exit;
+
+  // The underlying implementation of a strand.
+  class strand_impl
+  {
+#if defined (__BORLANDC__)
+  public:
+#else
+  private:
+#endif
+    void add_ref()
+    {
+      ++ref_count_;
+    }
+
+    void release()
+    {
+      if (--ref_count_ == 0)
+        delete this;
+    }
+
+  private:
+    // Only this service will have access to the internal values.
+    friend class strand_service;
+    friend class post_next_waiter_on_exit;
+    friend class invoke_current_handler;
+
+    strand_impl(strand_service& owner)
+      : owner_(owner),
+        current_handler_(0),
+        first_waiter_(0),
+        last_waiter_(0),
+        ref_count_(0)
+    {
+      // Insert implementation into linked list of all implementations.
+      boost::asio::detail::mutex::scoped_lock lock(owner_.mutex_);
+      next_ = owner_.impl_list_;
+      prev_ = 0;
+      if (owner_.impl_list_)
+        owner_.impl_list_->prev_ = this;
+      owner_.impl_list_ = this;
+    }
+
+    ~strand_impl()
+    {
+      // Remove implementation from linked list of all implementations.
+      boost::asio::detail::mutex::scoped_lock lock(owner_.mutex_);
+      if (owner_.impl_list_ == this)
+        owner_.impl_list_ = next_;
+      if (prev_)
+        prev_->next_ = next_;
+      if (next_)
+        next_->prev_= prev_;
+      next_ = 0;
+      prev_ = 0;
+      lock.unlock();
+
+      if (current_handler_)
+      {
+        current_handler_->destroy();
+      }
+
+      while (first_waiter_)
+      {
+        handler_base* next = first_waiter_->next_;
+        first_waiter_->destroy();
+        first_waiter_ = next;
+      }
+    }
+
+    // Mutex to protect access to internal data.
+    boost::asio::detail::mutex mutex_;
+
+    // The service that owns this implementation.
+    strand_service& owner_;
+
+    // The handler that is ready to execute. If this pointer is non-null then it
+    // indicates that a handler holds the lock.
+    handler_base* current_handler_;
+
+    // The start of the list of waiting handlers for the strand.
+    handler_base* first_waiter_;
+    
+    // The end of the list of waiting handlers for the strand.
+    handler_base* last_waiter_;
+
+    // Storage for posted handlers.
+    typedef boost::aligned_storage<128> handler_storage_type;
+#if defined(__BORLANDC__)
+    boost::aligned_storage<128> handler_storage_;
+#else
+    handler_storage_type handler_storage_;
+#endif
+
+    // Pointers to adjacent socket implementations in linked list.
+    strand_impl* next_;
+    strand_impl* prev_;
+
+    // The reference count on the strand implementation.
+    boost::detail::atomic_count ref_count_;
+
+#if !defined(__BORLANDC__)
+    friend void intrusive_ptr_add_ref(strand_impl* p)
+    {
+      p->add_ref();
+    }
+
+    friend void intrusive_ptr_release(strand_impl* p)
+    {
+      p->release();
+    }
+#endif
+  };
+
+  friend class strand_impl;
+
+  typedef boost::intrusive_ptr<strand_impl> implementation_type;
+
+  // Base class for all handler types.
+  class handler_base
+  {
+  public:
+    typedef void (*invoke_func_type)(handler_base*,
+        strand_service&, implementation_type&);
+    typedef void (*destroy_func_type)(handler_base*);
+
+    handler_base(invoke_func_type invoke_func, destroy_func_type destroy_func)
+      : next_(0),
+        invoke_func_(invoke_func),
+        destroy_func_(destroy_func)
+    {
+    }
+
+    void invoke(strand_service& service_impl, implementation_type& impl)
+    {
+      invoke_func_(this, service_impl, impl);
+    }
+
+    void destroy()
+    {
+      destroy_func_(this);
+    }
+
+  protected:
+    ~handler_base()
+    {
+    }
+
+  private:
+    friend class strand_service;
+    friend class strand_impl;
+    friend class post_next_waiter_on_exit;
+    handler_base* next_;
+    invoke_func_type invoke_func_;
+    destroy_func_type destroy_func_;
+  };
+
+  // Helper class to allow handlers to be dispatched.
+  class invoke_current_handler
+  {
+  public:
+    invoke_current_handler(strand_service& service_impl,
+        const implementation_type& impl)
+      : service_impl_(service_impl),
+        impl_(impl)
+    {
+    }
+
+    void operator()()
+    {
+      impl_->current_handler_->invoke(service_impl_, impl_);
+    }
+
+    friend void* asio_handler_allocate(std::size_t size,
+        invoke_current_handler* this_handler)
+    {
+      return this_handler->do_handler_allocate(size);
+    }
+
+    friend void asio_handler_deallocate(void*, std::size_t,
+        invoke_current_handler*)
+    {
+    }
+
+    void* do_handler_allocate(std::size_t size)
+    {
+#if defined(__BORLANDC__)
+      BOOST_ASSERT(size <= boost::aligned_storage<128>::size);
+#else
+      BOOST_ASSERT(size <= strand_impl::handler_storage_type::size);
+#endif
+      (void)size;
+      return impl_->handler_storage_.address();
+    }
+
+    // The asio_handler_invoke hook is not defined here since the default one
+    // provides the correct behaviour, and including it here breaks MSVC 7.1
+    // in some situations.
+
+  private:
+    strand_service& service_impl_;
+    implementation_type impl_;
+  };
+
+  // Helper class to automatically enqueue next waiter on block exit.
+  class post_next_waiter_on_exit
+  {
+  public:
+    post_next_waiter_on_exit(strand_service& service_impl,
+        implementation_type& impl)
+      : service_impl_(service_impl),
+        impl_(impl),
+        cancelled_(false)
+    {
+    }
+
+    ~post_next_waiter_on_exit()
+    {
+      if (!cancelled_)
+      {
+        boost::asio::detail::mutex::scoped_lock lock(impl_->mutex_);
+        impl_->current_handler_ = impl_->first_waiter_;
+        if (impl_->current_handler_)
+        {
+          impl_->first_waiter_ = impl_->first_waiter_->next_;
+          if (impl_->first_waiter_ == 0)
+            impl_->last_waiter_ = 0;
+          lock.unlock();
+          service_impl_.get_io_service().post(
+              invoke_current_handler(service_impl_, impl_));
+        }
+      }
+    }
+
+    void cancel()
+    {
+      cancelled_ = true;
+    }
+
+  private:
+    strand_service& service_impl_;
+    implementation_type& impl_;
+    bool cancelled_;
+  };
+
+  // Class template for a waiter.
+  template <typename Handler>
+  class handler_wrapper
+    : public handler_base
+  {
+  public:
+    handler_wrapper(Handler handler)
+      : handler_base(&handler_wrapper<Handler>::do_invoke,
+          &handler_wrapper<Handler>::do_destroy),
+        handler_(handler)
+    {
+    }
+
+    static void do_invoke(handler_base* base,
+        strand_service& service_impl, implementation_type& impl)
+    {
+      // Take ownership of the handler object.
+      typedef handler_wrapper<Handler> this_type;
+      this_type* h(static_cast<this_type*>(base));
+      typedef handler_alloc_traits<Handler, this_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(h->handler_, h);
+
+      post_next_waiter_on_exit p1(service_impl, impl);
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(h->handler_);
+
+      // A handler object must still be valid when the next waiter is posted
+      // since destroying the last handler might cause the strand object to be
+      // destroyed. Therefore we create a second post_next_waiter_on_exit object
+      // that will be destroyed before the handler object.
+      p1.cancel();
+      post_next_waiter_on_exit p2(service_impl, impl);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Indicate that this strand is executing on the current thread.
+      call_stack<strand_impl>::context ctx(impl.get());
+
+      // Make the upcall.
+      boost_asio_handler_invoke_helpers::invoke(handler, &handler);
+    }
+
+    static void do_destroy(handler_base* base)
+    {
+      // Take ownership of the handler object.
+      typedef handler_wrapper<Handler> this_type;
+      this_type* h(static_cast<this_type*>(base));
+      typedef handler_alloc_traits<Handler, this_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(h->handler_, h);
+
+      // A sub-object of the handler may be the true owner of the memory
+      // associated with the handler. Consequently, a local copy of the handler
+      // is required to ensure that any owning sub-object remains valid until
+      // after we have deallocated the memory here.
+      Handler handler(h->handler_);
+      (void)handler;
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+    }
+
+  private:
+    Handler handler_;
+  };
+
+  // Construct a new strand service for the specified io_service.
+  explicit strand_service(boost::asio::io_service& io_service)
+    : boost::asio::detail::service_base<strand_service>(io_service),
+      mutex_(),
+      impl_list_(0)
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    // Construct a list of all handlers to be destroyed.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    strand_impl* impl = impl_list_;
+    handler_base* first_handler = 0;
+    while (impl)
+    {
+      if (impl->current_handler_)
+      {
+        impl->current_handler_->next_ = first_handler;
+        first_handler = impl->current_handler_;
+        impl->current_handler_ = 0;
+      }
+      if (impl->first_waiter_)
+      {
+        impl->last_waiter_->next_ = first_handler;
+        first_handler = impl->first_waiter_;
+        impl->first_waiter_ = 0;
+        impl->last_waiter_ = 0;
+      }
+      impl = impl->next_;
+    }
+
+    // Destroy all handlers without holding the lock.
+    lock.unlock();
+    while (first_handler)
+    {
+      handler_base* next = first_handler->next_;
+      first_handler->destroy();
+      first_handler = next;
+    }
+  }
+
+  // Construct a new strand implementation.
+  void construct(implementation_type& impl)
+  {
+    impl = implementation_type(new strand_impl(*this));
+  }
+
+  // Destroy a strand implementation.
+  void destroy(implementation_type& impl)
+  {
+    implementation_type().swap(impl);
+  }
+
+  // Request the io_service to invoke the given handler.
+  template <typename Handler>
+  void dispatch(implementation_type& impl, Handler handler)
+  {
+    if (call_stack<strand_impl>::contains(impl.get()))
+    {
+      boost_asio_handler_invoke_helpers::invoke(handler, &handler);
+    }
+    else
+    {
+      // Allocate and construct an object to wrap the handler.
+      typedef handler_wrapper<Handler> value_type;
+      typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+      raw_handler_ptr<alloc_traits> raw_ptr(handler);
+      handler_ptr<alloc_traits> ptr(raw_ptr, handler);
+
+      boost::asio::detail::mutex::scoped_lock lock(impl->mutex_);
+
+      if (impl->current_handler_ == 0)
+      {
+        // This handler now has the lock, so can be dispatched immediately.
+        impl->current_handler_ = ptr.release();
+        lock.unlock();
+        this->get_io_service().dispatch(invoke_current_handler(*this, impl));
+      }
+      else
+      {
+        // Another handler already holds the lock, so this handler must join
+        // the list of waiters. The handler will be posted automatically when
+        // its turn comes.
+        if (impl->last_waiter_)
+        {
+          impl->last_waiter_->next_ = ptr.get();
+          impl->last_waiter_ = impl->last_waiter_->next_;
+        }
+        else
+        {
+          impl->first_waiter_ = ptr.get();
+          impl->last_waiter_ = ptr.get();
+        }
+        ptr.release();
+      }
+    }
+  }
+
+  // Request the io_service to invoke the given handler and return immediately.
+  template <typename Handler>
+  void post(implementation_type& impl, Handler handler)
+  {
+    // Allocate and construct an object to wrap the handler.
+    typedef handler_wrapper<Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr, handler);
+
+    boost::asio::detail::mutex::scoped_lock lock(impl->mutex_);
+
+    if (impl->current_handler_ == 0)
+    {
+      // This handler now has the lock, so can be dispatched immediately.
+      impl->current_handler_ = ptr.release();
+      lock.unlock();
+      this->get_io_service().post(invoke_current_handler(*this, impl));
+    }
+    else
+    {
+      // Another handler already holds the lock, so this handler must join the
+      // list of waiters. The handler will be posted automatically when its turn
+      // comes.
+      if (impl->last_waiter_)
+      {
+        impl->last_waiter_->next_ = ptr.get();
+        impl->last_waiter_ = impl->last_waiter_->next_;
+      }
+      else
+      {
+        impl->first_waiter_ = ptr.get();
+        impl->last_waiter_ = ptr.get();
+      }
+      ptr.release();
+    }
+  }
+
+private:
+  // Mutex to protect access to the linked list of implementations. 
+  boost::asio::detail::mutex mutex_;
+
+  // The head of a linked list of all implementations.
+  strand_impl* impl_list_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#if defined(__BORLANDC__)
+
+namespace boost {
+
+inline void intrusive_ptr_add_ref(
+    boost::asio::detail::strand_service::strand_impl* p)
+{
+  p->add_ref();
+}
+
+inline void intrusive_ptr_release(
+    boost::asio::detail::strand_service::strand_impl* p)
+{
+  p->release();
+}
+
+} // namespace boost
+
+#endif // defined(__BORLANDC__)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
author	Remko Tronçon <git@el-tramo.be>	2009-06-01 08:48:42 (GMT)
committer	Remko Tronçon <git@el-tramo.be>	2009-06-01 09:24:28 (GMT)
commit	2812bddd81f8a1b804c7460f4e14cd0aa393d129 (patch)
tree	d46294f35150c4f0f43deaf2d31fceaf945ae715 /3rdParty/Boost/boost/asio/detail/strand_service.hpp
download	swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.zip swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.tar.bz2