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

Go to the documentation of this file.

//
// stream.hpp
// ~~~~~~~~~~
//
// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
// Copyright (c) 2005 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_SSL_STREAM_HPP
#define ASIO_SSL_STREAM_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 <boost/config.hpp>
#include <boost/noncopyable.hpp>
#include <boost/type_traits.hpp>
#include "asio/detail/pop_options.hpp"

#include "asio/error.hpp"
#include "asio/ssl/basic_context.hpp"
#include "asio/ssl/stream_base.hpp"
#include "asio/ssl/stream_service.hpp"
#include "asio/detail/throw_error.hpp"

namespace asio {
namespace ssl {


template <typename Stream, typename Service = stream_service>
class stream
  : public stream_base,
    private boost::noncopyable
{
public:
  typedef typename boost::remove_reference<Stream>::type next_layer_type;

  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;

  typedef Service service_type;

  typedef typename service_type::impl_type impl_type;


  template <typename Arg, typename Context_Service>
  explicit stream(Arg& arg, basic_context<Context_Service>& context)
    : next_layer_(arg),
      service_(asio::use_service<Service>(next_layer_.io_service())),
      impl_(service_.null())
  {
    service_.create(impl_, next_layer_, context);
  }

  ~stream()
  {
    service_.destroy(impl_, next_layer_);
  }


  asio::io_service& io_service()
  {
    return next_layer_.io_service();
  }


  next_layer_type& next_layer()
  {
    return next_layer_;
  }


  lowest_layer_type& lowest_layer()
  {
    return next_layer_.lowest_layer();
  }


  impl_type impl()
  {
    return impl_;
  }


  void handshake(handshake_type type)
  {
    asio::error_code ec;
    service_.handshake(impl_, next_layer_, type, ec);
    asio::detail::throw_error(ec);
  }


  asio::error_code handshake(handshake_type type,
      asio::error_code& ec)
  {
    return service_.handshake(impl_, next_layer_, type, ec);
  }


  template <typename HandshakeHandler>
  void async_handshake(handshake_type type, HandshakeHandler handler)
  {
    service_.async_handshake(impl_, next_layer_, type, handler);
  }


  void shutdown()
  {
    asio::error_code ec;
    service_.shutdown(impl_, next_layer_, ec);
    asio::detail::throw_error(ec);
  }


  asio::error_code shutdown(asio::error_code& ec)
  {
    return service_.shutdown(impl_, next_layer_, ec);
  }


  template <typename ShutdownHandler>
  void async_shutdown(ShutdownHandler handler)
  {
    service_.async_shutdown(impl_, next_layer_, handler);
  }


  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers)
  {
    asio::error_code ec;
    std::size_t s = service_.write_some(impl_, next_layer_, buffers, ec);
    asio::detail::throw_error(ec);
    return s;
  }


  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers,
      asio::error_code& ec)
  {
    return service_.write_some(impl_, next_layer_, buffers, ec);
  }


  template <typename ConstBufferSequence, typename WriteHandler>
  void async_write_some(const ConstBufferSequence& buffers,
      WriteHandler handler)
  {
    service_.async_write_some(impl_, next_layer_, buffers, handler);
  }


  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers)
  {
    asio::error_code ec;
    std::size_t s = service_.read_some(impl_, next_layer_, buffers, ec);
    asio::detail::throw_error(ec);
    return s;
  }


  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers,
      asio::error_code& ec)
  {
    return service_.read_some(impl_, next_layer_, buffers, ec);
  }


  template <typename MutableBufferSequence, typename ReadHandler>
  void async_read_some(const MutableBufferSequence& buffers,
      ReadHandler handler)
  {
    service_.async_read_some(impl_, next_layer_, buffers, handler);
  }


  template <typename MutableBufferSequence>
  std::size_t peek(const MutableBufferSequence& buffers)
  {
    asio::error_code ec;
    std::size_t s = service_.peek(impl_, next_layer_, buffers, ec);
    asio::detail::throw_error(ec);
    return s;
  }


  template <typename MutableBufferSequence>
  std::size_t peek(const MutableBufferSequence& buffers,
      asio::error_code& ec)
  {
    return service_.peek(impl_, next_layer_, buffers, ec);
  }


  std::size_t in_avail()
  {
    asio::error_code ec;
    std::size_t s = service_.in_avail(impl_, next_layer_, ec);
    asio::detail::throw_error(ec);
    return s;
  }


  std::size_t in_avail(asio::error_code& ec)
  {
    return service_.in_avail(impl_, next_layer_, ec);
  }

private:
  Stream next_layer_;

  service_type& service_;

  impl_type impl_;
};

} // namespace ssl
} // namespace asio

#include "asio/detail/pop_options.hpp"

#endif // ASIO_SSL_STREAM_HPP

---