PDG_AttributeRef.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_REF_H__
#define __PDG_ATTRIBUTE_REF_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_AttributeQuery.h"
#include "PDG_AttributeTypes.h"

#include <UT/UT_Options.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_WorkBuffer.h>

#include <SYS/SYS_Hash.h>

class PDG_AttributeOwner;
class PDG_Node;
class PDG_Scheduler;

/**
 * Base class for attribute references
 */
class PDG_API PDG_AttributeRef
{
public:
    explicit PDG_AttributeRef(const UT_StringHolder& name,
                              const PDG_AttributeOwner* owner,
                              PDG_AttributeError error = 
                                    PDG_AttributeError::eNone)
        : myName(name)
        , myOwner(owner)
        , myError(error)
    {
    }

    /// Returns true if the handle is valid
    inline                      operator bool() const
                                { return isValid(); }

    /// Returns true if the handle is valid
    inline bool                 isValid() const
                                    { return (myError == PDG_AttributeError::eNone);}

    /// Returns the error state of the handle
    inline PDG_AttributeError    error() const
                                    { return myError; }

    /// Returns the name of the attribute referenced by this attrib ref
    inline const UT_StringHolder&
                                name() const
                                    { return myName; }

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

    /// Returns false and Writes an attribute error message into the buffer if
    /// an error exists, or returns trues and does not modify the buffer if no
    /// error has been recorded.
    bool                        validate(UT_WorkBuffer& buffer) const;

    /// Same as above, except the attribute error is reported on the specified
    /// node instead of returned as a buffer, if an error has occured. The
    /// method still returns true if no error has occured, and false if one
    /// has.
    /// 
    /// The report_errors argument is provided as a convenience, to make it 
    /// possible to parametrically skip error reporting
    bool                        validate(
                                    const PDG_Node* node,
                                    PDG_AttributeErrorLevel level) const;

    /// Writes an attribute error format message to the buffer, based on the
    /// supply error, attrib name and optional work item. Returns True if no
    /// error is detected, or false if an error occured.
    static bool                 attributeError(
                                    UT_WorkBuffer& buffer,
                                    PDG_AttributeError error,
                                    const UT_StringHolder& attrib_name,
                                    const PDG_AttributeOwner* owner=nullptr);

    /// Emits events when the attribute is modified
    static void                 attributeModified(
                                    const PDG_AttributeOwner* owner,
                                    PDG_AttributeType attrib_type,
                                    const UT_StringHolder& attrib_name);

    /// Localizes a path with the specified scheduler
    static UT_StringHolder      localizePath(
                                    const UT_StringHolder& path,
                                    const PDG_Scheduler* scheduler);

protected:
    UT_StringHolder             myName;
    const PDG_AttributeOwner*   myOwner;
    PDG_AttributeError          myError;
};

/**
 * Base class for templated attribute references
 */
template <typename Attribute, typename Holder>
class PDG_API_TMPL PDG_AttributeRefT : public PDG_AttributeRef
{
public:
    using Self = PDG_AttributeRefT<Attribute, Holder>;

public:
    explicit PDG_AttributeRefT(Holder* holder,
                               const UT_StringHolder& name,
                               const PDG_AttributeOwner* owner,
                               PDG_AttributeError error = 
                                    PDG_AttributeError::eNone)
        : PDG_AttributeRef(name, owner, error)
        , myHolder(holder)
    {
    }

    /// Returns the underlying attribute holder
    inline Holder*                  holder() const
    {
        return myHolder;
    }

    /// Returns a const pointer to the underlying attribute instance
    inline const Attribute*         attribute() const
    {
        return myHolder->template attribute<const Attribute>();
    }

    /// Returns a const pointer to the underlying attribute instance,
    /// casted to the specified type
    template <typename T> const T*  attributeT() const
    {
        return myHolder->template attribute<const T>();
    }

    /// Returns a const pointer to the underlying attribute instance
    inline const Attribute*         operator->() const
    {
        return attribute();
    }

    /// Returns true if the contained attribute has any data
    inline bool                     hasData() const
    {
        return myHolder->template hasData<Attribute>();
    }

    /// Returns true if the contained attribute holder owns its data
    inline bool                     isOwner() const
    {
        return myHolder->isOwner();
    }

