PDG_AttributeMap.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_MAP_H__
#define __PDG_ATTRIBUTE_MAP_H__

#include "PDG_API.h"

#include "PDG_AttributeData.h"
#include "PDG_AttributeDictionary.h"
#include "PDG_AttributeFile.h"
#include "PDG_AttributeGeometry.h"
#include "PDG_AttributeHolder.h"
#include "PDG_AttributePrimitive.h"
#include "PDG_AttributePyObject.h"
#include "PDG_AttributeRef.h"
#include "PDG_AttributeTypes.h"
#include "PDG_EvaluationContext.h"

#include <PDGT/PDGT_Value.h>

#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_ArrayStringSet.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_RWLock.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>

class UT_JSONValue;
class UT_JSONWriter;
class UT_OptionsHolder;

class PDG_AttributeMerge;
class PDG_AttributeOwner;
class PDG_AttributePattern;

/**
 * Map for storing, accessing and persisting PDG attribute data.
 * Attributes are stored in a map of string value to attribute holder, which
 * maintains a weak/strong reference to an attribute. Writing to an attrib value
 * results in a deep copy being performed on the specified attribute (i.e. copy
 * on write). Attribute handles are given to callers in the form of a 
 * PDG_ROAttributeRef or PDG_RWAttributeRef, depending on whether the caller
 * requested a read only or read/write handle.
 *
 * Attributes are owned by a PDG_AttributeOwner instance. In most cases this is
 * a PDG_WorkItem, and the attributes are accessed/modified when the node
 * creates or cooks the work item.
 *
 * The attribute map maintains a separate table for static and dynamic
 * attributes. Static attributes are any attributes created during the work
 * item generation step, and dynamic attributes are attributes created or
 * modified at any other point in time. If a work item attempts to modify
 * a static attribute while cooking, including adding output files, then a
 * copy made is in the dynamic map. The modifications are peformed on that
 * rather than on the original static attribute. This means that when a work
 * item is dirtied, it can easily roll back to the exact same state it was in
 * before cooking. When a work item is being regenerated, only static values
 * are considered. If the item is dirty then all dynamic attributes are
 * discarded, otherwise if the item is still valid then the dynamic values
 * are left as-is.
 *
 * The various merge* methods should be used to merge attribute map data
 * from a parent or dependency on the work item. Care should be taken to only
 * merge static attributes during work item generation. Dynamic attributes
 * can be merged at any point between generation and the work item being marked
 * as cooked.
 */
class PDG_API PDG_AttributeMap : UT_NonCopyable
{
public:
    /// Prefix for all built-in PDG attributes that can potentially appear on
    /// work items. User-created attributes cannot begin with this prefix.
    static const UT_StringHolder    theBuiltinPrefix;

    /// Name of the built-in input file list attribute, which contains the
    /// read only list of input files to a work item
    static const UT_StringHolder    theInputFileName;

    /// Name of the built-in output file list attribute, which contains the
    /// list of all output files from the work item, including any outputs
    /// copied from inputs.
    static const UT_StringHolder    theOutputFileName;

    /// Name of the built-in added file list attribute, which contains files
    /// explicitly added to the work item.
    static const UT_StringHolder    theAddedFileName;

    /// Name of the built-in command attribute
    static const UT_StringHolder    theCommandStringName;

    /// Name of the built-in human readable label attribute
    static const UT_StringHolder    theLabelName;

    /// Name of the built-in custom state attribute
    static const UT_StringHolder    theCustomStateName;

    /// Name of the built-in cook percent attribute
    static const UT_StringHolder    theCookPercentName;

    /// Name of the built-in partition size attribute
    static const UT_StringHolder    thePartitionSizeName;


    /// Special token indicating all attributes, used when binding attributes
    /// with PDG_AttributeInfo.
    static const UT_StringHolder    theAllAttribName;

    /// Special token used to indicate a "pseudo" attribute dependency, such
    /// as the work item's index or frame. These attribute dependencies only
    /// exist because the values are accessible via expressions like a regular
    /// attribute, although the value itself is not stored as an attribute.
    static const UT_StringHolder    thePseudoAttribName;


    /// Flags for the standard input file attribute
    static const uint16             theInputFileFlags;

    /// Flags for the standard output file attribute
    static const uint16             theOutputFileFlags;

    /// Flags for the standard added file attribute
    static const uint16             theAddedFileFlags;

    /// Flags for the standard command string attribute
    static const uint16             theCommandStringFlags;

    /// Flags for the standard label attribute
    static const uint16             theLabelFlags;

    /// Flags for the standard custom state attribute
    static const uint16             theCustomStateFlags;

    /// Determines when to create an attribute, for refRW method calls that
    /// can optionally create one if it does not yet exist.
    enum CreateWhen
    {
        /// Never create the attribute, even if its not found
        eCreateNever,

        /// Always create the attribute if it does not exist
        eCreateAlways,

        /// Only create the attribute if its necessary to upgrade from
        /// a static table entry to a dynamic table entry.
        eCreateUpgrade,
    };
   
    /// Enumeration of possible attribute change results during regeneration
    enum ChangeResult
    {
        /// No changes occured
        eChangeNone,

        /// Attribute values were changed or added
        eChangeConstructive,

        /// At least one attribute was deleted
        eChangeDestructive
    };

    /// Enumeration of attribute tables
    enum AttribTable
    {
        /// Static attribute table, attributes in this table are modified when
        /// the work item is generated
        eTableStatic,

        /// Dynamic attribute table, attributes in this table are modified
        /// outside of the generation step (during the cook, precook, etc).
        eTableDynamic,

        /// Number of attribute tables
        eTableCount,
    };

public:
    /// Scoped lock of an attribute map and the node that owns the work item
    /// associated with the attribute map. This is used to serialize access
    /// to work item attributes when running a node callback or adding results
    /// from the scheduler.
    ///
    /// When a node callback runs, the node's read lock and work item's write
    /// lock are acquired. When a full-node callback like onRegenerate is
    /// run, the node's write lock is acquired, effectively locking all attribs
    /// on all items in the node.
    ///
    /// Internally, PDG does not require the use of this lock. The cook logic
    /// and dependency graph are structure in such a way that work items don't
    /// need to lock in order to safely access themselves or their parent. This
    /// lock and the scoped locks around various work item callbacks exist for
    /// the benefit of external code that requires direct, random access to
    /// PDG work items. PDG attribute events, for example, can safely read
    /// attribute data without locking.
    template <bool Read>
    class PDG_API ScopedLock
    {
    public:
        /// We must always acquire the global lock first, then the attrib lock.
        /// Other places in the code such as the onRegenerate callback
        /// assume that to be the case, and doing so in the wrong order will
        /// cause a deadlock. The global lock is only acquired as a read lock
        /// here -- acquring a write lock to the global lock can be used to get
        /// exclusive access to ALL attribute maps that use the same lock.
        ScopedLock(const PDG_AttributeMap& attribute_map)
            : myGlobalLock(attribute_map.globalLock())
            , myAttribLock(attribute_map.attributeLock())
            , myAttribMap(attribute_map)
        {
            if (myGlobalLock)
                myGlobalLock->readLock();

            if (Read)
                myAttribLock.readLock();
            else
                myAttribLock.writeLock();

            myAttribMap.myWasModified = false;
        }

