UT/UT_LockedRawPtr.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.
 *
 * Produced by:
 *      Edward Lam
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        UT_LockedRawPtr.h (UT Library, C++)
 *
 * COMMENTS:    A template class that allows auto-locking in a getter method.
 *              This class has pointer semantics and does NOT deal with
 *              ownership by design. The pointer that you give it *MUST* live
 *              longer than the lifetime of this class.
 *
 * EXAMPLE:
 *              class B;
 *              class A
 *              {
 *                  /// Obtain a ptr to myB that is locked. When it goes out
 *                  /// of scope, it will automatically unlock.
 *                  UT_LockedRawPtr<B> getLockedB()
 *                          { return UT_LockedRawPtr<B>(myB, myBLock); }
 *              private:
 *                  B       myB;
 *                  UT_Lock myBLock;
 *              };
 */

#ifndef __UT_LOCKEDRAWPTR_H__
#define __UT_LOCKEDRAWPTR_H__

#include "UT_API.h"
#include <memory>
#include "UT_Algorithm.h"
#include "UT_Assert.h"
#include "UT_Lock.h"

template <typename PTR>
class UT_LockedRawPtr
{
public:
    UT_LockedRawPtr()
        : myPtr(0)
        , myAutoLock(0)
    {
    }
    UT_LockedRawPtr(PTR &ptr, UT_Lock &lock)
        : myPtr(&ptr)
        , myAutoLock(new UT_AutoLock(lock))
    {
    }
    UT_LockedRawPtr(const UT_LockedRawPtr &other)
        : myPtr(other.myPtr)
        , myAutoLock(other.myAutoLock)
    {
    }
    UT_LockedRawPtr &operator=(const UT_LockedRawPtr &other)
    {
        if (&other != this)
        {
            myPtr = other.myPtr;
            myAutoLock = other.myAutoLock;
        }
        return *this;
    }

    PTR &       operator*() const   { UT_ASSERT(myPtr); return *myPtr; }
    PTR *       operator->() const  { UT_ASSERT(myPtr); return  myPtr; }

    operator    bool() const        { return (myPtr != 0); }
    bool        operator!() const   { return (myPtr == 0); }

private:
    PTR *                       myPtr;
    mutable std::auto_ptr<UT_AutoLock>  myAutoLock;
};

#endif // __UT_LOCKEDRAWPTR_H__

---