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 <UT/UT_StringMap.h>
#include <UT/UT_ValArray.h>

/**
 * 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 void             setValues(const ArrayType& data)
    {
        myData.setSizeIfNeeded(data.size());
        for (exint i = 0; i < data.size(); i++)
            myData[i] = data[i];
    }

    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             setSize(int size)
    {
        myData.setSize(size);
        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;
        }
    }

    void                    expandIfNeeded(
                                const DataType& default_value,
                                int component)
    {
        if (component < 0)
        {
            myData.append(default_value);
        }
        else if (component >= myData.size())
        {
            myData.setSizeIfNeeded(component+1);
            myData[component] = default_value;
        }
    }

protected:
    ArrayType       myData;
};

#endif