        ~ScopedLock()
        {
            if (Read)
                myAttribLock.readUnlock();
            else
            {
                myAttribMap.onUnlock();
                myAttribLock.writeUnlock();
            }

            if (myGlobalLock)
                myGlobalLock->readUnlock();
        }

    private:
        UT_RWLock*                          myGlobalLock;
        UT_RWLock&                          myAttribLock;
        const PDG_AttributeMap&             myAttribMap;
    };

    /// Version of the above lock that only tries to lock, and sets a flag
    /// to true or false based on whether the lock was acquired. This should
    /// be used for UI updates that don't require access to a specific attrib
    /// and are simply presenting current state, for example. It reduces the
    /// amount of time the UI spends blocked on PDG structures.
    class PDG_API ScopedTryLock
    {
    public:
        ScopedTryLock(const PDG_AttributeMap& attribute_map)
            : myGlobalLock(attribute_map.globalLock())
            , myAttribLock(attribute_map.attributeLock())
            , myDidLockGlobal(false)
            , myDidLockAttrib(false)
        {
            if (!myGlobalLock || myGlobalLock->tryReadLock())
            {
                myDidLockGlobal = true;
                if (myAttribLock.tryReadLock())
                    myDidLockAttrib = true;
            }
        }

        ~ScopedTryLock()
        {
            if (myDidLockAttrib)
                myAttribLock.readUnlock();

            if (myGlobalLock && myDidLockGlobal)
                myGlobalLock->readUnlock();
        }

        /// Returns true only if the lock was successful. This method should be
        /// checked before performing any actions on this attribute map.
        inline bool didLock() const
            { return (myDidLockGlobal && myDidLockAttrib); }

    private:
        UT_RWLock*  myGlobalLock;
        UT_RWLock&  myAttribLock;
        bool        myDidLockGlobal;
        bool        myDidLockAttrib;
    };

    /// Runs a functor on this map under the scoped read lock, so it's safe
    /// for concurrent access on an arbitrary thread. This holds both the
    /// global read lock and attribute map read lock, so it can always be
    /// called in order to safely iterate over attribute values. This should
    /// be used in, for example, an event handler callback in order to ensure
    /// that the attributes are not also being written to by the owner or
    /// a full-item list operation performed by another holder of the global
    /// lock.
    ///
    /// If this map does not have an owner, or the owner does not have a 
    /// global lock, the functor will be called with only the local attribute
    /// lock held.
    template <typename Func>
    bool                    lockedAccess(const Func& func) const
    {
        ScopedLock<true> auto_lock(*this);
        func(*this);
        return true;
    }

    /// Same as above, but only try-locks. If the lock cannot be acquired the
    /// functor is not run and the method returns false. If the functor is
    /// run successfully this method returns true.
    template <typename Func>
    bool                    tryLockedAccess(const Func& func) const
    {
        ScopedTryLock auto_lock(*this);
        if (!auto_lock.didLock())
            return false;

        func(*this);
        return true;
    }

    /// Iterates over attributes in the map of the specified type, and invokes
    /// the input function on each matching entry. This function operates on
    /// the space of attribute names, and therefore will including parent map
    /// attributes and dynamic attributes, if permitted by the active context.
    ///
    /// The supplied function can return true to halt iteration.
    template <typename Attribute, typename Func>
    void                    forEachRO(const Func& func) const
    {
        UT_ArrayStringSet names;
        attributeNames(names, Attribute::TypeEnum);

        for (auto&& name : names)
        {
            auto&& ref = refRO<Attribute>(name);
            if (ref && func(ref))
                break;
        }
    }

    /// Iterates over attributes in the map that match the specified
    /// pattern, and invokes the function on each matching entry.
    /// Attributes are referenced generally, as PDG_AttributeData references.
    ///
    /// The supplied function can return true to halt iteration. This function
    /// returns true if iteration was interrupted.
    template <typename Func>
    bool                    forEachRO(
                                const PDG_AttributePattern& pattern,
                                const Func& func) const
    {
        UT_ArrayStringSet names;
        if (!attributeMatch(names, pattern, false))
            return false;

        for (auto&& name : names)
        {
            auto&& ref = refRO<PDG_AttributeData>(name);
            if (ref && func(ref))
                return true;
        }

        return false;
    }

    /// Iterates over attributes in the map that match the specified
    /// pattern and type, and invokes the function on each matching entry.
    /// Attributes are referenced generally, as PDG_AttributeData references.
    ///
    /// The supplied function can return true to halt iteration. This function
    /// returns true if iteration was interrupted.
    template <typename Attribute, typename Func>
    bool                    forEachRO(
                                const PDG_AttributePattern& pattern,
                                const Func& func) const
    {
        UT_ArrayStringSet names;
        if (!attributeMatch(names, pattern, Attribute::TypeEnum, false))
            return false;

        for (auto&& name : names)
        {
            auto&& ref = refRO<Attribute>(name);
            if (ref && func(ref))
                return true;
        }

        return false;
    }
    
public:
    explicit                PDG_AttributeMap(
                                const PDG_AttributeOwner* owner,
                                bool has_runtime);
                            ~PDG_AttributeMap();

    /// Returns the memory usage of this attribute map
    int64                   getMemoryUsage(bool inclusive) const;

    /// Swaps the target attribute map contents with this one
    void                    swap(PDG_AttributeMap& other);

    /// Freezes the attributes in the map, which invokes a deep copy on any
    /// unowned attributes. This makes the map fully standalone, without any
    /// shallow references to external attribute maps.
    void                    freeze();

    /// Merges all attributes from another map into this one.
    bool                    mergeFull(
                                PDG_AttributeMerge& attrib_merge,
                                const PDG_AttributeMap& other,
                                AttribTable dst_table=eTableStatic,
                                bool reset=true);

    /// Merges all attributes from another attribute owner into this one.
    bool                    mergeFull(
                                PDG_AttributeMerge& attrib_merge,
                                const PDG_AttributeOwner* owner,
                                AttribTable dst_table=eTableStatic,
                                bool reset=true);

    /// Merges static attributes from another attribute owenr into this one.
    bool                    mergeStatic(
                                PDG_AttributeMerge& attrib_merge,
                                const PDG_AttributeOwner* owner);

    /// Merges dynamic attributes from another attribute owenr into this one.
    bool                    mergeDynamic(
                                PDG_AttributeMerge& attrib_merge,
                                const PDG_AttributeOwner* owner);

    /// Sets the parent map
    void                    setParentMap(PDG_AttributeOwner* parent);

    /// Resolves any pending operations in the specified attribute merge map
    void                    resolveMergeOps(PDG_AttributeMerge& attrib_merge);

    /// Erases any dynamic attributes, unowned attributes, or owned attributes
    /// that were formed by concatenating input attributes. Returns true if
    /// an attribute that was owned by this map is destroyed.
    bool                    eraseDirty(bool include_unowned);

    /// Removes any stale attributes from the map from the deserialization
    /// process
    void                    eraseStale();

    /// Erases all attributes in this map
    PDG_AttributeError      eraseAll(bool include_internal);

    /// Erases all attributes of the specified Attribute type from the map
    PDG_AttributeError      erase(PDG_AttributeType type);

    /// Erases an attribute from the map by name
    PDG_AttributeError      erase(const UT_StringHolder& name);

    /// Clears the contents of any owned concatenated attributes, but does
    /// not remove them
    void                    clearConcat(AttribTable table=eTableCount);


