ConditionVariableWrapper.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_THREADING_CONDITIONVARIABLEWRAPPER_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_THREADING_CONDITIONVARIABLEWRAPPER_H_

#include <atomic>
#include <chrono>
#include <condition_variable>
#include <unordered_set>
#include <thread>

#include <AVSCommon/Utils/Power/PowerMonitor.h>
#include <AVSCommon/Utils/Timing/Timer.h>
#include <AVSCommon/Utils/Logger/LoggerUtils.h>

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace threading {

class ConditionVariableWrapper {
public:
    inline static std::string getTag() {
        return "ConditionVariableWrapper";
    }

    ConditionVariableWrapper();

    void notifyOne();

    void notifyAll();

    template <typename Predicate>
    void wait(std::unique_lock<std::mutex>& lock, Predicate pred);

    template <typename Rep, typename Period, typename Predicate>
    bool waitFor(
        std::unique_lock<std::mutex>& lock,
        const std::chrono::duration<Rep, Period>& rel_time,
        Predicate pred);

    template <typename Clock, typename Duration, typename Predicate>
    bool waitUntil(
        std::unique_lock<std::mutex>& lock,
        const std::chrono::time_point<Clock, Duration>& timeout_time,
        Predicate pred);

private:
    void waitInner(std::unique_lock<std::mutex>& lock, std::function<bool()> pred);

    bool waitForInner(std::unique_lock<std::mutex>& lock, std::chrono::nanoseconds relTime, std::function<bool()> pred);

    static std::atomic<uint64_t> g_id;

    const uint64_t m_id;

    std::condition_variable m_cv;

    std::mutex m_mutex;

    std::shared_ptr<power::PowerResource> m_notifyOnePowerResource;

    uint64_t m_notifyOnePowerResourceRefCount;

    std::unordered_set<std::shared_ptr<power::PowerResource>> m_frozenResources;
};

template <typename Predicate>
void ConditionVariableWrapper::wait(std::unique_lock<std::mutex>& lock, Predicate pred) {
    waitInner(lock, pred);
}

template <typename Rep, typename Period, typename Predicate>
bool ConditionVariableWrapper::waitFor(
    std::unique_lock<std::mutex>& lock,
    const std::chrono::duration<Rep, Period>& rel_time,
    Predicate pred) {
    return waitForInner(lock, rel_time, pred);
};

template <typename Clock, typename Duration, typename Predicate>
bool ConditionVariableWrapper::waitUntil(
    std::unique_lock<std::mutex>& lock,
    const std::chrono::time_point<Clock, Duration>& timeout_time,
    Predicate pred) {
    return waitForInner(lock, timeout_time - Clock::now(), pred);
};

}  //  namespace threading
}  //  namespace utils
}  //  namespace avsCommon
}  //  namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_THREADING_CONDITIONVARIABLEWRAPPER_H_