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

#ifndef __GT_DASubArray__
#define __GT_DASubArray__

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

#include <UT/UT_StringArray.h> // required by GT_IMPL_INHERIT_ARRAY()
#include <UT/UT_ValArray.h>

/// @brief A slice of a different data array
class GT_API GT_DASubArray : public GT_DAInherit
{
public:
    /// Default constructor
    GT_DASubArray()
        : mySize(0)
        , myStart(0)
        , GT_DAInherit()
    {
    }
    /// Useful constructor
    GT_DASubArray(const GT_DataArrayHandle &data, GT_Offset start, GT_Size size)
        : mySize(size)
        , myStart(start)
        , GT_DAInherit(data)
    {
    }
    /// Copy constructor
    GT_DASubArray(const GT_DASubArray &src)
        : mySize(src.mySize)
        , myStart(src.myStart)
        , GT_DAInherit(src)
    {
    }
    /// Destructor
    ~GT_DASubArray() override;

    const char         *className() const override { return "GT_DASubArray"; }

    /// Initialize with given data
    void                init(const GT_DataArrayHandle &data,
                            GT_Offset start, GT_Size size)
                        {
                            GT_DAInherit::init(data);
                            myStart = start;
                            mySize = size;
                        }

    GT_Size             itemSize(GT_Offset offset) const override
                            { return myData->itemSize(this->getIndirect(offset)); }
    GT_Size             getTotalArrayEntries() const override
                            {
                                GT_Size sum = 0;
                                for (GT_Size off = myStart; off < myStart; ++off)
                                    sum += myData->itemSize(off);
                                return sum;
                            }

    bool isSameIndirection(const GT_DataArray &base) const override
    {
        const GT_DASubArray *other = dynamic_cast<const GT_DASubArray *>(&base);
        return other
               && other->myStart == myStart
               && other->mySize == mySize
               && myData->isSameIndirection(*other->myData);
    }

    /// If the base data supports backing data, we can get the backing data too
    const void  *getBackingData() const override;

    GT_IMPL_INHERIT_ARRAY(getIndirect, mySize)

#define GT_IMPL_FILL_ARRAY(TYPE) \
    void doFillArray(TYPE *data, GT_Offset start, GT_Size length, \
                        int tuple_size, int stride) const override \
                 { \
                     myData->fillArray( \
                        data, getIndirect(start), length, tuple_size, stride); \
                 } \
    void doFillArrayAttr(UT_Array<TYPE> &data, UT_Array<int> &sizes, \
                        GT_Offset start, GT_Size length) const override \
                 { \
                    myData->fillArray(data, sizes, getIndirect(start), length); \
                 }
    GT_IMPL_FILL_ARRAY(uint8)
    GT_IMPL_FILL_ARRAY(int8)
    GT_IMPL_FILL_ARRAY(int16)
    GT_IMPL_FILL_ARRAY(int32)
    GT_IMPL_FILL_ARRAY(int64)
    GT_IMPL_FILL_ARRAY(fpreal16)
    GT_IMPL_FILL_ARRAY(fpreal32)
    GT_IMPL_FILL_ARRAY(fpreal64)
#undef GT_IMPL_FILL_ARRAY

    void doExtendedQuantizedFill(uint8 *data,
                        GT_Offset start, GT_Size length,
                        int tuple_size, int nrepeats, int stride,
                        fpreal black, fpreal white) const override
                 {
                    myData->extendedFillArray(data, getIndirect(start), length,
                        tuple_size, nrepeats, stride, black, white);

                 }

private:
    /// Map the requested offset to the offset in my data
    inline GT_Offset    getIndirect(GT_Offset offset) const
                            { return myStart + offset; }

    GT_Offset           myStart;
    GT_Size             mySize;
};

#endif