Mutex.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
#ifndef UniSet_MUTEX_H_
#define UniSet_MUTEX_H_
// -----------------------------------------------------------------------------------------
#include <string>
#include <memory>
#include <mutex>
#include <Poco/RWLock.h>
// -----------------------------------------------------------------------------------------
namespace uniset
{
// rwmutex..
class uniset_rwmutex
{
    public:
        uniset_rwmutex( const std::string& name );
        uniset_rwmutex();
        ~uniset_rwmutex();

        void lock();
        void unlock();

        void wrlock();
        void rlock();

        bool try_lock();
        bool try_rlock();
        bool try_wrlock();

        uniset_rwmutex( const uniset_rwmutex& r ) = delete;
        uniset_rwmutex& operator=(const uniset_rwmutex& r) = delete;

        uniset_rwmutex( uniset_rwmutex&& r ) = default;
        uniset_rwmutex& operator=(uniset_rwmutex&& r) = default;

        inline std::string name()
        {
            return nm;
        }
        inline void setName( const std::string& name )
        {
            nm = name;
        }

    private:
        std::string nm;
        friend class uniset_rwmutex_lock;
        std::unique_ptr<Poco::RWLock> m;
};

std::ostream& operator<<(std::ostream& os, uniset_rwmutex& m );
// -------------------------------------------------------------------------
class uniset_rwmutex_wrlock
{
    public:
        uniset_rwmutex_wrlock( uniset_rwmutex& m );
        ~uniset_rwmutex_wrlock();

    private:
        uniset_rwmutex_wrlock(const uniset_rwmutex_wrlock&) = delete;
        uniset_rwmutex_wrlock& operator=(const uniset_rwmutex_wrlock&) = delete;
        uniset_rwmutex& m;
};

class uniset_rwmutex_rlock
{
    public:
        uniset_rwmutex_rlock( uniset_rwmutex& m );
        ~uniset_rwmutex_rlock();

    private:
        uniset_rwmutex_rlock(const uniset_rwmutex_rlock&) = delete;
        uniset_rwmutex_rlock& operator=(const uniset_rwmutex_rlock&) = delete;
        uniset_rwmutex& m;
};
// -------------------------------------------------------------------------
} // end of UniSetTypes namespace

#endif