PDG_AttributeArray.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_ARRAY_H__
#define __PDG_ATTRIBUTE_ARRAY_H__

#include "PDG_API.h"

#include "PDG_AttributeData.h"
#include "PDG_AttributeTypes.h"
#include "PDG_File.h"

#include <UT/UT_JSONValue.h>
#include <UT/UT_JSONValueArray.h>
#include <UT/UT_JSONValueMap.h>
#include <UT/UT_JSONWriter.h>

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

class PDG_AttributeEvaluator;

/**
 * Base template for array attribute types
 */
template <PDG_AttributeType AttribType,
          typename DataType,
          typename ArrayType = UT_ValArray<DataType>>
class PDG_API_TMPL PDG_AttributeArray : public PDG_AttributeData
{
public:
    static constexpr PDG_AttributeType TypeEnum = AttribType;

    using Self  = PDG_AttributeArray<AttribType, DataType, ArrayType>;
    using Data  = DataType;
    using Array = ArrayType;
    using Map   = UT_StringMap<ArrayType>;
    using PDG_AttributeData::PDG_AttributeData;

    PDG_AttributeArray()
        : PDG_AttributeData()
    {
    }

    explicit PDG_AttributeArray(const ArrayType& data)
        : PDG_AttributeData()
        , myData(data)
    {
    }

                            ~PDG_AttributeArray() override {}

    inline bool             hasData() const
    {
        return (myData.size() > 0);
    }

    inline int              size() const
    {
        return myData.size();
    }

    inline bool             valid(int component) const
    {
        return (component >= 0) && (component < myData.size());
    }

    inline bool             value(DataType& data, int component) const
    {
        int real_index = component;

        if (real_index < 0)
            real_index += size();

        if (!valid(real_index))
            return false;

        data = myData[real_index];
        return true;
    }

    inline const DataType&  value(int component) const
    {
        return myData[component];
    }

    inline DataType&        value(int component)
    {
        return myData[component];
    }

    inline void             setValue(const ArrayType& data)
    {
        myData = data;
    }

    inline void             setValue(const ArrayType&& data)
    {
        myData = data;
    }

    inline void             setValue(const DataType& value, int component)
    {
        expand(value, component);
    }

    inline const DataType&  appendValue(const DataType& value)
    {
        myData.append(value);
        return myData.last();
    }

    inline const ArrayType& values() const
    {
        return myData;
    }

    inline ArrayType&       values()
    {
        return myData;
    }

    inline void             clear()
    {
        myData.clear();
    }

    inline void             truncate(int length)
    {
        myData.truncate(length);
    }

    inline bool             concat(const Self* other)
    {
        myData.concat(other->myData);
        return true;
    }

    inline bool             adjustSize(int offset)
    {
        myData.setSize(myData.size() + offset);
        return true;
    }

    inline bool             hash(SYS_HashType& hash_value,
                                 UT_WorkBuffer& errors) const override
    {
        hash_value = SYShashRange(myData.begin(), myData.end());
        return true;
    }

    inline void             swap(Self* other)
    {
        myData.swap(other->myData);
    }

    inline void             copy(const Self* other)
    {
        myData = other->myData;
    }

    bool                    compare(
                                const PDG_AttributeData* other) const override
    {
        return ((const Self*)(other))->myData == myData;
    }

    PDG_AttributeMergeError merge(PDG_AttributeMergeOp merge_op,
                                  int stride) override
    {
        return PDG_AttributeData::merge(myData, merge_op, stride);
    }
    
protected:
    void                    expand(const DataType& value, int component)
    {
        if (component < 0)
        {
            myData.append(value);
        }
        else
        {
            myData.setSizeIfNeeded(component+1);
            myData[component] = value;
        }
    }

protected:
    ArrayType       myData;
};

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

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

    int64                       getMemoryUsage(bool inclusive) const override
    {
        int64 mem = inclusive ? sizeof(*this) : 0;
        mem += getDataMemory(Base::myData);
        return mem;
    }

    PDG_AttributeData*          clone() const override
    {
        return new Self(Base::myData);
    }

    bool                        saveData(UT_JSONWriter& writer) const override
    {
        return writer.jsonValue(Base::myData);
    }

    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;
    }

private:
    static int64                getDataMemory(const UT_StringArray& data)
    {
        return UTarrayDeepMemoryUsage(data, false);
    }

    template <typename T>
    static int64                getDataMemory(const UT_ValArray<T>& data)
    {
        return data.getMemoryUsage(false);
    }
};

/**
 * Simple array attribute type specializations
 */
using PDG_AttributeFloat = PDG_AttributeArraySimple<
                                                PDG_AttributeType::eFloatArray,
                                                fpreal,
                                                UT_ValArray<fpreal>,
                                                UT_ValArray<fpreal64>>;
using PDG_AttributeInteger = PDG_AttributeArraySimple<
                                                PDG_AttributeType::eIntegerArray,
                                                exint,
                                                UT_ValArray<exint>,
                                                UT_ValArray<int64>>;
using PDG_AttributeString = PDG_AttributeArraySimple<
                                                PDG_AttributeType::eStringArray,
                                                UT_StringHolder,
                                                UT_StringArray>;

/**
 * Result data array attribute type
 */
class PDG_API PDG_AttributeFile : public PDG_AttributeArray<
                                                PDG_AttributeType::eFileArray,
                                                PDG_File,
                                                PDG_File::Array>
{
public:
    using Base = PDG_AttributeArray<PDG_AttributeType::eFileArray,
                                    PDG_File,
                                    PDG_File::Array>;
    using Base::Base;
    using Base::values;
    using Base::appendValue;

    enum QueryType
    {
        eQueryAny,
        eQueryReal,
        eQueryExpected
    };

public:

    ~PDG_AttributeFile() override;

    int64                       getMemoryUsage(bool inclusive) const override;
    PDG_AttributeData*          clone() const override;
    bool                        saveData(UT_JSONWriter& writer) const override;
    bool                        loadData(const UT_JSONValue& value) override;

    bool                        clearExpected();
    void                        clearMatching(const PDG_File::Set& file_set);

    const Data&                 appendValue(const PDG_WorkItem* work_item,
                                            const UT_StringHolder& path,
                                            const UT_StringHolder& tag,
                                            PDG_File::Hash hash,
                                            PDG_File::FileType file_type,
                                            bool own,
                                            bool replace_expected);
    const Data&                 appendValue(const Data&,
                                            bool replace_expected);

    void                        values(Array& values,
                                       QueryType query=eQueryReal) const;
    void                        valuesForTag(Array& values,
                                             const UT_StringHolder& tag,
                                             QueryType query=eQueryReal) const;
    PDG_AttributeCast           valueForTag(Data& value,
                                            int index,
                                            const UT_StringHolder& tag,
                                            QueryType query=eQueryReal) const;
    PDG_AttributeCast           valuesForEvaluator(
                                        UT_WorkBuffer& buffer,
                                        const PDG_AttributeEvaluator& evaluator,
                                        QueryType query=eQueryReal) const;
};

#endif