    /// Returns the set of time dependent attributes for this map
    bool                    timeDependentAttributes(
                                        UT_ArrayStringSet& names) const;

    /// Checks for the existance of an attribute by name. Returns true if the
    /// attribute is found, else false
    bool                    hasAttribute(const UT_StringHolder& name) const;

    /// Returns the type of the attribute with the specified name
    PDG_AttributeType       attributeType(const UT_StringHolder& name) const;

    /// Returns the size of the attribute with the specified name
    int                     attributeSize(const UT_StringHolder& name) const;

    /// Returns the set of attribute names in the map, for the specified 
    /// attribute type. Values are returned back as a string set.
    void                    attributeNames(UT_ArrayStringSet& names,
                                           PDG_AttributeType type) const;

    /// Returns the set of attribute names in the map, for the specified 
    /// attribute type. Values are returned back as an array, sorted by
    /// attribute name.
    void                    attributeNames(UT_StringArray& names,
                                           PDG_AttributeType type) const;

    /// Returns the total number of attributes in the map, for the specified
    /// atribute type.
    int                     numAttributes(PDG_AttributeType type) const;

    /// Returns true if any attributes in this map match the specified pattern
    bool                    attributeMatch(const PDG_AttributePattern& pattern,
                                           bool include_internal) const;

    /// Returns the set of attribute names in the map that match the specified
    /// attribute pattern. Returns true if anything matches, else false.
    bool                    attributeMatch(UT_ArrayStringSet& names,
                                           const PDG_AttributePattern& pattern,
                                           bool include_internal) const;

    /// Returns the set of attribute names in the map that match the specified
    /// attribute pattern and attribute type. Returns true if anything matches,
    /// else false.
    bool                    attributeMatch(UT_ArrayStringSet& names,
                                           const PDG_AttributePattern& pattern,
                                           PDG_AttributeType type,
                                           bool include_internal) const;

    /// Returns the set of attribute names in the map that match the specified
    /// attribute pattern and attribute type. Writes out the best compatible
    /// type between all matched attributes, or Undefined if no compatible type
    /// exists. Returns true if anything matches, else false.
    bool                    attributeMatch(UT_ArrayStringSet& names,
                                           PDG_AttributeType& compatible,
                                           const PDG_AttributePattern& pattern,
                                           PDG_AttributeType type,
                                           bool include_internal) const;

    /// Saves the attribute map to a JSON writer, in the most current data
    /// format
    bool                    save(UT_JSONWriter& writer,
                                 PDG_AttributeSaveType save_type,
                                 bool is_patch,
                                 bool include_bound) const;

    /// Saves the attribute map to a UT_Options, in the most current data
    /// format
    void                    save(UT_OptionsHolder& dict,
                                 PDG_AttributeSaveType save_type,
                                 bool is_patch,
                                 bool include_bound) const;

    /// Saves a single attribute holder to a JSON writer, in the most current
    /// data format.
    bool                    save(UT_JSONWriter& writer,
                                 const PDG_AttributeHolder& holder,
                                 const UT_StringHolder& name) const;

    /// Saves a single attribute holder to a UT_Options, in the most current
    /// data format.
    void                    save(UT_OptionsHolder& dict,
                                 const PDG_AttributeHolder& holder) const;

    /// Loads a V1 data format json object
    bool                    loadV1(PDG_AttributeCollision strategy,
                                   const UT_JSONValue& value);

    /// Loads a V2 data format json object
    bool                    loadV2(PDG_AttributeSaveType save_type,
                                   PDG_AttributeCollision strategy,
                                   const UT_JSONValue& value);

    /// Loads a V2 data format dictionary
    bool                    loadV2(PDG_AttributeSaveType save_type,
                                   PDG_AttributeCollision strategy,
                                   const UT_OptionsHolder& dict);

    /// Returns the attribute owner
    const PDG_AttributeOwner* owner() const
                                { return myOwner; }

    /// Returns a read-only handle to the standard input file attribute
    PDG_ROAttributeRef<PDG_AttributeFile>
                            inputFileRO(AttribTable table=eTableCount) const
    {
        return refRO<PDG_AttributeFile>(theInputFileName, table);
    }

    /// Returns a read/write handle to the standard input file attribute
    PDG_RWAttributeRef<PDG_AttributeFile>
                            inputFileRW(CreateWhen create=eCreateNever,
                                        AttribTable table=eTableCount)
    {
        return refRWC<PDG_AttributeFile>(
            theInputFileName,
            create,
            PDG_AttributeOverwrite::eMatch,
            table,
            true,
            theInputFileFlags);
    }

    /// Returns a read-only handle to the standard output file attribute
    PDG_ROAttributeRef<PDG_AttributeFile>
                            outputFileRO(AttribTable table=eTableCount) const
    {
        return refRO<PDG_AttributeFile>(theOutputFileName, table);
    }

    /// Returns a read-write handle to the standard output file attribute
    PDG_RWAttributeRef<PDG_AttributeFile>
                            outputFileRW(CreateWhen create=eCreateNever,
                                         AttribTable table=eTableCount)
    {
        return refRWC<PDG_AttributeFile>(
            theOutputFileName,
            create,
            PDG_AttributeOverwrite::eMatch,
            table,
            true,
            theOutputFileFlags);
    }

    /// Returns a read-only handle to the standard added file attribute
    PDG_ROAttributeRef<PDG_AttributeFile>
                            addedFileRO(AttribTable table=eTableCount) const
    {
        return refRO<PDG_AttributeFile>(theAddedFileName, table);
    }

    /// Returns a read/write handle to the standard input file attribute
    PDG_RWAttributeRef<PDG_AttributeFile>
                            addedFileRW(CreateWhen create=eCreateNever,
                                        AttribTable table=eTableCount)
    {
        return refRWC<PDG_AttributeFile>(
            theAddedFileName,
            create,
            PDG_AttributeOverwrite::eMatch,
            table,
            true,
            theAddedFileFlags);
    }

    /// Returns a read-only handle to the standard command string file
    /// attribute
    PDG_ROAttributeRef<PDG_AttributeString>
                            commandStringRO(AttribTable table=eTableCount) const
    {
        return refRO<PDG_AttributeString>(theCommandStringName, table);
    }

    /// Returns a read/write handle to the standard input file attribute
    PDG_RWAttributeRef<PDG_AttributeString>
                            commandStringRW(CreateWhen create=eCreateNever,
                                            AttribTable table=eTableCount)
    {
        return refRWC<PDG_AttributeString>(
            theCommandStringName,
            create,
            PDG_AttributeOverwrite::eMatch,
            table,
            true,
            theCommandStringFlags);
    }

    /// Returns a read-only handle to the standard work item label
    /// attribute
    PDG_ROAttributeRef<PDG_AttributeString>
                            labelRO(AttribTable table=eTableCount) const
    {
        return refRO<PDG_AttributeString>(theLabelName, table);
    }

    /// Returns a read/write handle to the standard work item label attribute
    PDG_RWAttributeRef<PDG_AttributeString>
                            labelRW(CreateWhen create=eCreateNever,
                                    AttribTable table=eTableCount)
    {
        return refRWC<PDG_AttributeString>(
            theLabelName,
            create,
            PDG_AttributeOverwrite::eMatch,
            table,
            true,
            theLabelFlags);
    }

