PDG_AttributePrimitive.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_PRIMITIVE_H__
#define __PDG_ATTRIBUTE_PRIMITIVE_H__

#include "PDG_API.h"

#include "PDG_AttributeArray.h"
#include "PDG_AttributeData.h"
#include "PDG_AttributeTypes.h"

#include <UT/UT_JSONValue.h>
#include <UT/UT_JSONWriter.h>
#include <UT/UT_Options.h>

#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_ValArray.h>

/**
 * Template for primitive value array attributes that can serialize themselves
 * directly to JSON, without the need for custom value handling.
 */
template <PDG_AttributeType AttribType,
          typename DataType,
          typename ArrayType = UT_ValArray<DataType>,
          typename JSONType = ArrayType>
class PDG_API_TMPL PDG_AttributePrimitive : public PDG_AttributeArray<
                                                        AttribType,
                                                        DataType,
                                                        ArrayType>
{
public:
    using Base = PDG_AttributeArray<AttribType, DataType, ArrayType>;
    using Self = PDG_AttributePrimitive<
        AttribType, DataType, ArrayType, JSONType>;

    using Base::Base;
                                ~PDG_AttributePrimitive() override {}

    /// Returns the total memory usage of the underlying array data
    int64                       getMemoryUsage(bool inclusive) const override
    {
        int64 mem = inclusive ? sizeof(*this) : 0;
        mem += getDataMemory(Base::myData);
        return mem;
    }

    /// Constructs a new attribue that's copied from this one
    PDG_AttributeData*          clone() const override
    {
        return new Self(Base::myData);
    }

    /// Saves the array data to the specified json writer
    bool                        saveData(UT_JSONWriter& writer) const override
    {
        return writer.jsonValue(Base::myData);
    }

    /// Saves the array data to the specified options
    void                        saveData(
                                    const UT_StringHolder& key,
                                    UT_OptionsHolder& dict) const override
    {
        dict.update([&] (UT_Options& edit)
        {
            saveOption(key, Base::myData, edit);
        });
    }

    /// Reads array data from the json value
    bool                        loadData(const UT_JSONValue& value) override
    {
        JSONType json_type;
        if (!value.import(json_type))
            return false;
        for (auto&& entry: json_type)
            Base::myData.append(entry);
        return true;
    }

    /// Reads array data from a dict
    bool                        loadData(
                                    const UT_StringHolder& key,
                                    const UT_OptionsHolder& dict) override
    {
        return dict->importOption(key, Base::myData);
    }

private:
    /// Utility function to return the memory usage of a string array, which
    /// counts the contents of the array values themselves
    static int64                getDataMemory(const UT_StringArray& data)
    {
        return UTarrayDeepMemoryUsage(data, false);
    }

    /// Utility function to return the memory usage of a value array
    template <typename T>
    static int64                getDataMemory(const UT_ValArray<T>& data)
    {
        return data.getMemoryUsage(false);
    }

    /// Utilities for saving data to a UT_Options
    static void                 saveOption(
                                    const UT_StringHolder& key,
                                    const UT_ValArray<fpreal>& data,
                                    UT_Options& dict)
    {
        dict.setOptionFArray(key, data.data(), data.size());
    }

    static void                 saveOption(
                                    const UT_StringHolder& key,
                                    const UT_ValArray<exint>& data,
                                    UT_Options& dict)
    {
        dict.setOptionIArray(key, data);
    }

    static void                 saveOption(
                                    const UT_StringHolder& key,
                                    const UT_StringArray& data,
                                    UT_Options& dict)
    {
        dict.setOptionSArray(key, data);
    }
};

/**
 * Primitive array attribute type specializations for float, integer and
 * string attributes
 */
using PDG_AttributeFloat = PDG_AttributePrimitive<
                                            PDG_AttributeType::eFloatArray,
                                            fpreal,
                                            UT_ValArray<fpreal>,
                                            UT_ValArray<fpreal64>>;
using PDG_AttributeInteger = PDG_AttributePrimitive<
                                            PDG_AttributeType::eIntegerArray,
                                            exint,
                                            UT_ValArray<exint>,
                                            UT_ValArray<int64>>;
using PDG_AttributeString = PDG_AttributePrimitive<
                                            PDG_AttributeType::eStringArray,
                                            UT_StringHolder,
                                            UT_StringArray>;

#endif