basic_waitable_timer.hpp

Go to the documentation of this file.

//
// basic_waitable_timer.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2015 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_WAITABLE_TIMER_HPP
#define ASIO_BASIC_WAITABLE_TIMER_HPP

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

#include "asio/detail/config.hpp"
#include <cstddef>
#include "asio/basic_io_object.hpp"
#include "asio/detail/handler_type_requirements.hpp"
#include "asio/detail/throw_error.hpp"
#include "asio/error.hpp"
#include "asio/wait_traits.hpp"
#include "asio/waitable_timer_service.hpp"

#include "asio/detail/push_options.hpp"

namespace asio {


template <typename Clock,
    typename WaitTraits = asio::wait_traits<Clock>,
    typename WaitableTimerService = waitable_timer_service<Clock, WaitTraits> >
class basic_waitable_timer
  : public basic_io_object<WaitableTimerService>
{
public:
  typedef Clock clock_type;

  typedef typename clock_type::duration duration;

  typedef typename clock_type::time_point time_point;

  typedef WaitTraits traits_type;


  explicit basic_waitable_timer(asio::io_service& io_service)
    : basic_io_object<WaitableTimerService>(io_service)
  {
  }


  basic_waitable_timer(asio::io_service& io_service,
      const time_point& expiry_time)
    : basic_io_object<WaitableTimerService>(io_service)
  {
    asio::error_code ec;
    this->service.expires_at(this->implementation, expiry_time, ec);
    asio::detail::throw_error(ec, "expires_at");
  }


  basic_waitable_timer(asio::io_service& io_service,
      const duration& expiry_time)
    : basic_io_object<WaitableTimerService>(io_service)
  {
    asio::error_code ec;
    this->service.expires_from_now(this->implementation, expiry_time, ec);
    asio::detail::throw_error(ec, "expires_from_now");
  }


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


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


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


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


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


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


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


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


  std::size_t expires_from_now(const duration& 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, "expires_from_now");
    return s;
  }


  std::size_t expires_from_now(const duration& 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, "wait");
  }


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


  template <typename WaitHandler>
  ASIO_INITFN_RESULT_TYPE(WaitHandler,
      void (asio::error_code))
  async_wait(ASIO_MOVE_ARG(WaitHandler) handler)
  {
    // If you get an error on the following line it means that your handler does
    // not meet the documented type requirements for a WaitHandler.
    ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;

    return this->service.async_wait(this->implementation,
        ASIO_MOVE_CAST(WaitHandler)(handler));
  }
};

} // namespace asio

#include "asio/detail/pop_options.hpp"

#endif // ASIO_BASIC_WAITABLE_TIMER_HPP