RWLEnvelope.hpp

Go to the documentation of this file.

/*
    RWLEnvelope
    Reader Writer lock wrapper for object access
    Repo: https://github.com/SiddiqSoft/RWLEnvelope
 
    BSD 3-Clause License
 
    Copyright (c) 2021, Siddiq Software LLC
    All rights reserved.
 
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:
 
    1. Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
 
    2. Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.
 
    3. Neither the name of the copyright holder nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.
 
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#pragma once

 
#ifndef RWLENVELOPE_HPP
#define RWLENVELOPE_HPP
 
#include <functional>
#include <shared_mutex>
#include <tuple>
#include <utility>
#include <concepts>
#include <exception>
#include <type_traits>
 
#if !__has_cpp_attribute(nodiscard)
#error "We really should have [[nodiscard]]"
#endif
 
#if !__cpp_lib_shared_mutex
#error "Must have <shared_mutex>"
#endif
 
namespace siddiqsoft
{
    template <typename ContainerType, typename Callback, typename... Args>
    concept ObserveCallbackNoexcept = requires(Callback f, const ContainerType& item, Args... args) {
        { f(item, std::forward<Args>(args)...) } noexcept;
    };

    template <typename ContainerType, typename Callback, typename... Args>
    concept MutateCallbackNoexcept = requires(Callback f, ContainerType& item, Args... args) {
        { f(item, std::forward<Args>(args)...) } noexcept;
    };
 

    template <typename ContainerType>
        requires std::copy_constructible<ContainerType>
    class RWLEnvelope
    {
        using RWLock = std::unique_lock<std::shared_mutex>;
        using RLock  = std::shared_lock<std::shared_mutex>;
 
    private:
        struct rone
        {
            uint64_t& m_Dest;

            rone(uint64_t& dest)
                : m_Dest(dest)
            {
            }

            ~rone() { ++m_Dest; }
        };
 
    public:
        explicit RWLEnvelope()
            : _item(ContainerType {})
        {
        }
 

        explicit RWLEnvelope(RWLEnvelope<ContainerType>&& src) noexcept
        {
            try
            {
                // Execute within the lock of the source object
                if (auto [o, wl] = src.writeLock(); wl)
                {
                    // Move the internal data from source
                    _item = std::move(o);
                    // Transfer the counter from source to this object
                    _rwa = std::exchange(src._rwa, 0);
                }
            }
            catch (...)
            {
                // cannot throw
            }
        }
 

        explicit RWLEnvelope(ContainerType&& src)
                : _item(std::move(src))
        {
            //_item = std::move(src);
        }
 

        template<typename T>
        explicit RWLEnvelope(std::initializer_list<T> init)
        {
            _item = ContainerType(init);
        }
 
        
        void reassign(ContainerType&& src)
        {
            RWLock myWriterLock(_sMutex);
            _item = std::move(src);
        }
 

        explicit RWLEnvelope(const ContainerType& arg)
        {
            RWLock myWriterLock(_sMutex);
            _item = arg;
        }
 

        RWLEnvelope& operator=(RWLEnvelope const&) = delete;
 

        template <typename Callback, typename... Args>
            requires ObserveCallbackNoexcept<ContainerType, Callback, Args...>
        auto observe(Callback cbf, Args&&... args) const
        {
            RLock myLock(_sMutex);
            return cbf(_item, std::forward<Args>(args)...);
        }
 

        // NOLINTBEGIN(clang-diagnostic-return-type)
        template <typename Callback, typename... Args>
            requires MutateCallbackNoexcept<ContainerType, Callback, Args...>
        auto mutate(Callback cbf, Args&&... args)
        {
            RWLock myWriterLock(_sMutex);
            rone   d(_rwa); // we increment the housekeeping counter on each callback
 
            try
            {
                return cbf(_item, std::forward<Args>(args)...);
            }
            catch (...)
            {
            }
        }
        // NOLINTEND(clang-diagnostic-return-type)
 

        [[nodiscard]] ContainerType snapshot() const
        {
            RLock myLock(_sMutex);
            return _item;
        }
 

        [[nodiscard]] std::tuple<const ContainerType&, RLock> readLock() { return {std::ref(_item), RLock(_sMutex)}; }
 

        [[nodiscard]] std::tuple<ContainerType&, RWLock> writeLock() { return {std::ref(_item), RWLock(_sMutex)}; }
 
 
#ifdef INCLUDE_NLOHMANN_JSON_HPP_
    public:
        operator nlohmann::json() const
        {
            RLock myLock(_sMutex);
            return {{"storage", _item}, {"_typver", "RWLEnvelope/1.5.1"}, {"readWriteActions", _rwa}};
        }
#endif
 
    private:
        ContainerType _item;

        mutable std::shared_mutex _sMutex {};

        uint64_t _rwa {0};
    };
} // namespace siddiqsoft
 
#endif // !RWLENVELOPE_HPP