PDG_AttributeHolder.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.
 *
 * COMMENTS:
 */

#ifndef __PDG_ATTRIBUTE_HOLDER_H__
#define __PDG_ATTRIBUTE_HOLDER_H__

#include "PDG_API.h"

#include "PDG_AttributeData.h"

#include <UT/UT_NonCopyable.h>
#include <SYS/SYS_Types.h>

/**
 * Reference to a PDG attribute instance, either owned or shared. Contains the
 * type information for the attribute as well as various flags (no copy, export,
 * etc).
 */
class PDG_API PDG_AttributeHolder : UT_NonCopyable
{
public:
    /// Constructs an invalid attribute holder
    PDG_AttributeHolder()
        : myAttribute(nullptr)
        , myType(PDG_AttributeType::eUndefined)
        , myFlags(0)
        , myIsOwner(false)
        , myIsStale(false)
        , myIsConcat(false)
        , myIsChanged(false)
    {
    }

    /// Move constructs an attribute holder
    PDG_AttributeHolder(PDG_AttributeHolder&& other)
        : myType(other.myType)
        , myFlags(other.myFlags)
        , myIsOwner(other.myIsOwner)
        , myIsStale(other.myIsStale)
        , myIsConcat(other.myIsConcat)
        , myIsChanged(other.myIsChanged)
    {
        myAttribute = other.myAttribute;

        other.myAttribute = nullptr;
        other.myIsOwner = false;
        other.myIsStale = false;
        other.myIsConcat = false;
        other.myIsChanged = false;
    }

    /// Constructs an attribute holder from an attribute data pointer, with
    /// the specified ownership
    PDG_AttributeHolder(PDG_AttributeData* attribute,
                        PDG_AttributeType type,
                        uint16 flags,
                        bool owner,
                        bool stale)
        : myAttribute(attribute)
        , myType(type)
        , myFlags(flags)
        , myIsOwner(owner)
        , myIsStale(stale)
        , myIsConcat(false)
        , myIsChanged(false)
    {
    }

    /// Destroys the attribute own by this holder if it exists, and the own
    /// flag is set
    ~PDG_AttributeHolder()
    {
        if (myAttribute && myIsOwner)
            delete myAttribute;
    }
   
    /// Move assignment is permitted
    PDG_AttributeHolder& operator=(PDG_AttributeHolder&& other)
    {
        if (this != &other)
        {
            reset(other.myAttribute, other.myType, other.myFlags,
                other.myIsOwner, other.myIsStale, other.myIsConcat);

            other.myAttribute = nullptr;
            other.myIsOwner = false;
            other.myIsStale = false;
            other.myIsConcat = false;
            other.myIsChanged = false;
        }

        return *this;
    }

    /// Returns the memory usage of the attribute, including the data only if
    /// this holder owns it.
    int64                           getMemoryUsage(bool inclusive) const
    {
        int64 mem = inclusive ? sizeof(*this) : 0;
        if (myIsOwner)
            mem += myAttribute->getMemoryUsage(true);
        return mem;
    }

    /// Returns whether or not this holder has taken ownership of the attribute
    inline bool                     isOwner() const
    {
        return myIsOwner;
    }

    /// Returns true if this is a stale owned attribute, which happens during
    /// deserialization
    inline bool                     isStale() const
    {
        return myIsStale;
    }

    /// Returns true if this attribute contains data that was concatenated
    /// from multiple input attributes
    inline bool                     isConcat() const
    {
        return myIsConcat;
    }

    /// Returns true if this attribute has been modified since the changed
    /// flag was cleared
    inline bool                     isChanged() const
    {
        return myIsChanged;
    }

    /// Takes ownership of the attribute pointer if it is not already owned. If
    /// it is, the pointer is returned back directly
    inline PDG_AttributeData*       own()
    {
        if (!myAttribute || myIsOwner)
            return myAttribute;

        myAttribute = myAttribute->clone();
        myIsOwner = true;
        return myAttribute;
    }