    /// Returns the type of the contained attribute
    inline PDG_AttributeType        type() const
    {
        return myHolder->type();
    }

    /// Returns the flags on the contained holder
    inline uint16                   flags() const
    {
        return myHolder->flags();
    }

    /// Returns true if the contained holder has any flags set
    inline bool                     hasAnyFlags() const
    {
        return myHolder->hasAnyFlags();
    }

    /// Returns true if the contained holder has the specified flag set
    inline bool                     hasFlag(PDG_AttributeFlag flag) const
    {
        return myHolder->hasFlag(flag);
    }

    /// Returns true if the contained holder has all of the specified flags set
    inline bool                     hasFlags(uint16 flags) const
    {
        return myHolder->hasFlags(flags);
    }

    /// Returns true if the contained holder has any of the specified flags set
    inline bool                     hasAnyFlags(uint16 flags) const
    {
        return myHolder->hasAnyFlags(flags);
    }

    /// Returns true if the attribute is numeric
    inline bool                     isNumeric() const
    {
        return (myHolder->type() == PDG_AttributeType::eIntegerArray) ||
               (myHolder->type() == PDG_AttributeType::eFloatArray);
    }

    /// Returns true if the attribute is an array
    inline bool                     isArray() const
    {
        return PDG_AttributeData::isArrayType(myHolder->type());
    }

    /// Returns a hash of the name, flags and values of the attribute
    inline bool                     hash(
                                        SYS_HashType& result,
                                        exint index,
                                        bool include_value,
                                        bool include_name,
                                        bool include_flags,
                                        UT_WorkBuffer& errors) const
    {
        result = 0;

        if (include_name)
            SYShashCombine(result, myName);

        if (include_value)
        {
            SYS_HashType attrib_hash = 0;
            if (!attribute()->hash(attrib_hash, index, errors))
                return false;

            SYShashCombine(result, attrib_hash);
        }

        if (include_flags)
            SYShashCombine(result, flags());

        return true;
    }

    /// Casts the value contained in the attribute at the particular index to a
    /// numeric value, by looking up the value with the query string. Falls
    /// a regular cast if query strings aren't supported
    inline PDG_AttributeCast        asNumber(fpreal& number,
                                             exint& query_index,
                                             const PDG_AttributeQuery& query,
                                             int index,
                                             bool has_component) const
    {
        if (myHolder->type() == PDG_AttributeType::ePythonObject)
        {
            if (!has_component)
                index = -1;
            return myHolder->template attribute<PDG_AttributePyObject>()->query(
                number, query, index);
        }
        else if (myHolder->type() == PDG_AttributeType::eDictArray)
        {
            if (!has_component)
                index = 0;
            return myHolder->template attribute<PDG_AttributeDictionary>()->query(
                number, query, query_index, index);
        }

        return asNumber(number, index);
    }

    /// Casts the value contained in the attribute at the particular index to a
    /// numeric value, if possible.
    inline PDG_AttributeCast        asNumber(fpreal& number, int index) const
    {
        if (myHolder->type() == PDG_AttributeType::eIntegerArray)
        {
            PDG_AttributeInteger::Data temp;
            if (myHolder->template attribute<PDG_AttributeInteger>()->value(
                    temp, index))
            {
                number = temp;
                return PDG_AttributeCast::eSuccess;
            }

            return PDG_AttributeCast::eErrorBounds;
        }
        else if (myHolder->type() == PDG_AttributeType::eFloatArray)
        {
            if (myHolder->template attribute<PDG_AttributeFloat>()->value(
                number, index))
            {
                return PDG_AttributeCast::eSuccess;
            }

            return PDG_AttributeCast::eErrorBounds;
        }

        return PDG_AttributeCast::eErrorType;
    }