    /// Returns a read-only handle to the standard work item custom state
    /// attribute
    PDG_ROAttributeRef<PDG_AttributeString>
                            stateRO(AttribTable table=eTableCount) const
    {
        return refRO<PDG_AttributeString>(theCustomStateName, table);
    }

    /// Returns a read/write handle to the standard work item custom state
    /// attribute
    PDG_RWAttributeRef<PDG_AttributeString>
                            stateRW(CreateWhen create=eCreateNever,
                                    AttribTable table=eTableCount)
    {
        return refRWC<PDG_AttributeString>(
            theCustomStateName,
            create,
            PDG_AttributeOverwrite::eMatch,
            table,
            true,
            theCustomStateFlags);
    }

    /// Returns a read-only handle to the standard work item cook progress
    /// attribute
    PDG_ROAttributeRef<PDG_AttributeFloat>
                            cookPercentRO(AttribTable table=eTableCount) const
    {
        return refRO<PDG_AttributeFloat>(theCookPercentName, table);
    }

    /// Returns a read/write handle to the standard work item custom state
    /// attribute
    PDG_RWAttributeRef<PDG_AttributeFloat>
                            cookPercentRW(CreateWhen create=eCreateNever,
                                    AttribTable table=eTableCount)
    {
        return refRWC<PDG_AttributeFloat>(
            theCookPercentName,
            create,
            PDG_AttributeOverwrite::eMatch,
            table,
            true,
            theCustomStateFlags);
    }

    /// Returns a read-only, const attribute handle. Will be invalid if the
    /// specified attribute does not exist or is of the wrong type.
    template <typename Attribute=PDG_AttributeData>
    PDG_ROAttributeRef<Attribute>
                            refRO(const UT_StringHolder& name,
                                  AttribTable table=eTableCount) const
    {
        PDG_EvaluationContext* local_ctx = PDG_EvaluationContext::getContext();
        PDG_AttributeError error;

        if (table == eTableCount)
            table = isRuntime(local_ctx) ? eTableDynamic : eTableStatic;

        const PDG_AttributeHolder* holder =
            attribHolderR<Attribute>(error, name, table, true);

        if (!holder)
            return PDG_ROAttributeRef<Attribute>(nullptr, name, myOwner, error);
        return PDG_ROAttributeRef<Attribute>(holder, name, myOwner);
    }

    /// Returns a read/write, non-const attribute handle that permits both
    /// flag and data manipulation. Does not create the attribute, but will
    /// upgrade it from a parent map/lower table if necessary. Note that this
    /// method is intionally distinct from the version below since it uses a
    /// codepath that doesn't require a concrete Attribute type in order to
    /// create an attribute reference.
    template <typename Attribute>
    PDG_RWAttributeRef<Attribute>
                            refRW(const UT_StringHolder& name)
    {
        PDG_EvaluationContext* local_ctx = PDG_EvaluationContext::getContext();
        if (!canWrite(local_ctx))
        {
            return PDG_RWAttributeRef<Attribute>(nullptr, name, myOwner,
                PDG_AttributeError::eAttributesReadOnly);
        }

        AttribTable table = isStatic(local_ctx) ? eTableStatic : eTableDynamic;

        UT_StringHolder valid;
        PDG_AttributeData::makeValidName(valid, name, false);

        PDG_AttributeError error;
        PDG_AttributeHolder* holder = attribHolderW<Attribute>(
            error, valid, table);

        if (holder)
        {
            myWasModified = true;
            return PDG_RWAttributeRef<Attribute>(holder, valid, myOwner);
        }

        return PDG_RWAttributeRef<Attribute>(nullptr, name, myOwner, error);
    }

    /// Returns a read/write, non-const attribute handle that permits both
    /// flag and data manipulation. Optionally creates the attribute if it 
    /// does not exist. Will be invalid if the specified attribute does not
    /// exist, is of the wrong type, or is marked as read-only.
    template <typename Attribute>
    PDG_RWAttributeRef<Attribute>
                            refRW(const UT_StringHolder& name,
                                  bool create,
                                  PDG_AttributeOverwrite overwrite = 
                                        PDG_AttributeOverwrite::eMatch,
                                  uint16 flags=0)
    {
        return refRWC<Attribute>(
            name,
            (create ? eCreateAlways : eCreateNever),
            overwrite, 
            eTableCount,
            false,
            flags);
    }

    /// Same as above, but with greater control on the creation flags.
    template <typename Attribute>
    PDG_RWAttributeRef<Attribute>
                            refRWC(const UT_StringHolder& name,
                                   CreateWhen create=eCreateNever,
                                   PDG_AttributeOverwrite overwrite =
                                        PDG_AttributeOverwrite::eMatch,
                                   AttribTable table=eTableCount,
                                   bool allow_internal_names=false,
                                   uint16 flags=0)
    {
        PDG_EvaluationContext* local_ctx = PDG_EvaluationContext::getContext();
        if (!canWrite(local_ctx))
        {
            return PDG_RWAttributeRef<Attribute>(nullptr, name, myOwner,
                PDG_AttributeError::eAttributesReadOnly);
        }

        UT_StringHolder valid;
        PDG_AttributeData::makeValidName(valid, name, allow_internal_names);

        if (table == eTableCount)
            table = isStatic(local_ctx) ? eTableStatic : eTableDynamic;

        PDG_AttributeError error;
        PDG_AttributeHolder* holder = attribHolderC<Attribute>(error, valid,
            create, overwrite, true, table, flags);

        if (holder)
        {
            myWasModified = true;
            return PDG_RWAttributeRef<Attribute>(holder, valid, myOwner);
        }

        return PDG_RWAttributeRef<Attribute>(nullptr, name, myOwner, error);
    }

    /// Copies the specified attribute from this map to attribute with the
    /// new name
    PDG_AttributeError      copyFrom(const UT_StringHolder& new_name,
                                     const UT_StringHolder& old_name,
                                     PDG_AttributeCopyOp copy_op,
                                     bool deep_copy)
    {
        PDG_AttributeType type = attributeType(old_name);
        if (type == PDG_AttributeType::eUndefined)
            return PDG_AttributeError::eNotFound;

        switch (type)
        {
            case PDG_AttributeType::eIntegerArray:
            {
                return copyFrom(
                    new_name,
                    refRO<PDG_AttributeInteger>(old_name),
                    copy_op,
                    deep_copy);
            }

            case PDG_AttributeType::eFloatArray:
            {
                return copyFrom(
                    new_name,
                    refRO<PDG_AttributeFloat>(old_name),
                    copy_op,
                    deep_copy);
            }

            case PDG_AttributeType::eStringArray:
            {
                return copyFrom(
                    new_name,
                    refRO<PDG_AttributeString>(old_name),
                    copy_op,
                    deep_copy);
            }

            case PDG_AttributeType::eFileArray:
            {
                return copyFrom(
                    new_name,
                    refRO<PDG_AttributeFile>(old_name),
                    copy_op,
                    deep_copy);
            }

            case PDG_AttributeType::eDictArray:
            {
                return copyFrom(
                    new_name,
                    refRO<PDG_AttributeDictionary>(old_name),
                    copy_op,
                    deep_copy);
            }

            case PDG_AttributeType::ePythonObject:
            {
                return copyFrom(
                    new_name,
                    refRO<PDG_AttributePyObject>(old_name),
                    copy_op,
                    deep_copy);
            }

            case PDG_AttributeType::eGeometry:
            {
                return copyFrom(
                    new_name,
                    refRO<PDG_AttributeGeometry>(old_name),
                    copy_op,
                    deep_copy);

            }

            default:
                return PDG_AttributeError::eUnspecified;
        }
    }

