UT/UT_COW.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:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        UT_COW.h ( UT Library, C++)
 *
 * COMMENTS:
 *              Defines our templated copy-on-write methods.
 */

#ifndef __UT_COW__
#define __UT_COW__

#include "UT_API.h"

#include <SYS/SYS_AtomicInt.h>

// Sadly, we cannot include this in the .C file since we are
// a template
#include <SYS/SYS_AtomicIntImpl.h>

#include <boost/shared_ptr.hpp>

#include "UT_Assert.h"

///
/// This is a copy-on-write shared pointer to data.
/// If you create a writehandle, it will uniquify the
/// underlying data.
/// Do not pass references to handles or pointers to them around.
/// This can cause you to invalidate the tracking of copies.
/// In any case, passing by value is fast.
///

// Forward declarations for our friendship.
template <typename Data> class UT_COWReadHandle;
template <typename Data> class UT_COWWriteHandle;

///
/// A plain handle is an opaque refernce to the data.  You can't
/// read or write to it with this sort of handle, but you can
/// copy and store it.  Assign a plain handle into a ReadHandle
/// or a WriteHandle to gain more privelages.
/// 
template <typename Data>
class UT_COWHandle
{
public:
    UT_COWHandle()
    {
        myData.reset((Data *)0);
        myWriteCount.set(0);
    }

    virtual ~UT_COWHandle()
    {
        // Locks must have expired.
        UT_ASSERT(!myWriteCount);
    }

    UT_COWHandle(const UT_COWHandle<Data> &src)
    {
        myData.reset((Data *) 0);
        *this = src;
    }

    const UT_COWHandle<Data> &operator=(const UT_COWHandle<Data> &src)
    {
        UT_ASSERT(!myWriteCount);
        // It's fine to make a new handle of something with an existing
        // write lock, as long as we release the handle before we
        // next try to access the write lock. This condition is checked
        // in the UT_COWWriteHandle cast functions.
        myData = src.myData;

        return *this;
    }

    /// Calls the default constructor on the object.
    void        allocate()
    {
        UT_ASSERT(!myWriteCount);
        myData.reset(new Data);
    }

    /// Makes a copy of the source data.  This is the safest
    /// approach as the caller will retain ownership.
    void        copy(Data *src)
    {
        UT_ASSERT(!myWriteCount);
        myData.reset(new Data);
        *myData = *src;
    }

    /// Be careful when initializing using this function.  The
    /// handle will gain ownership of the provided pointer, so
    /// the caller should cease referring to it.
    void        steal(Data *src)
    {
        UT_ASSERT(!myWriteCount);
        myData.reset(src);
    }

    /// Turns us into a null pointer, a useful way to end our use
    /// of a handle without having to play weird scope games.
    void        resetHandle()
    {
        UT_ASSERT(!myWriteCount);
        myData.reset((Data *) 0);
    }

private:
    void        makeUnique()
    {
        // Zero pointers are already unique
        if (!myData)
            return;

        if (!myData.unique())
        {
            boost::shared_ptr<Data > tmp(new Data);
            *tmp = *myData;
            myData = tmp;
        }
        // We are now unique!
    }


    boost::shared_ptr<Data>     myData;

    /// Tracks the number of outstanding writecounts referring to this
    /// data.
    /// This is only required for sanity-checking.
    mutable SYS_AtomicInt32     myWriteCount;

    /// Grant our friends direct access.
    template<typename OtherData> friend class UT_COWReadHandle;
    template<typename OtherData> friend class UT_COWWriteHandle;
};

///
/// Read Handles are copies of the original handle that have
/// their internal data exposed.  You are not allowed to edit them,
/// so many read handles may be sharing the same underlying data.
///
template <typename Data>
class UT_COWReadHandle
{
public:
    UT_COWReadHandle()
    {
        // Handle's default to null so this is fine.
    }

    ~UT_COWReadHandle()
    {
        // Natural destructor suffices.
    }

    UT_COWReadHandle(const UT_COWReadHandle<Data> &src)
    {
        myHandle = src.myHandle;
    }

    UT_COWReadHandle(const UT_COWHandle<Data> &src)
    {
        *this = src;
    }