    /// Casts the value contained in the attribute to a numeric array, if
    /// possible.
    template <typename Array> 
    inline PDG_AttributeCast        asNumbers(Array& array) const
    {
        if (myHolder->type() == PDG_AttributeType::eIntegerArray)
        {
            auto&& attr = myHolder->template attribute<PDG_AttributeInteger>();
            for (exint i = 0; i < attr->size(); i++)
                array.append(attr->value(i));
            return PDG_AttributeCast::eSuccess;
        }
        else if (myHolder->type() == PDG_AttributeType::eFloatArray)
        {
            auto&& attr = myHolder->template attribute<PDG_AttributeFloat>();
            for (exint i = 0; i < attr->size(); i++)
                array.append(attr->value(i));
            return PDG_AttributeCast::eSuccess;
        }

        return PDG_AttributeCast::eErrorType;
    }

    /// Returns a file path from the attribute, using the specified index and
    /// tag filter. If a scheduler is supplied, the path is localized with the
    /// scheduler. Only valid for files and strings. For string attributes the
    /// tag is ignored and assumed to match
    inline PDG_AttributeCast        asFilePath(
                                        UT_StringHolder& path,
                                        int index,
                                        const UT_StringHolder& tag,
                                        const PDG_Scheduler* scheduler,
                                        bool localize)
    {
        if (myHolder->type() == PDG_AttributeType::eStringArray)
        {
            if (!myHolder->template attribute<PDG_AttributeString>()->value(
                    path, index))
            {
                return PDG_AttributeCast::eErrorBounds;
            }

            if (localize)
                path = localizePath(path, scheduler);

            return PDG_AttributeCast::eSuccess;
        }
        else if (myHolder->type() == PDG_AttributeType::eFileArray)
        {
            PDG_File file;
            PDG_AttributeCast result =
                myHolder->template attribute<PDG_AttributeFile>()->valueForTag(
                    file, index, tag);
            if (result != PDG_AttributeCast::eSuccess)
                return result;

            if (localize)
                path = file.localizePath(scheduler);
            else
                path = file.data();

            return PDG_AttributeCast::eSuccess;
        }

        return PDG_AttributeCast::eErrorType;
    }

    /// Returns a space-separate string of file path(s) from the attribute,
    /// using all values in the attribute and the specified tag filter. If a
    /// scheduler is supplied, the paths are localized with the scheduler. Only
    /// valid for files and strings. For string attributes the tag is ignored
    /// and assumed to match
    inline PDG_AttributeCast        asFilePathValues(
                                        UT_WorkBuffer& buffer,
                                        const UT_StringHolder& tag,
                                        const PDG_Scheduler* scheduler,
                                        bool localize)
    {
        if (myHolder->type() == PDG_AttributeType::eStringArray)
        {
            auto&& values = myHolder->template
                attribute<PDG_AttributeString>()->values();
            for (auto&& value : values)
            {
                UT_StringHolder path;
                if (localize)
                    path = localizePath(value, scheduler);
                else
                    path = value;

                UT_String wrap(path);
                wrap.protectString();
                buffer.appendSprintf("%s ", wrap.buffer());
            }

            buffer.removeTrailingSpace();
            return PDG_AttributeCast::eSuccess;
        }
        else if (myHolder->type() == PDG_AttributeType::eFileArray)
        {
            auto&& values = myHolder->template
                attribute<PDG_AttributeFile>()->values();
            for (auto&& value : values)
            {
                UT_StringHolder path;
                if (localize)
                    path = value.localizePath(scheduler);
                else
                    path = value.data();

                UT_String wrap(path);
                wrap.protectString();
                buffer.appendSprintf("%s ", wrap.buffer());
            }

            buffer.removeTrailingSpace();
            return PDG_AttributeCast::eSuccess;
        }

        return PDG_AttributeCast::eErrorType;
    }

