UT_PtrProxy.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:        UT_PtrProxy.h ( UT Library, C++)
 *
 * COMMENTS:    Template interface to the UT_ProxyPointer methods
 */

#ifndef __UT_PtrProxy__
#define __UT_PtrProxy__

#include "UT_ProxyPointer.h"


//
// First half of the proxy pointer interface.  The UT_PtrProxy maintains a
// pointer to the source object.
//
template <typename utObj>
class UT_PtrProxy
{
public:
    explicit UT_PtrProxy(utObj *me)
    {
        myId = UT_ProxyPointer::allocProxy(me);
    }
    ~UT_PtrProxy()
    {
        if (UT_ProxyPointer::isValid(myId)) // might have been moved
            UT_ProxyPointer::freeProxy(myId);
    }

    /// Not copyable
    /// @{
    UT_PtrProxy(const UT_PtrProxy<utObj>& copy) = delete;
    UT_PtrProxy<utObj>& operator=(const UT_PtrProxy<utObj>& copy) = delete;
    /// @}

    /// Movable
    /// @{
    UT_PtrProxy(UT_PtrProxy<utObj>&& src)
        : myId(src.myId)
    {
        src.myId = UT_ProxyPointer::nullId();
    }
    UT_PtrProxy<utObj>& operator=(UT_PtrProxy<utObj>&& src)
    {
        if (this != &src)
        {
            // NB: Two UT_PtrProxy instances cannot share the same id, so this
            //     is not something we need to check for here.
            if (UT_ProxyPointer::isValid(myId)) // might have been moved
                UT_ProxyPointer::freeProxy(myId);
            myId = src.myId;
            src.myId = UT_ProxyPointer::nullId();
        }
        return *this;
    }
    /// @}

    int                 getId() const   { return myId; }

    operator            const utObj *() const
                        {
                            const void *v = UT_ProxyPointer::lookupProxy(myId);
                            return (const utObj *)v;
                        }
    operator            utObj *()
                        {
                            void *v = UT_ProxyPointer::lookupProxy(myId);
                            return (utObj *)v;
                        }
    operator            int() const
                        {
                            return myId;
                        }
    void                swizzle(utObj *me)
                        {
                            UT_ProxyPointer::swizzlePointer(me);
                        }
    unsigned int        getReferences() const
                        {
                            return UT_ProxyPointer::getReferenceCount(myId)-1;
                        }

private:
    int         myId;
};

template <typename utObj>
class UT_RefProxy
{
public:
    explicit UT_RefProxy(int id)
    {
        init(id);
    }
    explicit UT_RefProxy(const UT_PtrProxy<utObj>&ptr)
    {
        init(ptr.getId());
    }
    ~UT_RefProxy()
    {
        if (UT_ProxyPointer::isValid(myId)) // might have been moved
            UT_ProxyPointer::deReferenceProxy(myId);
    }

    /// Copyable
    /// @{
    UT_RefProxy(const UT_RefProxy<utObj>& copy)
    {
        init(copy.myId);
    }
    UT_RefProxy<utObj>& operator=(const UT_RefProxy<utObj>& copy)
    {
        if (this != &copy)
            reset(copy.myId);
        return *this;
    }
    /// @}

    /// Movable
    /// @{
    UT_RefProxy(UT_RefProxy<utObj>&& src)
        : myId(src.myId)
    {
        src.myId = UT_ProxyPointer::nullId();
    }
    UT_RefProxy<utObj>& operator=(UT_RefProxy<utObj>&& src)
    {
        if (this != &src)
        {
            // NB: Two UT_RefProxy instances can share the same id, but we
            //     need to remove one reference here even in that case.
            if (UT_ProxyPointer::isValid(myId))
                UT_ProxyPointer::deReferenceProxy(myId);
            myId = src.myId;
            src.myId = UT_ProxyPointer::nullId();
        }
        return *this;
    }
    /// @}

    void                reset(int id = UT_ProxyPointer::nullId())
                        {
                            if (id != myId)
                            {
                                if (UT_ProxyPointer::isValid(myId))
                                    UT_ProxyPointer::deReferenceProxy(myId);
                                myId = id;
                                if (UT_ProxyPointer::isValid(myId))
                                    UT_ProxyPointer::referenceProxy(myId);
                            }
                        }
    void                reset(const UT_PtrProxy<utObj> &ptr)
                        { reset(ptr.getId()); }

    bool                isSet() const { return UT_ProxyPointer::isValid(myId); }

    operator            const utObj *() const
                        {
                            if (UT_ProxyPointer::isValid(myId))
                            {
                                void *v = UT_ProxyPointer::lookupProxy(myId);
                                return static_cast<const utObj *>(v);
                            }
                            return nullptr;
                        }
    operator            utObj *()
                        {
                            if (UT_ProxyPointer::isValid(myId))
                            {
                                void *v = UT_ProxyPointer::lookupProxy(myId);
                                return static_cast<utObj *>(v);
                            }
                            return nullptr;
                        }
    operator            int() const
                        {
                            return myId;
                        }

private:
    void        init(int id)
                {
                    myId = id;
                    if (UT_ProxyPointer::isValid(myId))
                        UT_ProxyPointer::referenceProxy(myId);
                }
    int         myId;
};


#endif