    /// Copies the specified attribute into an attribute on this map
    template <typename Attribute>
    PDG_AttributeError      copyFrom(const UT_StringHolder& name,
                                     const PDG_ROAttributeRef<Attribute>& ref,
                                     PDG_AttributeCopyOp copy_op,
                                     bool deep_copy)
    {
        PDG_EvaluationContext* local_ctx = PDG_EvaluationContext::getContext();
        if (!canWrite(local_ctx))
            return PDG_AttributeError::eAttributesReadOnly;

        UT_StringHolder valid;
        PDG_AttributeData::makeValidName(valid, name);

        AttribTable table =
            isStatic(local_ctx) ? eTableStatic : eTableDynamic;
        PDG_AttributeOverwrite overwrite;

        if (copy_op == PDG_AttributeCopyOp::eNew)
            overwrite = PDG_AttributeOverwrite::eNever;
        else if (copy_op == PDG_AttributeCopyOp::eOverwriteType)
            overwrite = PDG_AttributeOverwrite::eAlways;
        else
            overwrite = PDG_AttributeOverwrite::eMatch;

        bool array_op = 
            (copy_op == PDG_AttributeCopyOp::eAppend) ||
            (copy_op == PDG_AttributeCopyOp::ePrepend) ||
            (copy_op == PDG_AttributeCopyOp::eUpdate);

        PDG_AttributeError error;
        PDG_AttributeHolder* holder = attribHolderC<Attribute>(error, valid,
            eCreateAlways, overwrite, false, table, 0);
        if (!holder)
            return error;

        if (!ref.isArray() && array_op)
            return PDG_AttributeError::eTypeArray;

        const PDG_AttributeHolder* ref_holder = ref.holder();
        if (holder->isOwner())
        {
            holder->attribute<Attribute>()->copy(
                ref_holder->template attribute<Attribute>(),
                copy_op);
        }
        else if (holder->attribute() && array_op)
        {
            holder->own();
            holder->attribute<Attribute>()->copy(
                ref_holder->template attribute<Attribute>(),
                copy_op);
        }
        else
        {
            holder->reset(*ref_holder, false, true);

            if (deep_copy)
                holder->own();
        }

        myWasModified = true;
        return PDG_AttributeError::eNone;
    }

    /// Renames the specififed attribute
    PDG_AttributeError      rename(const UT_StringHolder& src_name,
                                   const UT_StringHolder& dst_name,
                                   bool overwrite)
    {
        // Attributes cannot be renamed if we don't have write access
        PDG_EvaluationContext* local_ctx = PDG_EvaluationContext::getContext();
        if (!canWrite(local_ctx))
            return PDG_AttributeError::eAttributesReadOnly;

        AttribTable table =
            isStatic(local_ctx) ? eTableStatic : eTableDynamic;

        PDG_AttributeHolder* holder = nullptr;
        AttribTable src_table = eTableCount;

        // Find the attribute in the desired table, or lower table if it does
        // not exist
        for (int i = table; i >= 0; i--)
        {
            auto&& attrib = myAttributes[i].find(src_name);
            if (attrib != myAttributes[i].end())
            {
                holder = attrib->second.get();
                src_table = static_cast<AttribTable>(i);
                break;
            }
        }

        // If the attribute only exists in a lower table, return an error since
        // we cannot manipulate that table.
        if (src_table < table)
            return PDG_AttributeError::eReadOnly;

        // If there's no holder, there's nothing to rename
        if (!holder)
            return PDG_AttributeError::eNotFound;

        // Disallow renaming of write protected attributes
        if (holder->hasFlag(PDG_AttributeFlag::eReadOnlyFlag))
            return PDG_AttributeError::eReadOnly;

        // Disallow renaming of internal attributes
        if (holder->hasFlag(PDG_AttributeFlag::eInternalFlag))
            return PDG_AttributeError::eInternal;

        // Create a valid destination name
        UT_StringHolder valid;
        PDG_AttributeData::makeValidName(valid, dst_name);

        // Check for an existing attribute with the dest name
        auto&& iter = myAttributes[table].find(valid);
        if (iter != myAttributes[table].end())
        {
            // Internal attributes can never be the destination of a rename
            if (iter->second->hasFlag(PDG_AttributeFlag::eInternalFlag))
                return PDG_AttributeError::eInternal;
            // Return early if the caller doesn't want to overwrite
            else if (!overwrite)
                return PDG_AttributeError::eOverwrite;

            // Erase the existing attribute
            myAttributes[table].erase(iter);
        }

        // Move the attribute into the map entry with the new name
        HolderPtr holder_copy = 
            UTmakeUnique<PDG_AttributeHolder>(std::move(*holder));
        myAttributes[table].emplace(valid, std::move(holder_copy));
        myAttributes[table].erase(src_name);

        myWasModified = true;
        return PDG_AttributeError::eNone;
    }

    /// Utility method that looks up a value from an attribute, with a given
    /// index, and an optional flag filter
    template <typename Attribute>
    bool                    value(typename Attribute::Data& value,
                                  const UT_StringHolder& name,
                                  int index,
                                  uint16 flags = 0) const
    {
        auto&& attribute = refRO<Attribute>(name);
        if (!attribute || !attribute.hasFlags(flags))
            return false;
        if (attribute.hasFlag(PDG_AttributeFlag::eInternalFlag))
            return false;

        return attribute->value(value, index);
    }

    /// Utility method that looks up an array value from an attribute, with an
    /// optional flag filter
    template <typename Attribute>
    bool                    value(typename Attribute::Array& value,
                                  const UT_StringHolder& name,
                                  uint16 flags = 0) const
    {
        auto&& attribute = refRO<Attribute>(name);
        if (!attribute || !attribute.hasFlags(flags))
            return false;
        if (attribute.hasFlag(PDG_AttributeFlag::eInternalFlag))
            return false;

        value = attribute->values();
        return true;
    }

    /// Utility method that sets an attribute value at a specified index, and
    /// creates it if it does not already exist
    template <typename Attribute>
    PDG_AttributeError      setValue(const UT_StringHolder& name,
                                     const typename Attribute::Data& value,
                                     int index,
                                     bool create,
                                     PDG_AttributeOverwrite overwrite = 
                                        PDG_AttributeOverwrite::eMatch)
    {
        auto&& attribute = refRW<Attribute>(name, create, overwrite);
        if (!attribute)
            return attribute.error();
        attribute->setValue(value, index);
        return PDG_AttributeError::eNone;
    }

    /// Utility method that sets an attribute array value, and creates it if
    /// it does not already exist
    template <typename Attribute>
    PDG_AttributeError      setValue(const UT_StringHolder& name,
                                     const typename Attribute::Array& values,
                                     bool create,
                                     PDG_AttributeOverwrite overwrite = 
                                        PDG_AttributeOverwrite::eMatch)
    {
        auto&& attribute = refRW<Attribute>(name, create, overwrite);
        if (!attribute)
            return attribute.error();
        attribute->setValue(values);
        return PDG_AttributeError::eNone;
    }

