basic_deadline_timer.hpp

Go to the documentation of this file.

//
// basic_deadline_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_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/config.hpp"

#if defined(ASIO_HAS_BOOST_DATE_TIME) \
  || defined(GENERATING_DOCUMENTATION)

#include <cstddef>
#include "asio/basic_io_object.hpp"
#include "asio/deadline_timer_service.hpp"
#include "asio/detail/handler_type_requirements.hpp"
#include "asio/detail/throw_error.hpp"
#include "asio/error.hpp"

#include "asio/detail/push_options.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, "expires_at");
  }


  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, "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_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, "expires_at");
    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, "expires_from_now");
    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, "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 // defined(ASIO_HAS_BOOST_DATE_TIME)
       // || defined(GENERATING_DOCUMENTATION)

#endif // ASIO_BASIC_DEADLINE_TIMER_HPP