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

#ifndef __GT_DAInherit__
#define __GT_DAInherit__

#include "GT_API.h"
#include "GT_DataArray.h"

/// @brief Base class for a data array which references another data array
class GT_API GT_DAInherit : public GT_DataArray
{
public:
    /// Default constructor
    GT_DAInherit() : myData() {}
    /// Convenience constructor
    GT_DAInherit(const GT_DataArrayHandle &data) : myData(data) { }
    /// Copy constructor
    GT_DAInherit(const GT_DAInherit &src)
        : myData(src.myData)
        , GT_DataArray()
    {
    }
    ~GT_DAInherit() override;

    void        init(const GT_DataArrayHandle &data)
                {
                    myData = data;
                }

    /// @{
    /// Methods defined on GT_DataArray
    GT_Storage  getStorage() const override
                            { return myData->getStorage(); }
    GT_Size     getTupleSize() const override
                            { return myData->getTupleSize(); }
    GT_Type     getTypeInfo() const override
                            { return myData->getTypeInfo(); }
    int64       getMemoryUsage() const override
                            { return myData->getMemoryUsage() + sizeof(*this); }
    bool        hasArrayEntries() const override
                            { return myData->hasArrayEntries(); }

    /// This method may need to be overridden by derived classes depending on
    /// how the underlying data is referenced.
    GT_Size     itemSize(GT_Offset offset) const override
                            { return myData->itemSize(offset); }

    /// This method may need to be overridden by derived classes depending on
    /// how the underlying data is referenced.
    GT_Size     getTotalArrayEntries() const override
                            { return myData->getTotalArrayEntries(); }

    /// Return "true" if there's pointer aliasing
    bool        getPointerAliasing(const void *data) const override
                            { return myData->getPointerAliasing(data); }
    bool        isValid() const override { return myData && myData->isValid(); }
    int64       getDataId() const override { return myData->getDataId(); }
    void        updateGeoDetail(const GU_ConstDetailHandle &dtl,
                                const char *attrib_name,
                                GT_Owner attrib_owner,
                                const int expected_size) override
                {
                    myData->updateGeoDetail(dtl, attrib_name,
                                            attrib_owner,
                                            expected_size);
                }
    /// @}