    /// Utility method that clears all values from an attribute, and creates
    /// it if it does not already exist
    template <typename Attribute>
    PDG_AttributeError      clearValues(const UT_StringHolder& name,
                                        bool create,
                                        PDG_AttributeOverwrite overwrite = 
                                            PDG_AttributeOverwrite::eMatch)
    {
        auto&& attribute = refRW<Attribute>(name, create, overwrite);
        if (!attribute)
            return attribute.error();
        attribute->clear();
        return PDG_AttributeError::eNone;
    }

    /// Queries all values of the specified attribute type and returns them as 
    /// a map.
    template <typename Attribute>
    bool                    values(typename Attribute::Map& value_map,
                                   uint16 flags = 0) const
    {
        values<Attribute>(eTableStatic, value_map, flags);
        PDG_EvaluationContext* local_ctx = PDG_EvaluationContext::getContext();
        if (isRuntime(local_ctx))
            values<Attribute>(eTableDynamic, value_map, flags);
        return true;
    }

    /// Queries a scalar value by name/index and stores it as a PDGT_Value
    bool                    value(PDGT_Value& value,
                                  const UT_StringHolder& name,
                                  int index,
                                  uint16 flags = 0) const;

    /// Queries all values as PDGT_Values
    bool                    values(PDGT_Value::Map& value_map,
                                   uint16 flags = 0) const;


    /// Returns true if attribute has the the specified flag set, else false
    bool                    hasFlag(const UT_StringHolder& name,
                                    PDG_AttributeFlag flag) const;

    /// Sets or clears a flag on the specified attribute
    PDG_AttributeError      setFlag(const UT_StringHolder& name,
                                    PDG_AttributeFlag flag,
                                    bool set);

    /// Sets or clears a flag on all attributes
    bool                    setFlagAll(PDG_AttributeFlag flag,
                                       bool set);


    /// Begins tracking attribute changes
    void                    startChangeTracking(); 

    /// Ends tracking changes, returning true if a change made was
    ChangeResult            endChangeTracking(bool check_all);

    /// Computes the hash value for attrib values, errors can occur if python
    /// objects hash() raises an exception.
    bool                    hash(SYS_HashType& hash_val,
                                 AttribTable table,
                                 bool include_internal,
                                 bool include_unowned,
                                 UT_WorkBuffer& errors) const;

    /// Computes the hash value for the specific attribute values specified in
    /// the set of names. This is the same as the function above, but it
    /// only applies to the indicated subset of attribs.
    bool                    hash(SYS_HashType& hash_val,
                                 const UT_ArrayStringSet& filter,
                                 AttribTable table,
                                 bool include_internal,
                                 bool include_unowned,
                                 UT_WorkBuffer& errors) const;

private:
    /// Managed attribute holder pointer
    using HolderPtr = UT_UniquePtr<PDG_AttributeHolder>;

    /// String map to attribute holder - the actual storage type of this 
    /// structure
    using Map       = UT_ArrayStringMap<HolderPtr>;

private:
    /// Returns the attribute lock for this attribute map
    UT_RWLock&              attributeLock() const;

    /// Returns the global attribute lock for this map
    UT_RWLock*              globalLock() const;

    /// Called when the map is unlocked
    void                    onUnlock() const;

    /// Internal logic for hashing attributes
    bool                    hashAttributes(
                                SYS_HashType& hash_val,
                                const UT_ArrayStringSet& filter,
                                AttribTable table,
                                bool include_internal,
                                bool include_unowned,
                                UT_WorkBuffer& errors) const;

    /// Returns the sorted set of attribute names for a save operation
    void                    saveNames(
                                UT_SortedStringSet& names,
                                PDG_AttributeSaveType save_type) const;

    /// Returns the attribute holder for the specified name and save options,
    /// or nullptr if no valid holder meets the save settings
    const PDG_AttributeHolder*
                            saveHolder(
                                const UT_StringHolder& name,
                                PDG_AttributeSaveType save_type,
                                AttribTable table,
                                bool is_patch,
                                bool include_bound) const;

    /// Returns a reference to the shared, static invalid attribute reg
    static PDG_AttributeHolder&
                            invalidHolder();

    /// Returns true if the attribute owenr that owns this attribute map can
    /// create RW attribute references
    bool                    canWrite(const PDG_EvaluationContext* ctx) const;

    /// Returns true if called during a runtime/cook operation, instead of a
    /// generation operation
    bool                    isRuntime(const PDG_EvaluationContext* ctx) const;

    /// Returns true if called during work item generation
    bool                    isStatic(const PDG_EvaluationContext* ctx) const;

    /// Returns true if the specified attribute exists in the table
    bool                    hasAttribute(const UT_StringHolder& name,
                                         AttribTable table) const
    {
        if (myParentMap && myParentMap->hasAttribute(name, table))
            return true;
        return (myAttributes[table].find(name) != myAttributes[table].end());
    }

    /// Merges attributes from the source table in another map to dst
    /// table in this map.
    bool                    mergeMap(
                                PDG_AttributeMerge& attrib_merge,
                                UT_StringSet& exclusion_set,
                                const PDG_AttributeMap& other,
                                AttribTable src_table,
                                AttribTable dst_table,
                                bool flatten_dynamic);

    /// Merges an attribute from a different map into the dst table in this
    /// map.
    bool                    mergeAttribute(
                                PDG_AttributeMerge& attrib_merge,
                                UT_StringSet& exclusion_set,
                                const PDG_AttributeHolder& other_holder,
                                const UT_StringHolder& name,
                                AttribTable dst_table);

    /// Loads an attribute from the json value, with the specified name, type
    /// and flags
    bool                    loadAttribute(AttribTable table,
                                          PDG_AttributeCollision strategy,
                                          PDG_AttributeType type,
                                          const UT_StringHolder& name,
                                          uint16 flags,
                                          bool is_own,
                                          bool is_concat,
                                          const UT_JSONValue& data);

    /// Loads an attribute from the dict, with the specified name, type
    /// and flags
    bool                    loadAttribute(AttribTable table,
                                          PDG_AttributeCollision strategy,
                                          PDG_AttributeType type,
                                          const UT_StringHolder& name,
                                          uint16 flags,
                                          bool is_own,
                                          bool is_concat,
                                          const UT_OptionsHolder& dict);

    /// Loads an old-style attribute entry from json
    bool                    loadV1Map(PDG_AttributeCollision strategy,
                                      PDG_AttributeType type,
                                      const UT_JSONValue& data);

    /// Saves the values from the specified map into an instace of a generic
    /// data map
    bool                    values(AttribTable table,
                                   PDGT_Value::Map& value_map,
                                   uint16 flags) const
    {
        if (myParentMap)
            myParentMap->values(table, value_map, flags);

        for (auto&& attrib_pair : myAttributes[table])
        {
            const PDG_AttributeHolder& holder = *attrib_pair.second;
            if (!holder.hasFlags(flags))
                continue;
            if (holder.hasFlag(PDG_AttributeFlag::eInternalFlag))
                continue;
            if (!attribToValue(value_map[attrib_pair.first], 0, holder))
                return false;
        }

        return true;
    }

