D:/opendownloadmanager/ODM-1.x/Bittorrent/libtorrent-0.12/include/libtorrent/asio/io_service.hpp

Go to the documentation of this file.

//
// io_service.hpp
// ~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2007 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 ASIO_IO_SERVICE_HPP
#define ASIO_IO_SERVICE_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include "asio/detail/push_options.hpp"

#include "asio/detail/push_options.hpp"
#include <cstddef>
#include <stdexcept>
#include <typeinfo>
#include <boost/config.hpp>
#include <boost/throw_exception.hpp>
#include "asio/detail/pop_options.hpp"

#include "asio/error_code.hpp"
#include "asio/detail/epoll_reactor_fwd.hpp"
#include "asio/detail/kqueue_reactor_fwd.hpp"
#include "asio/detail/noncopyable.hpp"
#include "asio/detail/select_reactor_fwd.hpp"
#include "asio/detail/service_registry_fwd.hpp"
#include "asio/detail/signal_init.hpp"
#include "asio/detail/task_io_service_fwd.hpp"
#include "asio/detail/win_iocp_io_service_fwd.hpp"
#include "asio/detail/winsock_init.hpp"
#include "asio/detail/wrapped_handler.hpp"

namespace asio {


class io_service
  : private noncopyable
{
private:
  // The type of the platform-specific implementation.
#if defined(ASIO_HAS_IOCP)
  typedef detail::win_iocp_io_service impl_type;
#elif defined(ASIO_HAS_EPOLL)
  typedef detail::task_io_service<detail::epoll_reactor<false> > impl_type;
#elif defined(ASIO_HAS_KQUEUE)
  typedef detail::task_io_service<detail::kqueue_reactor<false> > impl_type;
#else
  typedef detail::task_io_service<detail::select_reactor<false> > impl_type;
#endif

public:
  class work;
  friend class work;

  class id;

  class service;

  class strand;

  io_service();


  explicit io_service(std::size_t concurrency_hint);

  ~io_service();


  std::size_t run();


  std::size_t run(asio::error_code& ec);


  std::size_t run_one();


  std::size_t run_one(asio::error_code& ec);


  std::size_t poll();


  std::size_t poll(asio::error_code& ec);


  std::size_t poll_one();


  std::size_t poll_one(asio::error_code& ec);


  void stop();


  void reset();


  template <typename CompletionHandler>
  void dispatch(CompletionHandler handler);


  template <typename CompletionHandler>
  void post(CompletionHandler handler);


  template <typename Handler>
#if defined(GENERATING_DOCUMENTATION)
  unspecified
#else
  detail::wrapped_handler<io_service, Handler>
#endif
  wrap(Handler handler);


  template <typename Service>
  friend Service& use_service(io_service& ios);


  template <typename Service>
  friend void add_service(io_service& ios, Service* svc);


  template <typename Service>
  friend bool has_service(io_service& ios);

private:
#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
  detail::winsock_init<> init_;
#elif defined(__sun) || defined(__QNX__)
  detail::signal_init<> init_;
#endif

  // The service registry.
  asio::detail::service_registry* service_registry_;

  // The implementation.
  impl_type& impl_;
};


class io_service::work
{
public:

  explicit work(asio::io_service& io_service);


  work(const work& other);


  ~work();

  asio::io_service& io_service();

private:
  // Prevent assignment.
  void operator=(const work& other);

  // The io_service.
  asio::io_service& io_service_;
};

class io_service::id
  : private noncopyable
{
public:
  id() {}
};

class io_service::service
  : private noncopyable
{
public:
  asio::io_service& io_service();

protected:

  service(asio::io_service& owner);

  virtual ~service();

private:
  virtual void shutdown_service() = 0;

  friend class asio::detail::service_registry;
  asio::io_service& owner_;
  const std::type_info* type_info_;
  const asio::io_service::id* id_;
  service* next_;
};

class service_already_exists
  : public std::logic_error
{
public:
  service_already_exists()
    : std::logic_error("Service already exists.")
  {
  }
};

class invalid_service_owner
  : public std::logic_error
{
public:
  invalid_service_owner()
    : std::logic_error("Invalid service owner.")
  {
  }
};

} // namespace asio

#include "asio/impl/io_service.ipp"

#include "asio/detail/pop_options.hpp"

#endif // ASIO_IO_SERVICE_HPP

---