//Mutex for readers-writers locking.
//Simultaneously can work some readers or one writer.
//If there are no write requests, readers can work and be added.
//If there are write requests, readers can work, but can't be added.
//If there are no readers or writers, read and write requests will be executed concurrently
class RWLocker final
{
    mutable std::mutex general_lock_;
    mutable std::mutex write_lock_;
    mutable std::mutex read_lock_;

    mutable std::size_t number_of_readers_ = 0;

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

    RWLocker () = default;

    //Only read and write abstractions can work with RWLocker
    friend class ReadGuard;
    friend class WriteGuard;
};

class WriteGuard final
{
    const RWLocker & locker_;

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

public:

    //Strong exception guarantee
    explicit WriteGuard (const RWLocker & input_lock) :
        locker_ { input_lock }
    {
        locker_.general_lock_.lock ();
        locker_.write_lock_.lock ();
        locker_.general_lock_.unlock ();
    }

    ~WriteGuard ()
    {
        //Anyway UB if unlock fails
        locker_.write_lock_.unlock ();
    }
};

class ReadGuard final
{
    const RWLocker & locker_;

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

public:

    //Strong exception guarantee
    explicit ReadGuard (const RWLocker & input_lock) :
        locker_ { input_lock }
    {
        locker_.general_lock_.lock ();
        locker_.read_lock_.lock ();
        locker_.general_lock_.unlock ();

        if (0 < ++locker_.number_of_readers_)
            locker_.write_lock_.lock ();

        locker_.read_lock_.unlock ();
    }

    ~ReadGuard ()
    {
        ErrorMaster::getInstance ().runUntilSuccess ("ReadGuard::~ReadGuard () noexcept border",
                                                     [=]
        {
            locker_.read_lock_.lock ();
        });

        //Anyway UB if unlock fails
        if (1 > --locker_.number_of_readers_)
            locker_.write_lock_.unlock ();

        locker_.read_lock_.unlock ();
    }
};