    /// Saves the values from the specified map into an instance of the map
    /// data type
    template <typename Attribute>
    void                    values(AttribTable table,
                                   typename Attribute::Map& value_map,
                                   uint16 flags) const
    {
        if (myParentMap)
            myParentMap->values<Attribute>(table, value_map, flags);

        for (auto&& attrib_pair : myAttributes[table])
        {
            const PDG_AttributeHolder& holder = *attrib_pair.second;
            if (!holder.typeMatch<Attribute>())
            {
                value_map.erase(attrib_pair.first);
                continue;
            }

            if (!holder.hasFlags(flags))
                continue;
            if (holder.hasFlag(PDG_AttributeFlag::eInternalFlag))
                continue;

            const Attribute* attribute = holder.attribute<Attribute>();
            if (attribute)
                value_map[attrib_pair.first] = attribute->values();
        }
    }

    /// Returns the size of an attribute
    static int              attribSize(const PDG_AttributeHolder& src)
    {
        switch (src.type())
        {
            case PDG_AttributeType::eIntegerArray:
                return src.attribute<PDG_AttributeInteger>()->size();
            case PDG_AttributeType::eFloatArray:
                return src.attribute<PDG_AttributeFloat>()->size();
            case PDG_AttributeType::eStringArray:
                return src.attribute<PDG_AttributeString>()->size();
            case PDG_AttributeType::eFileArray:
                return src.attribute<PDG_AttributeFile>()->size();
            case PDG_AttributeType::eDictArray:
                return src.attribute<PDG_AttributeDictionary>()->size();
            case PDG_AttributeType::ePythonObject:
                return src.attribute<PDG_AttributePyObject>()->size();
            case PDG_AttributeType::eGeometry:
                return src.attribute<PDG_AttributeGeometry>()->size();
            default:
                return -1;
        }
    }

    /// Concatenates an attribute
    static bool             attribConcat(PDG_AttributeHolder& dst,
                                         const PDG_AttributeHolder& src)
    {
        if (src.type() != dst.type())
            return false;

        switch (dst.type())
        {
            case PDG_AttributeType::eIntegerArray:
                return dst.concat<PDG_AttributeInteger>(src);
            case PDG_AttributeType::eFloatArray:
                return dst.concat<PDG_AttributeFloat>(src);
            case PDG_AttributeType::eStringArray:
                return dst.concat<PDG_AttributeString>(src);
            case PDG_AttributeType::eFileArray:
                return dst.concat<PDG_AttributeFile>(src);
            case PDG_AttributeType::eDictArray:
                return dst.concat<PDG_AttributeDictionary>(src);
            default:
                return false;
        }

        return true;
    }

    /// Updates the size of an attribute
    static bool             attribAdjustSize(PDG_AttributeHolder& attrib,
                                             int offset)
    {
        switch (attrib.type())
        {
            case PDG_AttributeType::eIntegerArray:
                return attrib.adjustSize<PDG_AttributeInteger>(offset);
            case PDG_AttributeType::eFloatArray:
                return attrib.adjustSize<PDG_AttributeFloat>(offset);
            case PDG_AttributeType::eStringArray:
                return attrib.adjustSize<PDG_AttributeString>(offset);
            case PDG_AttributeType::eFileArray:
                return attrib.adjustSize<PDG_AttributeFile>(offset);
            case PDG_AttributeType::eDictArray:
                return attrib.adjustSize<PDG_AttributeDictionary>(offset);
            default:
                return false;
        }

        return true;
    }

    /// Clears an attribute
    static void             attribClear(PDG_AttributeHolder& attrib)
    {
        switch (attrib.type())
        {
            case PDG_AttributeType::eIntegerArray:
                attrib.clear<PDG_AttributeInteger>();
                break;
            case PDG_AttributeType::eFloatArray:
                attrib.clear<PDG_AttributeFloat>();
                break;
            case PDG_AttributeType::eStringArray:
                attrib.clear<PDG_AttributeString>();
                break;
            case PDG_AttributeType::eFileArray:
                attrib.clear<PDG_AttributeFile>();
                break;
            case PDG_AttributeType::eDictArray:
                attrib.clear<PDG_AttributeDictionary>();
                break;
            default:
                break;
        }
    }

    /// Saves the name of the specified attribute to the PDGT_Value variant.
    static bool             attribToValue(PDGT_Value& value,
                                          int index,
                                          const PDG_AttributeHolder& holder)
    {
        switch (holder.type())
        {
            case PDG_AttributeType::eFloatArray:
                return attribToValue<PDG_AttributeFloat>(value, index, holder);
            case PDG_AttributeType::eIntegerArray:
                return attribToValue<PDG_AttributeInteger>(value, index, holder);
            case PDG_AttributeType::eStringArray:
                return attribToValue<PDG_AttributeString>(value, index, holder);
            case PDG_AttributeType::eFileArray:
            {
                typename PDG_AttributeFile::Data temp;
                if (holder.attribute<PDG_AttributeFile>()->value(temp, index))
                    value.setValue(temp.local_data());
                else
                    value.setValue("");
                return true;    
            }
            case PDG_AttributeType::eDictArray:
            {
                UT_WorkBuffer buffer;
                if (holder.attribute<PDG_AttributeDictionary>()->desc(
                        buffer, index))
                {
                    value.setValue(buffer.buffer());
                }
                else
                    value.setValue("");
                return true;    
            }
            case PDG_AttributeType::ePythonObject:
            {
                UT_StringHolder str;
                if (holder.attribute<PDG_AttributePyObject>()->str(str))
                    value.setValue(str);
                else
                    value.setValue("");
                return true;
            }
            case PDG_AttributeType::eGeometry:
            {
                UT_StringHolder str;
                if (holder.attribute<PDG_AttributeGeometry>()->desc(str))
                    value.setValue(str);
                else
                    value.setValue("");
                return true;

            }
            default:
                return false;
        }

        return false;
    }

    /// Helper method for storing an attribute value to a PDGT_Value variant.
    template <typename Attribute>
    static bool             attribToValue(PDGT_Value& value,
                                          int index,
                                          const PDG_AttributeHolder& holder)
    {
        typename Attribute::Data temp;
        if (holder.attribute<Attribute>()->value(temp, index))
            value.setValue(temp);
        else
            value.setValue(typename Attribute::Data());

        return true;    
    }

    /// Returns a const attribute holder an existing static or dynamic
    /// attribute. Uses the local context to determine if dynamic access
    /// is permitted.
    template <typename Attribute>
    const PDG_AttributeHolder*
                            attribHolderR(const UT_StringHolder& name) const
    {
        PDG_AttributeError error;
        PDG_EvaluationContext* local_ctx = PDG_EvaluationContext::getContext();
        AttribTable table = isRuntime(local_ctx) ? eTableDynamic : eTableStatic;
        return attribHolderR<Attribute>(error, name, table, true);
    }

    /// Returns an const attribute holder to an existing static or dynamic
    /// attribute. Does not create the attribute if it does not exist.
    template <typename Attribute>
    const PDG_AttributeHolder*
                            attribHolderR(PDG_AttributeError& error,
                                          const UT_StringHolder& name,
                                          AttribTable table,
                                          bool check_parent) const
    {
        const PDG_AttributeHolder* holder = nullptr;
        for (int i = table; i >= 0; i--)
        {
            auto&& attrib = myAttributes[i].find(name);
            if (attrib != myAttributes[i].end())
            {
                holder = attrib->second.get();
                break;
            }
        }

        if (!holder)
        {
            if (myParentMap && check_parent)
            {
                return myParentMap->attribHolderR<Attribute>(
                    error, name, table, true);
            }

            error = PDG_AttributeError::eNotFound;
            return nullptr;
        }

        if (!holder->typeMatch<Attribute>())
        {
            error = PDG_AttributeError::eTypeConflict;
            return nullptr;
        }

        error = PDG_AttributeError::eNone;
        return holder;
    }