    /// Casts the value contained in the attribute to a PDG_File object. Only
    /// valid for string, file and PyObject attribute types
    inline PDG_AttributeCast        asFile(
                                        PDG_File& file,
                                        int index,
                                        const UT_StringHolder& tag = 
                                            UT_StringHolder::theEmptyString,
                                        PDG_File::Hash hash = 0,
                                        bool own = false) const
    {
        UT_StringHolder file_path;
        UT_StringHolder file_tag = tag;
        PDG_File::Hash file_hash = hash;
        
        switch (myHolder->type())
        {
            case PDG_AttributeType::ePythonObject:
            {
                if (!myHolder->template attribute<PDG_AttributePyObject>()->str(
                        file_path))
                {
                    return PDG_AttributeCast::eErrorBounds;
                }

                break;
            }

            case PDG_AttributeType::eStringArray:
            {
                if (!myHolder->template attribute<PDG_AttributeString>()->value(
                        file_path, index))
                {
                    return PDG_AttributeCast::eErrorBounds;
                }

                break;
            }

            case PDG_AttributeType::eFileArray:
            {
                PDG_AttributeFile::Data temp;
                if (myHolder->template attribute<PDG_AttributeFile>()->value(
                        temp, index))
                {
                    file_path = temp.data();

                    if (file_tag.isEmpty())
                        file_tag = temp.tag();

                    if (!file_hash)
                        file_hash = temp.hash();

                    break;
                }

                return PDG_AttributeCast::eErrorBounds;
            }

            default:
                return PDG_AttributeCast::eErrorType;
        }

        file = PDG_File(file_path, file_tag, file_hash, own);
        return PDG_AttributeCast::eSuccess;
    }

    /// Casts the value contained in the attribute at the particular index to a
    /// string value, by looking up the value with the query string. Falls
    /// a regular cast if query strings aren't supported
    inline PDG_AttributeCast        asString(UT_WorkBuffer& buffer,
                                             exint& query_index,
                                             const PDG_AttributeQuery& query,
                                             int index,
                                             int pad,
                                             bool has_component) const
    {
        if (myHolder->type() == PDG_AttributeType::ePythonObject)
        {
            if (!has_component)
                index = -1;
            return myHolder->template attribute<PDG_AttributePyObject>()->query(
                buffer, query, index);
        }
        else if (myHolder->type() == PDG_AttributeType::eDictArray)
        {
            if (!has_component)
                index = 0;
            return myHolder->template attribute<PDG_AttributeDictionary>()->query(
                buffer, query, query_index, index);
        }

        return asString(buffer, index, pad);
    }

    /// Casts the value contained in the attribute at the particular index to a
    /// string value, if possible.
    inline PDG_AttributeCast        asString(UT_WorkBuffer& buffer,
                                             int index,
                                             int pad=0) const
    {
        switch (myHolder->type())
        {
            case PDG_AttributeType::eIntegerArray:
            {
                PDG_AttributeInteger::Data temp;
                if (myHolder->template attribute<PDG_AttributeInteger>()->value(
                        temp, index))
                {
                    buffer.sprintf("%0*" SYS_PRId64, pad, temp);
                    return PDG_AttributeCast::eSuccess;
                }
                return PDG_AttributeCast::eErrorBounds;
            }

            case PDG_AttributeType::eFloatArray:
            {
                PDG_AttributeFloat::Data temp;
                if (myHolder->template attribute<PDG_AttributeFloat>()->value(
                        temp, index))
                {
                    // If a padding was specified, round to the nearest int and
                    // pad the integer value. This is the same behavior as the
                    // padzero() HScript function. Otherwise, format the value
                    // as-is.
                    if (pad > 0)
                        buffer.sprintf("%0*d", pad, (int)SYSrint(temp));
                    else
                        buffer.sprintf("%g", temp);
                    return PDG_AttributeCast::eSuccess;
                }
                return PDG_AttributeCast::eErrorBounds;
            }

            case PDG_AttributeType::eStringArray:
            {
                PDG_AttributeString::Data temp;
                if (myHolder->template attribute<PDG_AttributeString>()->value(
                        temp, index))
                {
                    buffer.sprintf("%s", temp.c_str());
                    return PDG_AttributeCast::eSuccess;
                }
                return PDG_AttributeCast::eErrorBounds;
            }

            case PDG_AttributeType::eFileArray:
            {
                PDG_AttributeFile::Data temp;
                if (myHolder->template attribute<PDG_AttributeFile>()->value(
                        temp, index))
                {
                    buffer.sprintf("%s", temp.data().c_str());
                    return PDG_AttributeCast::eSuccess;
                }
                return PDG_AttributeCast::eErrorBounds;
            }

            case PDG_AttributeType::eDictArray:
            {
                if (myHolder->template attribute<PDG_AttributeDictionary>()->desc(
                        buffer, index, false))
                {
                    return PDG_AttributeCast::eSuccess;
                }

                return PDG_AttributeCast::eErrorBounds;
            }

            case PDG_AttributeType::ePythonObject:
            {
                UT_StringHolder temp;
                if (myHolder->template attribute<PDG_AttributePyObject>()->str(
                        temp))
                {
                    buffer.sprintf("%s", temp.c_str());
                    return PDG_AttributeCast::eSuccess;
                }
                return PDG_AttributeCast::eErrorBounds;
            }

            default:
                return PDG_AttributeCast::eErrorType;
        }
    }

