timer.hh

Go to the documentation of this file.

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  You may not use this file except in compliance with the License.
 *
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/*
 * Copyright 2015 Cloudius Systems
 */
 
#pragma once
 
#include <seastar/core/future.hh>
#include <seastar/core/scheduling.hh>
#include <seastar/core/timer-set.hh>
#include <seastar/util/std-compat.hh>
#include <seastar/util/modules.hh>
#ifndef SEASTAR_MODULE
#include <boost/intrusive/list.hpp>
#include <atomic>
#include <chrono>
#include <functional>
#endif
 
 
 
namespace seastar {
 
SEASTAR_MODULE_EXPORT_BEGIN
 
using steady_clock_type = std::chrono::steady_clock;
 
 
 
template <typename Clock = steady_clock_type>
class timer {
public:
    typedef typename Clock::time_point time_point;
    typedef typename Clock::duration duration;
    typedef Clock clock;
private:
    using callback_t = noncopyable_function<void()>;
    boost::intrusive::list_member_hook<> _link;
    scheduling_group _sg;
    callback_t _callback;
    time_point _expiry;
    std::optional<duration> _period;
    bool _armed = false;
    bool _queued = false;
    bool _expired = false;
    void readd_periodic() noexcept;
    void arm_state(time_point until, std::optional<duration> period) noexcept {
        assert(!_armed);
        _period = period;
        _armed = true;
        _expired = false;
        _expiry = until;
        _queued = true;
    }
public:
    timer() noexcept {};  // implementation is required (instead of = default) for noexcept due to a bug in gcc 9.3.1,
                          // since boost::intrusive::list_member_hook default constructor is not specified as noexcept.
    timer(timer&& t) noexcept : _sg(t._sg), _callback(std::move(t._callback)), _expiry(std::move(t._expiry)), _period(std::move(t._period)),
            _armed(t._armed), _queued(t._queued), _expired(t._expired) {
        _link.swap_nodes(t._link);
        t._queued = false;
        t._armed = false;
    }
    timer(scheduling_group sg, noncopyable_function<void ()>&& callback) noexcept : _sg(sg), _callback{std::move(callback)} {
    }
    explicit timer(noncopyable_function<void ()>&& callback) noexcept : timer(current_scheduling_group(), std::move(callback)) {
    }
    ~timer();
    void set_callback(scheduling_group sg, noncopyable_function<void ()>&& callback) noexcept {
        _sg = sg;
        _callback = std::move(callback);
    }
    void set_callback(noncopyable_function<void ()>&& callback) noexcept {
        set_callback(current_scheduling_group(), std::move(callback));
    }
    void arm(time_point until, std::optional<duration> period = {}) noexcept;
    void rearm(time_point until, std::optional<duration> period = {}) noexcept {
        if (_armed) {
            cancel();
        }
        arm(until, period);
    }
    void arm(duration delta) noexcept {
        return arm(Clock::now() + delta);
    }
    void arm_periodic(duration delta) noexcept {
        arm(Clock::now() + delta, {delta});
    }
    void rearm_periodic(duration delta) noexcept {
        if (_armed) {
            cancel();
        }
        arm_periodic(delta);
    }
    bool armed() const noexcept { return _armed; }
    bool cancel() noexcept;
    time_point get_timeout() const noexcept {
        return _expiry;
    }
    friend class reactor;
    friend class timer_set<timer, &timer::_link>;
};
 
extern template class timer<steady_clock_type>;
 
 
SEASTAR_MODULE_EXPORT_END
}