    /// Returns an attribute holder for an existing or new attribute, either
    /// static or dynamic. If the attribute is static but we need a dynamic
    /// one, the existing static attribute is copied to the dynamic map.
    template <typename Attribute>
    PDG_AttributeHolder*    attribHolderW(PDG_AttributeError& error,
                                          const UT_StringHolder& name,
                                          AttribTable table)
    {
        PDG_AttributeHolder* holder = nullptr;
        AttribTable src_table = eTableCount;

        // Check for the attribute in the desired table, and work downwards if
        // its not found
        for (int i = table; i >= 0; i--)
        {
            auto&& attrib = myAttributes[i].find(name);
            if (attrib != myAttributes[i].end())
            {
                holder = attrib->second.get();
                src_table = static_cast<AttribTable>(i);
                break;
            }
        }

        // If the attribute doesn't exist anywhere, check the parent map first
        // before returning an error.
        if (!holder)
        {
            // If a parent map is set, check for the attribute on the parent
            if (myParentMap)
            {
                const PDG_AttributeHolder* parent =
                    attribHolderR<Attribute>(error, name, table, true);
            
                // We never create an attribute on the parent map, but if one
                // does exist make a copy of it and store it on this map.
                if (parent)
                {
                    HolderPtr new_holder = UTmakeUnique<PDG_AttributeHolder>();
                    new_holder->reset(*parent, parent->isOwner(), true);
                    auto&& insert = myAttributes[table].emplace(
                        name, std::move(new_holder));
                    error = PDG_AttributeError::eNone;
                    return insert.first->second.get();
                }
            }

            error = PDG_AttributeError::eNotFound;
            return nullptr;
        }

        // Read only attributes cannot be accessed for writing in any case
        if (holder->hasFlag(PDG_AttributeFlag::eReadOnlyFlag))
        {
            error = PDG_AttributeError::eReadOnly;
            return nullptr;
        }

        // If the attribute exists in any of the tables but is the wrong type,
        // this is always an error.
        if (!holder->typeMatch<Attribute>())
        {
            error = PDG_AttributeError::eTypeConflict;
            return nullptr;
        }

        // If the attribute was found in a lower table than the one that was
        // requested, only create the attribute if the creation mode is
        // Always or Upgrade.
        if (src_table < table)
        {
            HolderPtr holder_copy = UTmakeUnique<PDG_AttributeHolder>();
            holder_copy->reset(*holder, holder->isOwner(), true);

            auto&& insert = myAttributes[table].emplace(
                name, std::move(holder_copy));
            error = PDG_AttributeError::eNone;
            return insert.first->second.get();
        }

        error = PDG_AttributeError::eNone;
        return holder;
    }

    /// Returns an attribute holder for an existing or new attribute, either
    /// static or dynamic. If the attribute is static but we need a dynamic
    /// one, the existing static attribute is copied to the dynamic map. This
    /// method will also create the attribute if needed, or if the type does
    /// not match, depending on the creation/overwrite options.
    template <typename Attribute>
    PDG_AttributeHolder*    attribHolderC(PDG_AttributeError& error,
                                          const UT_StringHolder& name,
                                          CreateWhen create,
                                          PDG_AttributeOverwrite overwrite,
                                          bool own,
                                          AttribTable table,
                                          uint16 flags)
    {
        PDG_AttributeHolder* holder = nullptr;
        AttribTable src_table = eTableCount;

        // Check for the attribute in the desired table, and work downwards if
        // its not found
        for (int i = table; i >= 0; i--)
        {
            auto&& attrib = myAttributes[i].find(name);
            if (attrib != myAttributes[i].end())
            {
                holder = attrib->second.get();
                src_table = static_cast<AttribTable>(i);
                break;
            }
        }

        // If the attribute doesn't exist anywhere, only create it when the
        // create mode is Always.
        if (!holder)
        {
            // If a parent map is set, check for the attribute on the parent
            if (myParentMap)
            {
                const PDG_AttributeHolder* parent =
                    attribHolderR<Attribute>(error, name, table, true);
            
                // We never create an attribute on the parent map, but if one
                // does exist and we were request to upgrade if possible, make
                // a copy of it and store it on this map.
                if (parent)
                {
                    if (create == eCreateNever)
                    {
                        error = PDG_AttributeError::eTypeUpgrade;
                        return nullptr;
                    }

                    HolderPtr new_holder = UTmakeUnique<PDG_AttributeHolder>();
                    new_holder->reset(*parent, parent->isOwner(), true);

                    auto&& insert = myAttributes[table].emplace(
                        name, std::move(new_holder));
                    error = PDG_AttributeError::eNone;
                    return insert.first->second.get();
                }
            }

            if (create != eCreateAlways)
            {
                error = PDG_AttributeError::eNotFound;
                return nullptr;
            }

            HolderPtr holder = UTmakeUnique<PDG_AttributeHolder>(
                own ? new Attribute() : nullptr,
                Attribute::TypeEnum,
                flags,
                own,
                false);

            auto&& insert = myAttributes[table].emplace(
                name, std::move(holder));
            error = PDG_AttributeError::eNone;
            return insert.first->second.get();
        }

        // If overwrite is off, we don't return back a holder
        if (overwrite == PDG_AttributeOverwrite::eNever)
        {
            error = PDG_AttributeError::eOverwrite;
            return nullptr;
        }

        // Read only attributes cannot be accessed for writing in any case
        if (holder->hasFlag(PDG_AttributeFlag::eReadOnlyFlag))
        {
            error = PDG_AttributeError::eReadOnly;
            return nullptr;
        }

        // If the attribute exists in any of the tables but is the wrong type,
        // this is always an error.
        bool type_match = holder->typeMatch<Attribute>();
        if (!type_match && (overwrite != PDG_AttributeOverwrite::eAlways))
        {
            error = PDG_AttributeError::eTypeConflict;
            return nullptr;
        }

        // If the attribute was found in a lower table than the one that was
        // requested, only create the attribute if the creation mode is
        // Always or Upgrade.
        if (src_table < table)
        {
            if (create == eCreateNever)
            {
                error = PDG_AttributeError::eTypeUpgrade;
                return nullptr;
            }

            HolderPtr holder_copy = UTmakeUnique<PDG_AttributeHolder>();
            if (!type_match)
            {
                holder_copy->reset(
                    new Attribute(),
                    Attribute::TypeEnum,
                    flags,
                    own,
                    false,
                    false);
            }
            else
                holder_copy->reset(*holder, holder->isOwner(), true);

            auto&& insert = myAttributes[table].emplace(
                name, std::move(holder_copy));
            error = PDG_AttributeError::eNone;
            return insert.first->second.get();
        }

        error = PDG_AttributeError::eNone;
        if (!type_match)
        {
            holder->reset(
                new Attribute(), Attribute::TypeEnum, flags, own, false, false);
        }

        return holder;
    }

private:
    Map                         myAttributes[eTableCount];
    UT_UniquePtr<Map[]>         myStaleAttributes;
    const PDG_AttributeOwner*   myOwner;
    PDG_AttributeMap*           myParentMap;
    mutable UT_RWLock           myAttributeLock;

    bool                        myHasRuntimeAttribs;
    mutable bool                myWasModified;
};

#endif