basic_deadline_timer.hpp

Go to the documentation of this file.

//
// basic_deadline_timer.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 ASIO_BASIC_DEADLINE_TIMER_HPP
#define ASIO_BASIC_DEADLINE_TIMER_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 "asio/detail/pop_options.hpp"

#include "asio/basic_io_object.hpp"
#include "asio/deadline_timer_service.hpp"
#include "asio/error.hpp"
#include "asio/detail/throw_error.hpp"

namespace asio {


template <typename Time,
    typename TimeTraits = asio::time_traits<Time>,
    typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_deadline_timer
  : public basic_io_object<TimerService>
{
public:
  typedef TimeTraits traits_type;

  typedef typename traits_type::time_type time_type;

  typedef typename traits_type::duration_type duration_type;


  explicit basic_deadline_timer(asio::io_service& io_service)
    : basic_io_object<TimerService>(io_service)
  {
  }


  basic_deadline_timer(asio::io_service& io_service,
      const time_type& expiry_time)
    : basic_io_object<TimerService>(io_service)
  {
    asio::error_code ec;
    this->service.expires_at(this->implementation, expiry_time, ec);
    asio::detail::throw_error(ec);
  }


  basic_deadline_timer(asio::io_service& io_service,
      const duration_type& expiry_time)
    : basic_io_object<TimerService>(io_service)
  {
    asio::error_code ec;
    this->service.expires_from_now(this->implementation, expiry_time, ec);
    asio::detail::throw_error(ec);
  }


  std::size_t cancel()
  {
    asio::error_code ec;
    std::size_t s = this->service.cancel(this->implementation, ec);
    asio::detail::throw_error(ec);
    return s;
  }


  std::size_t cancel(asio::error_code& ec)
  {
    return this->service.cancel(this->implementation, ec);
  }


  time_type expires_at() const
  {
    return this->service.expires_at(this->implementation);
  }


  std::size_t expires_at(const time_type& expiry_time)
  {
    asio::error_code ec;
    std::size_t s = this->service.expires_at(
        this->implementation, expiry_time, ec);
    asio::detail::throw_error(ec);
    return s;
  }


  std::size_t expires_at(const time_type& expiry_time,
      asio::error_code& ec)
  {
    return this->service.expires_at(this->implementation, expiry_time, ec);
  }


  duration_type expires_from_now() const
  {
    return this->service.expires_from_now(this->implementation);
  }


  std::size_t expires_from_now(const duration_type& expiry_time)
  {
    asio::error_code ec;
    std::size_t s = this->service.expires_from_now(
        this->implementation, expiry_time, ec);
    asio::detail::throw_error(ec);
    return s;
  }


  std::size_t expires_from_now(const duration_type& expiry_time,
      asio::error_code& ec)
  {
    return this->service.expires_from_now(
        this->implementation, expiry_time, ec);
  }


  void wait()
  {
    asio::error_code ec;
    this->service.wait(this->implementation, ec);
    asio::detail::throw_error(ec);
  }


  void wait(asio::error_code& ec)
  {
    this->service.wait(this->implementation, ec);
  }


  template <typename WaitHandler>
  void async_wait(WaitHandler handler)
  {
    this->service.async_wait(this->implementation, handler);
  }
};

} // namespace asio

#include "asio/detail/pop_options.hpp"

#endif // ASIO_BASIC_DEADLINE_TIMER_HPP