    /// Swaps the attributes in this holder and the specified holder, but
    /// leaves the flags unmodified.
    inline void                     swapAttributes(PDG_AttributeHolder& holder)
    {
        std::swap(myAttribute, holder.myAttribute);
        
        bool is_owner = myIsOwner;
        bool is_concat = myIsConcat;
        bool is_changed = myIsChanged;

        myIsOwner = holder.myIsOwner;
        myIsConcat = holder.myIsConcat;
        myIsChanged = holder.myIsChanged;

        holder.myIsOwner = is_owner;
        holder.myIsConcat = is_concat;
        holder.myIsChanged = is_changed;
    }

    /// Resets the holder to a nullptr, thus making it an invalid holder
    inline void                     reset()
    {
        if (myAttribute && myIsOwner)
            delete myAttribute;

        myAttribute = nullptr;
        myIsOwner = false;
        myIsStale = false;
        myIsConcat = false;
        myIsChanged = false;
    }

    /// Changes the attribute owned by this holder, and deletes the existing
    /// attribute if one existed and was owned by this holder.
    inline PDG_AttributeData*       reset(const PDG_AttributeData* attribute,
                                          PDG_AttributeType type,
                                          uint16 flags,
                                          bool own,
                                          bool stale,
                                          bool concat)
    {
        if (myAttribute && myIsOwner)
            delete myAttribute;

        if (!attribute)
        {
            myAttribute = nullptr;
            myIsOwner = false;
            myIsStale = false;
            myIsConcat = false;
            myIsChanged = false;
            myType = PDG_AttributeType::eUndefined;
            myFlags = 0;
        }
        else
        {
            myAttribute = (PDG_AttributeData*)(attribute);
            myIsOwner = own;
            myIsStale = (own && stale);
            myIsConcat = concat;
            myIsChanged = false;
            myType = type;
            myFlags = flags;
        }

        return myAttribute;
    }

    /// Changes the attribute owned by this holder so that it has a shallow
    /// holder to the one owned by the specififed attribute, or copies it
    /// depending on the own arg. Deletes the existing attribute if one existed
    /// and was owned by this holder
    inline PDG_AttributeData*       reset(const PDG_AttributeHolder& holder,
                                          bool own,
                                          bool sync_flags)
    {
        if (myAttribute && myIsOwner)
            delete myAttribute;

        if (!holder)
        {
            myAttribute = nullptr;
            myIsOwner = false;
            myIsStale = false;
            myIsConcat = false;
            myIsChanged = false;

            myType = PDG_AttributeType::eUndefined;
            myFlags = 0;
            return nullptr;
        }

        if (own)
        {
            myAttribute = holder.myAttribute->clone();
            myIsOwner = true;
            myIsStale = false;
            myIsConcat = false;
            myIsChanged = false;
        }
        else
        {
            myAttribute = holder.myAttribute;
            myIsOwner = false;
            myIsStale = false;
            myIsConcat = false;
            myIsChanged = false;
        }

        myType = holder.myType;
        if (sync_flags)
            myFlags = holder.myFlags;

        return myAttribute;
    }

    /// Const accessor for the own attribute - could be nullptr
    template <typename Attribute=PDG_AttributeData>
    inline const Attribute*         attribute() const
    {
        return ((const Attribute*)myAttribute);
    }

    /// Non-const accessor for the own attribute - could be nullptr
    template <typename Attribute=PDG_AttributeData>
    inline Attribute*               attribute()
    {
        return ((Attribute*)myAttribute);
    }

    /// Returns true if the underlying attribute has any data
    template <typename Attribute=PDG_AttributeData>
    inline bool                     hasData() const
    {
        const Attribute* attrib = attribute<Attribute>();
        if (!attrib || !attrib->hasData())
            return false;
        return true;
    }

    /// Const arrow operator, invalid to use if this holder refers to a
    /// null attribute.
    inline const PDG_AttributeData* operator->() const
    {
        return myAttribute;
    }

    /// Nonconst arrow operator, invalid to use if this holder refers to a
    /// null attribute.
    inline PDG_AttributeData*       operator->()
    {
        return myAttribute;
    }

    /// Const dereference, invalid to use if this holder refers to a
    /// null attribute.
    inline const PDG_AttributeData& operator*() const
    {
        return *myAttribute;
    }

    /// Nonconst dereference, invalid to use if this holder refers to a
    /// null attribute.
    inline PDG_AttributeData&       operator*()
    {
        return *myAttribute;
    }

