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_Optional.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,
                                exint index,
                                UT_WorkBuffer& errors) const override
    {
        if (index < 0)
            hash_value = SYShashRange(myData.begin(), myData.end());
        else if (index > myData.size())
            hash_value = 0;
        else
            hash_value = SYShash(myData[index]);

        return true;
    }

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

    inline void             copy(const Self* other, PDG_AttributeCopyOp copy_op)
    {
        return copy(other->myData, copy_op);
    }

    inline void             copy(
                                const ArrayType& data,
                                PDG_AttributeCopyOp copy_op)
    {
        if (copy_op == PDG_AttributeCopyOp::eAppend)
            myData.concat(data);
        else if (copy_op == PDG_AttributeCopyOp::ePrepend)
        {
            ArrayType copy(data);
            copy.concat(myData);
            myData = copy;
        }
        else if (copy_op == PDG_AttributeCopyOp::eUpdate)
        {
            myData.setSizeIfNeeded(data.size());
            for (int i = 0; i < data.size(); i++)
                myData[i] = data[i];
        }
        else
            myData = data;
    }

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

    bool                    slice(
                                ArrayType& result,
                                exint start,
                                UT_Optional<exint> end_opt
                                    = UT_Optional<exint>(),
                                UT_Optional<exint> step_opt
                                    = UT_Optional<exint>()) const
    {
        exint len = size();

        if (start < 0)
            start += len;

        exint end = end_opt.value_or(len);
        if (end < 0)
            end += len;
        
        exint step = step_opt.value_or(1);

        if (start < 0 || start >= len)
            return false;

        if (end < 0)
            return false;

        if (step == 0)
            return false;

        exint i = start;
        while (true)
        {
            if (i < 0 || i >= len)
                break;

            result.append(myData[i]);
            i += step;

            if (step < 0 && i <= end)
                break;

            if (step >= 0 && i >= end)
                break;
        }

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