    const UT_COWReadHandle<Data> &operator=(const UT_COWReadHandle<Data> &src)
    {
        myHandle = src.myHandle;
        return *this;
    }

    const UT_COWReadHandle<Data> &operator=(const UT_COWHandle<Data> &src)
    {
        myHandle = src;
        // It's fine to make a read lock of something with an existing
        // write lock, as long as we release the read lock before we
        // next try to access the write lock. This condition is checked
        // in the UT_COWWriteHandle cast functions.
        return *this;
    }

    /// Removes references, making this a null pointer
    void resetHandle()
    {
        myHandle.resetHandle();
    }

    const Data &operator*() const
    {
        return *myHandle.myData;
    }

    const Data *operator->() const
    {
        return &*myHandle.myData;
    }

private:
    UT_COWHandle<Data>            myHandle;
};

///
/// A write handle can be thought of as a pointer to the actual
/// data.  It allows you to modify the underlying data.  To do this,
/// it will unique the plain-handle's data so no outstanding
/// readlocks will be affected by the writes.
///
/// Building read handles while a write handle is active is valid
/// so long as no dereference occurs during the lifetime of the read
/// handle.
///
template <typename Data>
class UT_COWWriteHandle
{
public:
    UT_COWWriteHandle()
    {
        myHandle = 0;
    }

    ~UT_COWWriteHandle()
    {
        unlock();
    }

    UT_COWWriteHandle(const UT_COWWriteHandle<Data> &src)
    {
        myHandle = 0;
        *this = src;
    }

    UT_COWWriteHandle(UT_COWHandle<Data> *src)
    {
        myHandle = 0;
        *this = src;
    }

    /// Passing write handles by value is fine as the users understand
    /// they all share the same underlying data, so is responsible
    /// for thread safety, etc.
    const UT_COWWriteHandle<Data> &operator=(const UT_COWWriteHandle<Data> &src)
    {
        // Track our lock counts appropriately.
        src.lock();
        unlock();
        myHandle = src.myHandle;

        return *this;
    }

    /// Converting from a handle into a write handle can only be
    /// done once.  This prevents other threads or methods from
    /// invalidating our uniqueness property.
    /// Note we up case from a *pointer* to a UT_COWHandle, not from
    /// a UT_COWHandle.  This avoids people accidentally using an
    /// temporary as the source and underlines that write handles
    /// are like pointers while read handles are like values.
    const UT_COWWriteHandle<Data> &operator=(UT_COWHandle<Data> *src)
    {
        myHandle = src;

        if (src)
        {
            // Ensure we are the only copy.
            src->makeUnique();
        }

        lock();
        return *this;
    }

    /// Turns this into a null handle to drop references.
    void resetHandle()
    {
        unlock();
        myHandle = 0;
    }

    Data &operator*() const
    {
        if (myHandle)
        {
            // It is possible UT_COWReadHandles were created on
            // our handle. This is fine as long as they are
            // destroyed before we do our next write access.
            UT_ASSERT(myHandle->myData.unique());
            return *(myHandle->myData);
        }
        else
        {
            // As much of a crash as returning zero,
            // but the compiler is happier.
            // return *(0);
            return *(myHandle->myData);
        }
    }

    Data *operator->() const
    {
        if (myHandle)
        {
            // It is possible UT_COWReadHandles were created on
            // our handle. This is fine as long as they are
            // destroyed before we do our next write access.
            UT_ASSERT(myHandle->myData.unique());
            return &*(myHandle->myData);
        }
        else
            return (Data *)0;
    }

private:
    void        unlock() const
    {
        if (myHandle)
        {
            // Don't track reference counts on null arrays since
            // they are safe to share.
            if (!myHandle->myData)
                return;
            UT_ASSERT(myHandle->myWriteCount);
            if (myHandle->myWriteCount)
                myHandle->myWriteCount.add(-1);
        }
    }

    void        lock() const
    {
        if (myHandle)
        {
            // Don't track reference counts on null arrays since
            // they are safe to share.
            if (!myHandle->myData)
                return;
            myHandle->myWriteCount.add(1);
        }
    }

    UT_COWHandle<Data>    *myHandle;
};

#if defined( WIN32 ) || defined( LINUX ) || defined( MBSD ) || defined(GAMEOS)
    #include "UT_COW.C"
#endif


#endif

---