    /// @{
    /// Implement the specific methods of the inherited array.
    /// @param MAP_INDEX @n
    ///         A function which takes an offset an maps it to the index in the
    ///         source array
    /// @param SIZE @n
    ///         The size of this array
#define GT_IMPL_INHERIT_ARRAY(MAP_INDEX, SIZE)  \
    GT_Size     entries() const override { return SIZE; } \
    fpreal16    getF16(GT_Offset offset, int idx=0) const override \
                    { return myData->getF16(MAP_INDEX(offset), idx); } \
    fpreal32    getF32(GT_Offset offset, int idx=0) const override \
                    { return myData->getF32(MAP_INDEX(offset), idx); } \
    fpreal64    getF64(GT_Offset offset, int idx=0) const override \
                    { return myData->getF64(MAP_INDEX(offset), idx); } \
    uint8       getU8(GT_Offset offset, int idx=0) const override \
                    { return myData->getU8(MAP_INDEX(offset), idx); } \
    int32       getI32(GT_Offset offset, int idx=0) const override \
                    { return myData->getI32(MAP_INDEX(offset), idx); } \
    int64       getI64(GT_Offset offset, int idx=0) const override \
                    { return myData->getI64(MAP_INDEX(offset), idx); } \
    GT_String   getS(GT_Offset offset, int idx=0) const override \
                    { return myData->getS(MAP_INDEX(offset), idx); } \
    GT_Size     getStringIndexCount() const override \
                    { return myData->getStringIndexCount(); } \
    GT_Offset   getStringIndex(GT_Offset offset, int idx) const override \
                    { return myData->getStringIndex(MAP_INDEX(offset), idx); } \
    bool        getStringIndices(UT_Array<GT_Offset> &indices, \
                                 GT_Offset offset) const override \
                    { return myData->getStringIndices(indices, offset); } \
    void        getIndexedStrings(UT_StringArray &strings, \
                                  UT_IntArray &indices) const override \
                    { myData->getIndexedStrings(strings, indices); } \
    GT_Size     getDictIndexCount() const override \
                { return myData->getDictIndexCount(); } \
    GT_Offset   getDictIndex(GT_Offset offset, int idx) const override \
                { return myData->getDictIndex(MAP_INDEX(offset), idx); } \
    bool        getDictIndices(UT_Array<GT_Offset> &indices, \
                               GT_Offset offset) const override \
                    { return myData->getDictIndices(indices, offset); } \
    void        getIndexedDicts(UT_Array<UT_OptionsHolder> &dicts, \
                                  UT_IntArray &indices) const override \
                    { myData->getIndexedDicts(dicts, indices); } \
    bool        getSA(UT_StringArray &a, GT_Offset offset) const override \
                    { return myData->getSA(a, MAP_INDEX(offset)); } \
    int         getIndexPairObjectSetCount() const override \
                    { return myData->getIndexPairObjectSetCount(); } \
    void        getIndexPairObjects(GT_AttributeListHandle &properties,\
                                    int s = 0) const override \
                    { return myData->getIndexPairObjects(properties, s); } \
    void        doImport(GT_Offset off, uint8 *d, GT_Size sz) const override \
                    { myData->import(MAP_INDEX(off), d, sz); } \
    void        doImport(GT_Offset off, int8 *d, GT_Size sz) const override \
                    { myData->import(MAP_INDEX(off), d, sz); } \
    void        doImport(GT_Offset off, int16 *d, GT_Size sz) const override \
                    { myData->import(MAP_INDEX(off), d, sz); } \
    void        doImport(GT_Offset off, int32 *d, GT_Size sz) const override \
                    { myData->import(MAP_INDEX(off), d, sz); } \
    void        doImport(GT_Offset off, int64 *d, GT_Size sz) const override \
                    { myData->import(MAP_INDEX(off), d, sz); } \
    void        doImport(GT_Offset off, fpreal16 *d, GT_Size sz) const override\
                    { myData->import(MAP_INDEX(off), d, sz); } \
    void        doImport(GT_Offset off, fpreal32 *d, GT_Size sz) const override\
                    { myData->import(MAP_INDEX(off), d, sz); } \
    void        doImport(GT_Offset off, fpreal64 *d, \
                         GT_Size sz) const override \
                    { myData->import(MAP_INDEX(off), d, sz); } \
    void        doImportArray(GT_Offset off, \
                              UT_ValArray<fpreal16> &data) const override \
                    { myData->import(MAP_INDEX(off), data); } \
    void        doImportArray(GT_Offset off, \
                              UT_ValArray<fpreal32> &data) const override \
                    { myData->import(MAP_INDEX(off), data); } \
    void        doImportArray(GT_Offset off, \
                              UT_ValArray<fpreal64> &data) const override \
                    { myData->import(MAP_INDEX(off), data); } \
    void        doImportArray(GT_Offset off, \
                              UT_ValArray<uint8> &data) const override \
                    { myData->import(MAP_INDEX(off), data); } \
    void        doImportArray(GT_Offset off, \
                              UT_ValArray<int8> &data) const override \
                    { myData->import(MAP_INDEX(off), data); } \
    void        doImportArray(GT_Offset off, \
                              UT_ValArray<int16> &data) const override \
                    { myData->import(MAP_INDEX(off), data); } \
    void        doImportArray(GT_Offset off, \
                              UT_ValArray<int32> &data) const override \
                    { myData->import(MAP_INDEX(off), data); } \
    void        doImportArray(GT_Offset off, \
                              UT_ValArray<int64> &data) const override \
                    { myData->import(MAP_INDEX(off), data); } \
    void        fillStringArray(UT_StringArray &data, \
                                UT_ValArray<int> &sizes, \
                                GT_Offset start, GT_Size length) const override \
                    { \
                        UT_ASSERT(start >= 0 && length <= SIZE); \
                        if (myData->getStorage() == GT_STORE_STRING) \
                        { \
                            UT_StringArray attr_strings; \
                            for (GT_Offset off = start; off < length; ++off) \
                            { \
                                attr_strings.clear(); \
                                getSA(attr_strings, off); \
                                sizes.append(attr_strings.entries()); \
                                data.concat(attr_strings); \
                            } \
                        } \
                    }
    /// @}

    const GT_DataArrayHandle &referencedData() const { return myData; }

protected:
    
    GT_DataArrayHandle  myData;
};

#endif