Timer.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file 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.
 */

#ifndef ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_TIMING_TIMER_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_TIMING_TIMER_H_

#include <chrono>
#include <condition_variable>
#include <functional>
#include <future>
#include <mutex>
#include <thread>

#include <AVSCommon/AVS/Initialization/SDKPrimitivesProvider.h>
#include <AVSCommon/Utils/Timing/TimerDelegate.h>

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace timing {

class Timer {
public:
    static constexpr size_t FOREVER = 0;

    enum class PeriodType {
        ABSOLUTE,

        RELATIVE
    };

    Timer(
        const std::shared_ptr<sdkInterfaces::timing::TimerDelegateFactoryInterface>& timerDelegateFactory =
            avs::initialization::SDKPrimitivesProvider::getInstance()->getTimerDelegateFactory()) noexcept;

    ~Timer() noexcept;

    static inline size_t getForever() noexcept {
        return FOREVER;
    }

    template <typename Delay, typename Period, typename Task, typename... Args>
    bool start(
        Delay&& delay,
        Period&& period,
        PeriodType periodType,
        size_t maxCount,
        Task&& task,
        Args&&... args) noexcept;

    template <typename Period, typename Task, typename... Args>
    bool start(Period&& period, PeriodType periodType, size_t maxCount, Task&& task, Args&&... args) noexcept;

    template <typename Delay, typename Task, typename... Args>
    auto start(Delay&& delay, Task&& task, Args&&... args) noexcept -> std::future<decltype(task(args...))>;

    void stop() noexcept;

    bool isActive() const noexcept;

private:
    static constexpr size_t ONCE = 1u;

    bool activate() noexcept;

    bool callTask(
        const std::chrono::nanoseconds& delayNano,
        const std::chrono::nanoseconds& periodNano,
        PeriodType periodType,
        size_t maxCount,
        std::function<void()>&& task) noexcept;

    template <typename Delay, typename Period>
    bool adaptTypesAndCallTask(
        const Delay& delayNano,
        const Period& periodNano,
        PeriodType periodType,
        size_t maxCount,
        std::function<void()>&& task) noexcept;

    std::unique_ptr<sdkInterfaces::timing::TimerDelegateInterface> m_timer;

    std::thread m_thread;
};

template <typename Delay, typename Period, typename Task, typename... Args>
bool Timer::start(
    Delay&& delay,
    Period&& period,
    PeriodType periodType,
    size_t maxCount,
    Task&& task,
    Args&&... args) noexcept {
    // convert arguments to lambda
    auto boundTask = std::bind(std::forward<Task>(task), std::forward<Args>(args)...);

    // Kick off the new timer thread.
    return adaptTypesAndCallTask(
        std::forward<Delay>(delay), std::forward<Period>(period), periodType, maxCount, std::move(boundTask));
}

template <typename Period, typename Task, typename... Args>
bool Timer::start(Period&& period, PeriodType periodType, size_t maxCount, Task&& task, Args&&... args) noexcept {
    // convert arguments to lambda
    auto boundTask = std::bind(std::forward<Task>(task), std::forward<Args>(args)...);

    // Kick off the new timer thread.
    return adaptTypesAndCallTask(
        std::forward<Period>(period), std::forward<Period>(period), periodType, maxCount, std::move(boundTask));
}

template <typename Delay, typename Task, typename... Args>
auto Timer::start(Delay&& delay, Task&& task, Args&&... args) noexcept -> std::future<decltype(task(args...))> {
    // Task result value type.
    using Value = decltype(task(args...));

    // Remove arguments from the task's type by binding the arguments to the task.
    auto boundTask = std::bind(std::forward<Task>(task), std::forward<Args>(args)...);

    /*
     * Create a std::packaged_task with the correct return type. The reference will be passed into execution context
     * and will not be shared between threads.
     */
    auto packagedTask = std::make_shared<std::packaged_task<Value()>>(std::move(boundTask));
    // Get future object reference for function result.
    auto packagedTaskFuture = packagedTask->get_future();

    // Remove the return type from the task by wrapping it in a lambda with no return value.
    auto translatedTask = std::bind(&std::packaged_task<Value()>::operator(), std::move(packagedTask));

    // Kick off the new timer thread.
    if (!adaptTypesAndCallTask(
            std::forward<Delay>(delay),
            std::forward<Delay>(delay),
            PeriodType::ABSOLUTE,
            ONCE,
            std::move(translatedTask))) {
        return std::future<Value>();
    }

    return packagedTaskFuture;
}

template <typename Delay, typename Period>
bool Timer::adaptTypesAndCallTask(
    const Delay& delay,
    const Period& period,
    PeriodType periodType,
    size_t maxCount,
    std::function<void()>&& task) noexcept {
    return callTask(delay, period, periodType, maxCount, std::move(task));
}

// Externalize templates for common parameter types.
extern template bool Timer::adaptTypesAndCallTask(
    const std::chrono::milliseconds&,
    const std::chrono::milliseconds&,
    PeriodType,
    size_t,
    std::function<void()>&&) noexcept;
extern template bool Timer::adaptTypesAndCallTask(
    const std::chrono::nanoseconds&,
    const std::chrono::nanoseconds&,
    PeriodType,
    size_t,
    std::function<void()>&&) noexcept;

}  // namespace timing
}  // namespace utils
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_TIMING_TIMER_H_