PDG_AttributeData.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_DATA_H__
#define __PDG_ATTRIBUTE_DATA_H__

#include "PDG_API.h"

#include "PDG_AttributeTypes.h"
#include "PDG_EventTypes.h"
#include "PDG_File.h"

#include <SYS/SYS_Hash.h>
#include <SYS/SYS_Types.h>

#include <UT/UT_Array.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_Options.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_ValArray.h>

class UT_JSONValue;
class UT_JSONWriter;
class UT_WorkBuffer;

/**
 * Base class for all types of PDG attribute data
 */
class PDG_API PDG_AttributeData : UT_NonCopyable
{
public:
    /// Attribute data version number
    static constexpr PDG_AttributeType TypeEnum = PDG_AttributeType::eUndefined;

    /// Static stringholder keys, used during json serialization and
    /// deserialization.
    static const UT_StringHolder    theFlagKey;
    static const UT_StringHolder    theTypeKey;
    static const UT_StringHolder    theRuntimeKey;
    static const UT_StringHolder    theConcatKey;
    static const UT_StringHolder    theOwnKey;
    static const UT_StringHolder    theValueKey;

public:
    /// Constructs a new instance with a specified type and owning map, called
    /// by child classes.
                                    PDG_AttributeData();
    virtual                         ~PDG_AttributeData();

    /// Returns the memory usage of the attribute and its data
    virtual int64                   getMemoryUsage(bool inclusive) const = 0;

    /// Return a hash value derived from the attribute data
    virtual bool                    hash(SYS_HashType& hash_value,
                                         UT_WorkBuffer& errors) const = 0;

    /// Deep copies this attribute
    virtual PDG_AttributeData*      clone() const = 0;

    /// Serializes the data to a JSON writer
    virtual bool                    saveData(UT_JSONWriter&) const = 0;

    /// Serializes the data to a UT options
    virtual void                    saveData(
                                        const UT_StringHolder&,
                                        UT_OptionsHolder&) const = 0;

    /// Loads data from a JSON value
    virtual bool                    loadData(const UT_JSONValue&) = 0;

    /// Loads data from a dict
    virtual bool                    loadData(
                                        const UT_StringHolder&,
                                        const UT_OptionsHolder&) = 0;

    /// Compares this data object with another data object
    virtual bool                    compare(const PDG_AttributeData*) const = 0;

    /// Applies a merge op to the data in this attribute
    virtual PDG_AttributeMergeError merge(
                                        PDG_AttributeMergeOp merge_op,
                                        int stride) = 0;

    /// Static utility for constructing an attribute of the specified type,
    /// used during deserialization
    static PDG_AttributeData*       fromType(PDG_AttributeType type);

    /// Static utility for returnign an event from type from an attribute type
    static PDG_EventType            eventType(PDG_AttributeType type);

    /// Returns an attribute type enum from the specified string name
    static PDG_AttributeType        typeFromString(
                                            const UT_StringHolder& type_name);

    /// Returns an intrinsic type from an attribue name
    static PDG_AttributeIntrinsic   intrinsicFromName(const UT_StringRef& name);

    /// Returns an attribute name from a intrinsic type a name string
    static UT_StringHolder          nameFromIntrinsic(
                                        PDG_AttributeIntrinsic attrib_type,
                                        const UT_StringHolder& name);

    /// Returns true if the specified string is a valid attribute name. A
    /// valid name cannot start with __pdg prefix unless allow_interal is
    /// true. All names must begin with a letter or _ character and only
    /// contain letters/numbers/_ for subsequent character. E.g. they
    /// must match UT_String::isValidVariableName.
    static bool                     validName(const UT_StringHolder& str,
                                              bool allow_internal=false);

    /// Forces the string into a valid attribute name as described above, and
    /// returns true if any changes were made. If allow_internal is false then
    /// a __pdg prefix is replaced with __.
    static bool                     makeValidName(UT_StringHolder& name,
                                                  const UT_StringHolder& str,
                                                  bool allow_internal=false);

    /// Returns the string name for the specififed attribute type
    static UT_StringHolder          typeName(PDG_AttributeType type);

    /// Returns the string name for the specified merge op
    static UT_StringHolder          mergeName(PDG_AttributeMergeOp merge);

protected:
    /// Merge op utility for string array data
    static PDG_AttributeMergeError  merge(UT_StringArray& data,
                                          PDG_AttributeMergeOp merge_op,
                                          int stride);

    /// Merge op utility for file array data
    static PDG_AttributeMergeError  merge(PDG_File::Array& data,
                                          PDG_AttributeMergeOp merge_op,
                                          int stride);

    /// Merge op utility for float array data
    static PDG_AttributeMergeError  merge(UT_ValArray<fpreal>& data,
                                          PDG_AttributeMergeOp merge_op,
                                          int stride);

    /// Merge op utility for int array data
    static PDG_AttributeMergeError  merge(UT_ValArray<exint>& data,
                                          PDG_AttributeMergeOp merge_op,
                                          int stride);

    /// Merge op utility for dict array data
    static PDG_AttributeMergeError  merge(UT_Array<UT_OptionsHolder>& data,
                                          PDG_AttributeMergeOp merge_op,
                                          int stride);
};

#endif