NET_RWLock.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_RWLock.h
 *
 * COMMENTS:
 *                      
 *
 */

#ifndef __NET_RWLOCK_H__
#define __NET_RWLOCK_H__

#include "NET_API.h"

#include <UT/UT_Assert.h>

#if 0
#include <tbb/spin_rw_mutex.h>

using NET_RWLock = tbb::spin_rw_mutex;

class NET_AutoReadLock : public NET_RWLock::scoped_lock
{
public:
    NET_AutoReadLock(NET_RWLock& lock)
        : NET_RWLock::scoped_lock()
    {
        acquire(lock, false /*write*/);
    }

    NET_AutoReadLock(const NET_AutoReadLock&) = delete;
    NET_AutoReadLock& operator=(const NET_AutoReadLock&) = delete;
private:
};

class NET_AutoWriteLock : public NET_RWLock::scoped_lock
{
public:
    NET_AutoWriteLock(NET_RWLock& lock)
        : NET_RWLock::scoped_lock()
    {
        acquire(lock, true /*write*/);
    }
 
    NET_AutoWriteLock(const NET_AutoWriteLock&) = delete;
    NET_AutoWriteLock& operator=(const NET_AutoWriteLock&) = delete;
private:
};

class NET_API NET_AutoReadToWriteLock
{
public:
    NET_AutoReadToWriteLock(NET_AutoReadLock& lock) :
        myLock(lock)
    {
        myLock.upgrade_to_writer();
    }

    ~NET_AutoReadToWriteLock()
    {
        myLock.downgrade_to_reader();
    }

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

private:
    NET_AutoReadLock& myLock;
};
#else
#include <hboost/thread.hpp>

using NET_AutoReadLock = hboost::shared_lock<hboost::shared_mutex>;
using NET_AutoWriteLock = hboost::unique_lock<hboost::shared_mutex>;

using NET_RWLock = hboost::shared_mutex;

class NET_API NET_AutoReadUnlock
{
public:
    explicit NET_AutoReadUnlock(NET_RWLock& lock) :
        myLock(lock)
    {
        myLock.unlock_shared();
    }

    ~NET_AutoReadUnlock()
    {
        myLock.lock_shared();
    }

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

private:
    NET_RWLock& myLock;
};

class NET_API NET_AutoReadToWriteLock
{
public:
    explicit NET_AutoReadToWriteLock(NET_AutoReadLock& lock) :
        myLock(lock)
    {
        NET_RWLock* l = myLock.mutex();
        UT_ASSERT_P(l != nullptr);
        if (l != nullptr)
        {
            l->unlock_shared();
            l->lock();
        }
    }

    ~NET_AutoReadToWriteLock()
    {
        NET_RWLock* l = myLock.mutex();
        UT_ASSERT_P(l != nullptr);
        if (l != nullptr)
        {
            l->unlock();
            l->lock_shared();
        }
    }

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

private:
    NET_AutoReadLock& myLock;
};
#endif

#endif // __NET_RWLOCK_H__