    /// Compares two attribute holders and returns true if they're the same.
    /// The data is only compared if all other aspects are the same.
    inline bool                     operator==(const PDG_AttributeHolder& other)  const
    {
        // Null holders are never equal
        if (!myAttribute || !other.myAttribute)
            return false;

        // Type and flag check
        if ((myFlags != other.myFlags) || (myType != other.myType))
            return false;

        // Identical attribute pointers are always equal
        if (myAttribute == other.myAttribute)
            return true;

        // Compare data
        return (myAttribute->compare(other.myAttribute));
    }

    /// Compares two attribute holders for inequality - the inverse of the above
    /// function.
    inline bool                     operator!=(const PDG_AttributeHolder& other) const
    {
        return !(*this == other);
    }

    /// Returns true if this holder  refers to a valid attribute pointer,
    /// else false.
    inline                          operator bool() const
    {
        return (myAttribute != nullptr);
    }

    /// Returns true if the type of the template argumented is a match for the
    /// the type of this holder
    template <typename Attribute>
    inline bool                     typeMatch() const
    {
        return (Attribute::TypeEnum == myType) ||
               (Attribute::TypeEnum == PDG_AttributeType::eUndefined);
    }

    /// Returns the attribute type
    inline PDG_AttributeType        type() const
    {
        return myType;
    }

    /// Returns the attribute flags
    inline uint16                   flags() const
    {
        return myFlags;
    }

    /// Returns true if this attribute has at least one flag set
    inline bool                     hasAnyFlags() const
    {
        return (myFlags != 0);
    }

    /// Returns true if this attribute has the specified flag
    inline bool                     hasFlag(PDG_AttributeFlag flag) const
    {
        return (myFlags & (uint16)flag);
    }

    /// Returns true if this attribute has all of the specified flags set
    inline bool                     hasFlags(uint16 flags) const
    {
        return ((myFlags & (uint16)flags) == (uint16)flags);
    }

    /// Returns true if this attribute has any of the specified flags set
    inline bool                     hasAnyFlags(uint16 flags) const
    {
        return ((myFlags & flags) != 0);
    }

    /// Sets a flag on the attribute. Returns true if the flag was changed
    /// as a result of this operation.
    inline bool                     setFlag(PDG_AttributeFlag flag,
                                            bool set)
    {
        bool has_flag = hasFlag(flag);

        if (set)
        {
            myFlags |= (uint16)flag;
            myIsChanged |= !has_flag;

            return !has_flag;
        }
        else
        {
            myFlags &= ~((uint16)flag);
            myIsChanged |= has_flag;

            return has_flag;
        }
    }

    /// Sets the flags on the attribute directly. Returns true if any of the
    /// flags were modified.
    inline bool                     setFlags(uint16 flags)
    {
        bool changed = (myFlags != flags);
        myFlags = flags;
        myIsChanged |= changed;

        return changed;
    }

    /// Sets the concat bit to the specified value
    inline void                     setIsConcat(bool is_concat)
    {
        myIsConcat = is_concat;
    }

    /// Sets the changed bit to the specified value
    inline void                     setIsChanged(bool is_changed)
    {
        myIsChanged = is_changed;
    }

    /// Concats the specified attribute with the attribute in this holder
    template <typename Attribute>
    inline bool                     concat(const PDG_AttributeHolder& other)
    {
        myIsConcat = true;
        return attribute<Attribute>()->concat(other.attribute<Attribute>());
    }

    /// Sets the size of the attribute
    template <typename Attribute>
    inline bool                     adjustSize(int offset)
    {
        return attribute<Attribute>()->adjustSize(offset);
    }

    /// Clears the attribute
    template <typename Attribute>
    inline void                     clear()
    {
        return attribute<Attribute>()->clear();
    }

    /// Swaps the specified attribute with the attribute in this holder
    template <typename Attribute>
    inline void                     swap(PDG_AttributeHolder& other)
    {
        attribute<Attribute>()->swap(other.attribute<Attribute>());
    }

private:
    PDG_AttributeData*              myAttribute;
    uint16                          myFlags     : 16;
    PDG_AttributeType               myType      : 8;
    bool                            myIsOwner   : 1;
    bool                            myIsStale   : 1;
    bool                            myIsConcat  : 1;
    bool                            myIsChanged : 1;
};

#endif