    /// Casts the value contained in the attribute to a string array, if
    /// possible.
    inline PDG_AttributeCast        asStrings(UT_StringArray& array) const
    {
        UT_WorkBuffer buffer;
        switch (myHolder->type())
        {
            case PDG_AttributeType::eIntegerArray:
            {
                auto&& attr =
                    myHolder->template attribute<PDG_AttributeInteger>();

                for (exint i = 0; i < attr->size(); i++)
                {
                    buffer.format("{}", attr->value(i));
                    array.append(buffer.buffer());
                }

                return PDG_AttributeCast::eSuccess;
            }
            
            case PDG_AttributeType::eFloatArray:
            {
                auto&& attr =
                    myHolder->template attribute<PDG_AttributeFloat>();

                for (exint i = 0; i < attr->size(); i++)
                {
                    buffer.format("{}", attr->value(i));
                    array.append(buffer.buffer());
                }

                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eStringArray:
            {
                auto&& attr =
                    myHolder->template attribute<PDG_AttributeString>();

                for (exint i = 0; i < attr->size(); i++)
                    array.append(attr->value(i));

                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eFileArray:
            {
                auto&& attr =
                    myHolder->template attribute<PDG_AttributeFile>();

                for (exint i = 0; i < attr->size(); i++)
                    array.append(attr->value(i).data());

                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eDictArray:
            {
                auto&& attr =
                    myHolder->template attribute<PDG_AttributeDictionary>();

                for (exint i = 0; i < attr->size(); i++)
                {
                    attr->desc(buffer, i, false);
                    array.append(buffer.buffer());
                }
                
                return PDG_AttributeCast::eSuccess;
            }

            default:
                break;
        }

        return PDG_AttributeCast::eErrorType;
    }

    /// Prints the values contained in the attribute to space-separated string
    inline PDG_AttributeCast        asStringValues(UT_WorkBuffer& buffer,
                                                   int pad=0) const
    {
        switch (myHolder->type())
        {
            case PDG_AttributeType::eIntegerArray:
            {
                auto&& values = myHolder->template
                    attribute<PDG_AttributeInteger>()->values();
                for (auto&& value : values)
                    buffer.appendSprintf("%0*" SYS_PRId64 " ", pad, value);
                buffer.removeTrailingSpace();
                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eFloatArray:
            {
                auto&& values = myHolder->template
                    attribute<PDG_AttributeFloat>()->values();
                for (auto&& value : values)
                {
                    // If a padding was specified, round to the nearest int and
                    // pad the integer value. This is the same behavior as the
                    // padzero() HScript function. Otherwise, format the value
                    // as-is.
                    if (pad > 0)
                        buffer.appendSprintf("%0*d ", pad, (int)SYSrint(value));
                    else
                        buffer.appendSprintf("%g ", value);
                }

                buffer.removeTrailingSpace();
                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eStringArray:
            {
                auto&& values = myHolder->template
                    attribute<PDG_AttributeString>()->values();
                for (auto&& value : values)
                {
                    UT_String wrap(value);
                    wrap.protectString();
                    buffer.appendSprintf("%s ", wrap.buffer());
                }

                buffer.removeTrailingSpace();
                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eFileArray:
            {
                auto&& values = myHolder->template
                    attribute<PDG_AttributeFile>()->values();
                for (auto&& value : values)
                {
                    UT_String wrap(value.data());
                    wrap.protectString();
                    buffer.appendSprintf("%s ", wrap.buffer());
                }

                buffer.removeTrailingSpace();
                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eDictArray:
            {
                if (myHolder->template attribute<PDG_AttributeDictionary>()->desc(
                        buffer))
                {
                    return PDG_AttributeCast::eSuccess;
                }
                return PDG_AttributeCast::eErrorType;
            }

            case PDG_AttributeType::ePythonObject:
            {
                UT_StringHolder value;
                if (myHolder->template attribute<PDG_AttributePyObject>()->str(
                        value))
                {
                    UT_String wrap(value);
                    wrap.protectString();
                    buffer.appendSprintf("%s", wrap.buffer());
                    return PDG_AttributeCast::eSuccess;
                }
                return PDG_AttributeCast::eErrorType;
            }

            default:
                return PDG_AttributeCast::eErrorType;
        }
    }
   
    /// Imports the attribute data in the ref into a UT_Options instance
    /// using the name of this attribute as the key string
    inline PDG_AttributeCast        asOptions(
                                        UT_Options& options,
                                        PDG_AttributeOverwrite overwrite) const
    {
        return asOptions(options, myName, overwrite);
    }

    /// Imports the attribute data in the ref into an UT_Options instance
    /// using the specified key string 
    inline PDG_AttributeCast        asOptions(
                                        UT_Options& options,
                                        const UT_StringHolder& key,
                                        PDG_AttributeOverwrite overwrite) const
    {
        UT_OptionType existing_type = options.getOptionType(key);
        if ((existing_type != UT_OPTION_INVALID) &&
            (overwrite == PDG_AttributeOverwrite::eNever))
        {
            return PDG_AttributeCast::eSuccess;
        }

        switch (myHolder->type())
        {
            case PDG_AttributeType::eIntegerArray:
            {
                if (overwrite == PDG_AttributeOverwrite::eAlways ||
                    existing_type == UT_OPTION_INVALID ||
                    existing_type == UT_OPTION_INT ||
                    existing_type == UT_OPTION_INTARRAY)
                {
                    auto&& attr =
                        myHolder->template attribute<PDG_AttributeInteger>();
                    if (attr->size() == 1)
                        options.setOptionI(key, attr->value(0));
                    else
                        options.setOptionIArray(key, attr->values());
                }

                return PDG_AttributeCast::eSuccess;
            }
            
            case PDG_AttributeType::eFloatArray:
            {
                if (overwrite == PDG_AttributeOverwrite::eAlways ||
                    existing_type == UT_OPTION_INVALID ||
                    existing_type == UT_OPTION_FPREAL ||
                    existing_type == UT_OPTION_FPREALARRAY ||
                    existing_type == UT_OPTION_VECTOR2 ||
                    existing_type == UT_OPTION_VECTOR3 ||
                    existing_type == UT_OPTION_VECTOR4 ||
                    existing_type == UT_OPTION_QUATERNION ||
                    existing_type == UT_OPTION_MATRIX3 ||
                    existing_type == UT_OPTION_MATRIX4 ||
                    existing_type == UT_OPTION_UV ||
                    existing_type == UT_OPTION_UVW)
                {
                    auto&& attr =
                        myHolder->template attribute<PDG_AttributeFloat>();
                    if (attr->size() == 1)
                        options.setOptionF(key, attr->value(0));
                    else
                    {
                        options.setOptionFArray(
                            key, attr->values().data(), attr->size());
                    }
                }

                return PDG_AttributeCast::eSuccess;
            }
            
            case PDG_AttributeType::eStringArray:
            {
                if (overwrite == PDG_AttributeOverwrite::eAlways ||
                    existing_type == UT_OPTION_INVALID ||
                    existing_type == UT_OPTION_STRING ||
                    existing_type == UT_OPTION_STRINGARRAY)
                {
                    auto&& attr =
                        myHolder->template attribute<PDG_AttributeString>();
                    if (attr->size() == 1)
                        options.setOptionS(key, attr->value(0));
                    else
                        options.setOptionSArray(key, attr->values());
                }
                
                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eFileArray:
            {
                if (overwrite == PDG_AttributeOverwrite::eAlways ||
                    existing_type == UT_OPTION_INVALID ||
                    existing_type == UT_OPTION_STRING ||
                    existing_type == UT_OPTION_STRINGARRAY)
                {
                    auto&& attr =
                        myHolder->template attribute<PDG_AttributeFile>();
                    if (attr->size() == 1)
                        options.setOptionS(key, attr->value(0).data());
                    else
                    {
                        UT_StringArray values(attr->size());
                        for (auto&& value : attr->values())
                            values.append(value.data());
                        options.setOptionSArray(key, values);
                    }
                }
                
                return PDG_AttributeCast::eSuccess;
            }

            case PDG_AttributeType::eDictArray:
            {
                if (overwrite == PDG_AttributeOverwrite::eAlways ||
                    existing_type == UT_OPTION_INVALID ||
                    existing_type == UT_OPTION_DICT ||
                    existing_type == UT_OPTION_DICTARRAY)
                {
                    auto&& attr =
                        myHolder->template attribute<PDG_AttributeDictionary>();
                    if (attr->size() == 1)
                        options.setOptionDict(key, attr->value(0));
                    else
                        options.setOptionDictArray(key, attr->values());
                }
                
                return PDG_AttributeCast::eSuccess;
            }

            default:
                return PDG_AttributeCast::eErrorType;
        }
    }

    /// Returns the size of the data stored in the attribute
    inline int                      size() const
    {
        switch (myHolder->type())
        {
            case PDG_AttributeType::eIntegerArray:
            {
                return myHolder->template attribute<
                    PDG_AttributeInteger>()->size();
            }

            case PDG_AttributeType::eFloatArray:
            {
                return myHolder->template attribute<
                    PDG_AttributeFloat>()->size();
            }

            case PDG_AttributeType::eStringArray:
            {
                return myHolder->template attribute<
                    PDG_AttributeString>()->size();
            }

            case PDG_AttributeType::eFileArray:
            {
                return myHolder->template attribute<
                    PDG_AttributeFile>()->size();
            }

            case PDG_AttributeType::eDictArray:
            {
                return myHolder->template attribute<
                    PDG_AttributeDictionary>()->size();
            }

            case PDG_AttributeType::ePythonObject:
            {
                return myHolder->template attribute<
                    PDG_AttributePyObject>()->size();
            }

            case PDG_AttributeType::eGeometry:
            {
                return myHolder->template attribute<
                    PDG_AttributeGeometry>()->size();
            }

            default:
                return 0;
        }
    }

protected:
    Holder*                         myHolder;
};

/**
 * Read-only, const attribute ref
 */
template <typename Attribute>
class PDG_API_TMPL PDG_ROAttributeRef :
    public PDG_AttributeRefT<Attribute, const PDG_AttributeHolder>
{
public:
    using Base = PDG_AttributeRefT<Attribute, const PDG_AttributeHolder>;
    using Base::Base;
};

/**
 * Read/write attribute ref that permits modifications of holder flags as
 * well as non-const access to the underlying data. Accessing the attribute
 * using either the named accessor or the -> overload will result in a deep
 * copy + ownership being taken, if the data is not already owned by the
 * holder.
 */
template <typename Attribute>
class PDG_API_TMPL PDG_RWAttributeRef :
    public PDG_AttributeRefT<Attribute, PDG_AttributeHolder>
{
public:
    using Base = PDG_AttributeRefT<Attribute, PDG_AttributeHolder>;
    using Self = PDG_RWAttributeRef<Attribute>;

    /// Constructs an uninitialized RW ref
    PDG_RWAttributeRef(const UT_StringHolder& name,
                       const PDG_AttributeOwner* owner)
        : Base(nullptr, name, owner, PDG_AttributeError::eUninitialized)
        , myModified(false)
    {
    }

    /// Constructs a ref that can modify attribute data. We store the work
    /// item so we can emit events.
    PDG_RWAttributeRef(PDG_AttributeHolder* holder,
                       const UT_StringHolder& name,
                       const PDG_AttributeOwner* owner,
                       PDG_AttributeError error = 
                            PDG_AttributeError::eNone)
        : Base(holder, name, owner, error)
        , myModified(false)
    {
    }

    /// Explicitly defined copy constructor, since we don't want to copy the
    /// myModified flag from the source reference. Doing so would mean that
    /// we'd potentially by emitting an extra data change event on destruction.
    PDG_RWAttributeRef(const Self& other)
        : Base(other)
        , myModified(false)
    {
    }

    /// Explicitly defined move constructor, since a copy constructor has been
    /// defined. When moving a ref we do want to preserve the myModified flag,
    /// unlike in the copy constructor.
    PDG_RWAttributeRef(Self&& other)
        : Base(std::move(other))
        , myModified(other.myModified)
    {
        other.myModified = false;
    }

    /// Emits data changed events if this attribute ref recorded a modification
    ~PDG_RWAttributeRef()
    {
        emitEvents();
    }

    /// Explicitly defined copy assignment operator, since the copy constructor
    /// is defined.
    Self&               operator=(const Self& other)
    {
        if (this != &other)
        {
            emitEvents();
        
            myModified = false;
            Base::operator=(other);
        }

        return *this;
    }

    /// Explicitly defined move assignment operator, since the move constructor
    /// is defined.
    Self&               operator=(Self&& other)
    {
        if (this != &other)
        {
            emitEvents();

            myModified = other.myModified;
            other.myModified = false;

            Base::operator=(std::move(other));
        }

        return *this;
    }

    /// Emits pending events from the ref
    inline void         emitEvents()
    {
        if (Base::myOwner && myModified)
            Base::attributeModified(Base::myOwner, Base::type(), Base::myName);

        myModified = false;
    }

    /// Clears any pending events
    inline void         clearEvents()
    {
        myModified = false;
    }

    /// Returns a non-const pointer to the underlying attribute instance. This
    /// induces a copy if the attribute is not already owned, and counts as a
    /// modification for the purpose of event handling.
    inline Attribute*   attribute()
    {
        Base::myHolder->own();
        Base::myHolder->setIsChanged(true);

        myModified = true;
        return Base::myHolder->template attribute<Attribute>();
    }

    /// Returns a non-const pointer to the underlying attribute instance
    inline Attribute*   operator->()
    {
        return attribute();
    }

    /// Sets the specific flag on or off, based on the set arugment, an
    /// returns whether or not the flag was changed.
    inline PDG_AttributeError
                        setFlag(PDG_AttributeFlag flag,
                                bool set,
                                bool& changed)
    {
        if (!Base::isValid())
            return Base::error();

        if (Base::myOwner && !Base::myOwner->isAttribFlagValid(flag))
            return PDG_AttributeError::eInvalidFlag;

        changed = Base::myHolder->setFlag(flag, set);
        return PDG_AttributeError::eNone;
    }

    /// Sets the specific flag on or off
    inline PDG_AttributeError
                        setFlag(PDG_AttributeFlag flag, bool set)
    {
        bool discard;
        return setFlag(flag, set, discard);
    }

    /// Directly sets the flag bits to the specified flags
    inline PDG_AttributeError
                        setFlags(uint16 flags, bool& changed)
    {
        if (!Base::isValid())
            return Base::error();

        if (Base::myOwner && !Base::myOwner->areAttribFlagsValid(flags))
            return PDG_AttributeError::eInvalidFlag;

        changed = Base::myHolder->setFlags(flags);
        return PDG_AttributeError::eNone;
    }

    /// Sets all flags
    inline PDG_AttributeError
                        setFlags(uint16 flags)
    {
        bool discard;
        return setFlags(flags, discard);
    }

    /// Truncates the array stored in the attribute
    inline void         truncate(int length)
    {
        switch (Base::myHolder->type())
        {
            case PDG_AttributeType::eIntegerArray:
            {
                return Base::myHolder->template attribute<
                    PDG_AttributeInteger>()->truncate(length);
            }

            case PDG_AttributeType::eFloatArray:
            {
                return Base::myHolder->template attribute<
                    PDG_AttributeFloat>()->truncate(length);
            }

            case PDG_AttributeType::eStringArray:
            {
                return Base::myHolder->template attribute<
                    PDG_AttributeString>()->truncate(length);
            }

            case PDG_AttributeType::eFileArray:
            {
                return Base::myHolder->template attribute<
                    PDG_AttributeFile>()->truncate(length);
            }

            case PDG_AttributeType::eDictArray:
            {
                return Base::myHolder->template attribute<
                    PDG_AttributeDictionary>()->truncate(length);
            }

            default:
                return;
        }
    }

private:
    bool                myModified;
};

#endif