GT_DAVaryingArray.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.
 *
 * NAME:        GT_DAVaryingArray.h (GT Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GT_DAVaryingArray__
#define __GT_DAVaryingArray__

#include "GT_API.h"
#include "GT_CountArray.h"
#include "GT_DAInherit.h"

/// A array of arrays as values.  Each item is an array of 0 or more items.
class GT_API GT_DAVaryingArray : public GT_DAInherit
{
public:
    GT_DAVaryingArray()
        : GT_DAInherit()
        , myCounts()
    {
    }

    /// The values passed in are a run of values for all the entries of all the
    /// arrays.  The counts array is the number of elements in each array.
    /// For example: @code
    ///   int values := { 0, 1, 2, 0, 1, 2, 3, 4, 5 };
    ///   counts := { 3, 0, 5}
    /// @endcode
    /// Will define an data array of three entries.  Each entry will be an
    /// array of integers: @code
    ///   this[0] = { 0, 1, 2 }
    ///   this[1] = {}
    ///   this[2] = { 0, 1, 2, 3, 4, 5 }
    /// @endcode
    GT_DAVaryingArray(const GT_DataArrayHandle &values,
                        const GT_CountArray &counts)
        : GT_DAInherit(values)
        , myCounts(counts)
    {
        // Currently, we can't have nested array attributes
        UT_ASSERT(!values || !values->hasArrayEntries());
        UT_ASSERT((!values && counts.sumCounts() == 0)
                || (values && values->entries() == counts.sumCounts()));
    }

    ~GT_DAVaryingArray() override;

    const char  *className() const override { return "GT_DAVaryingArray"; }
    bool        isValid() const override
                {
                     return myData
                         && myData->isValid()
                         && !myData->hasArrayEntries()
                         && myData->entries() == myCounts.sumCounts();
                }

    const GT_DataArrayHandle    &values() const { return myData; }
    const GT_CountArray         &counts() const { return myCounts; }
    /// Return the number of elements in the array for the given item
    GT_Size                      itemSize(GT_Offset offset) const override
                                 {
                                     return myCounts.getCount(offset);
                                 }

    exint       getMemoryUsage() const override
    {
        return myData->getMemoryUsage() + myCounts.getMemoryUsage();
    }
    bool        hasArrayEntries() const override { return true; }
    GT_Size     entries() const override { return myCounts.entries(); }
    GT_Size     getTotalArrayEntries() const override
                {
                    return myCounts.sumCounts();
                }
    bool isSameIndirection(const GT_DataArray &base) const override
                {
                    auto *other = dynamic_cast<const GT_DAVaryingArray *>(&base);
                    return other
                           && other->myCounts.isEqual(myCounts)
                           && myData->isSameIndirection(*other->myData);
                }
#define IMPL_GET(TYPE, METHOD) \
    TYPE METHOD(GT_Offset off, int idx) const override { \
        auto offcount = myCounts.getOffsetCount(off); \
        if (offcount.second == 0) return 0; /* empty array */ \
        return myData->METHOD(offcount.first, idx); \
    } \
    /* end macro */
    IMPL_GET(fpreal16, getF16);
    IMPL_GET(fpreal32, getF32);
    IMPL_GET(fpreal64, getF64);
    IMPL_GET(uint8, getU8);
    IMPL_GET(int16, getI16);
    IMPL_GET(int32, getI32);
    IMPL_GET(int64, getI64);
    IMPL_GET(GT_String, getS);
    IMPL_GET(GT_Offset, getStringIndex);
    IMPL_GET(GT_Dict, getDict);
    IMPL_GET(GT_Offset, getDictIndex);
#undef IMPL_GET
    GT_Size     getStringIndexCount() const override
                { return myData->getStringIndexCount(); }
    void        getIndexedStrings(UT_StringArray &strings,
                                UT_IntArray &indices) const override
                { return myData->getIndexedStrings(strings, indices); }

    // TODO: Add support for indexed strings

    void        fillStringArray(UT_StringArray &data,
                    UT_ValArray<int> &sizes,
                    GT_Offset start, GT_Size length) const override;

    GT_Size     getDictIndexCount() const override 
                { return myData->getDictIndexCount(); }
    void        getIndexedDicts(UT_Array<UT_OptionsHolder> &dicts,
                                UT_IntArray &indices) const override
                { return myData->getIndexedDicts(dicts, indices); }

    void            fillDictionaryArray(UT_Array<UT_OptionsHolder> &data,
                            UT_ValArray<int> &sizes,
                            GT_Offset start, GT_Size length) const override;

    /// @{
    /// Array accessors
    bool getSA(UT_StringArray &a, GT_Offset off) const override;
    bool getDictA(UT_Array<UT_OptionsHolder> &a, GT_Offset offset) const override;
    bool getFA16(UT_ValArray<fpreal16> &a, GT_Offset off) const override
                    { return arrayImport(a, off); }
    bool getFA32(UT_ValArray<fpreal32> &a, GT_Offset off) const override
                    { return arrayImport(a, off); }
    bool getFA64(UT_ValArray<fpreal64> &a, GT_Offset off) const override
                    { return arrayImport(a, off); }
    bool getUA8(UT_ValArray<uint8> &a, GT_Offset off) const override
                { return arrayImport(a, off); }
    bool getIA8(UT_ValArray<int8> &a, GT_Offset off) const override
                { return arrayImport(a, off); }
    bool getIA16(UT_ValArray<int16> &a, GT_Offset off) const override
                    { return arrayImport(a, off); }
    bool getIA32(UT_ValArray<int32> &a, GT_Offset off) const override
                    { return arrayImport(a, off); }
    bool getIA64(UT_ValArray<int64> &a, GT_Offset off) const override
                    { return arrayImport(a, off); }
    void doImportArray(GT_Offset off, UT_ValArray<fpreal16> &a) const override
                    { arrayImport(a, off); }
    void doImportArray(GT_Offset off, UT_ValArray<fpreal32> &a) const override
                    { arrayImport(a, off); }
    void doImportArray(GT_Offset off, UT_ValArray<fpreal64> &a) const override
                    { arrayImport(a, off); }
    void doImportArray(GT_Offset off, UT_ValArray<uint8> &a) const override
                    { arrayImport(a, off); }
    void doImportArray(GT_Offset off, UT_ValArray<int8> &a) const override
                    { arrayImport(a, off); }
    void doImportArray(GT_Offset off, UT_ValArray<int16> &a) const override
                    { arrayImport(a, off); }
    void doImportArray(GT_Offset off, UT_ValArray<int32> &a) const override
                    { arrayImport(a, off); }
    void doImportArray(GT_Offset off, UT_ValArray<int64> &a) const override
                    { arrayImport(a, off); }
    /// @}

protected:
    /// Extract an array of a given type.  Implemented for fpreal16/32/64
    /// int16/32/64.
    ///
    /// The size of the array returned by arrayImport() will be
    /// itemSize()*getTupleSize() scalar values.
    template <typename T> bool
    arrayImport(UT_ValArray<T> &a, GT_Offset offset) const;

    GT_CountArray       myCounts;
};

#endif