SharedState.hpp

/*
 * Copyright (C) 2021 Alexander Kornilov (akornilov.82@gmail.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * 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.
 */
 
#ifndef CPP_MATE_SHARED_STATE_HPP
#define CPP_MATE_SHARED_STATE_HPP
 
#include <functional>
#include <mutex>
#include <condition_variable>
 
#if __cplusplus >= 201703L
#include <shared_mutex>
#endif // __cplusplus >= 201703L
 
namespace CppMate {
 
template<typename T>
class SharedState final
{
public:
    class Action;
 
    template<typename... A, typename = std::enable_if_t<std::is_constructible_v<T, A...>>>
    inline SharedState(A&&... args): _state(std::forward<A>(args)...) {}
 
    inline void view(std::function<void(const T&)> block) const {
        LockRead lock(_mutex);
        block(_state);
    }
 
    template<typename R>
    inline R view(std::function<R(const T&)> block) const {
        LockRead lock(_mutex);
        return block(_state);
    }
 
    inline void modify(std::function<void(T&)> block) {
        LockWriteGuard lock(_mutex);
        block(_state);
    }
 
    inline Action modify() {
        return Action(*this);
    }
 
private:
#if __cplusplus >= 201703L
    using Mutex = std::shared_mutex;
    using LockRead = std::shared_lock<Mutex>;
    using LockWriteGuard = std::unique_lock<Mutex>;
    using ConditionVariable = std::condition_variable_any;
 
#else
    using Mutex = std::mutex;
    using LockRead = std::lock_guard<Mutex>;
    using LockWriteGuard = std::lock_guard<Mutex>;
    using ConditionVariable = std::condition_variable;
#endif // __cplusplus >= 201703L
 
    using LockWrite = std::unique_lock<Mutex>;
 
    T _state;
    mutable Mutex _mutex;
    ConditionVariable _notify;
};
 
template <typename T>
class SharedState<T>::Action final
{
public:
 
    void access(std::function<void(T&)> block) {
        return block(_parent._state);
    }
 
    template<typename R>
    inline R extract(std::function<R(T&)> block) {
        return block(_parent._state);
    }
 
    inline void notifyOne(std::function<void(T&)> block) {
        block(_parent._state);
        _parent._notify.notify_one();
    }
 
    template<typename R>
    inline R notifyOne(std::function<R(T&)> block) {
        R result = block(_parent._state);
        _parent._notify.notify_one();
        return result;
    }
 
    inline void notifyAll(std::function<void(T&)> block) {
        block(_parent._state);
        _parent._notify.notify_all();
    }
 
    template<typename R>
    inline R notifyAll(std::function<R(T&)> block) {
        R result = block(_parent._state);
        _parent._notify.notify_all();
        return result;
    }
 
    inline Action& when(std::function<bool(T&)> pred) {
        _parent._notify.wait(_lock, [&pred, this] { return pred(_parent._state); });
        return *this;
    }
 
private:
    friend class SharedState;
 
    inline Action(SharedState& parent):
        _parent(parent),
        _lock(_parent._mutex)
    {
    }
 
    SharedState& _parent;
    LockWrite _lock;
};
 
} // namespace CppMate
 
#endif // CPP_MATE_SHARED_STATE_HPP