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

#ifndef __GT_DAValue__
#define __GT_DAValue__

#include "GT_API.h"
#include "GT_DataArray.h"
#include <UT/UT_Assert.h>

/// @brief An array of const values.
///
/// The data in the array is @b not owned by the array, but needs to exist
/// while the array is in use.
template <typename T>
class GT_DAValues : public GT_DataArray
{
public:
    GT_DAValues(const T *values, GT_Size array_size,
                    int tuple_size, GT_Type type=GT_TYPE_NONE)
        : myData(values)
        , mySize(array_size)
        , myTupleSize(tuple_size)
        , myType(type)
    {
    }
    ~GT_DAValues() override {}

    const T     *getData() const        { return myData; }

    const char         *className() const override { return "GT_DAValues"; }
    bool                getPointerAliasing(const void *data) const override
                                    { return myData == data; }

    /// @{
    /// Methods defined on GT_DataArray
    GT_Storage          getStorage() const override
                            { return GTstorage<T>(); }
    GT_Size             getTupleSize() const override
                            { return myTupleSize; }
    int64               getMemoryUsage() const override
                            { return sizeof(*this); }
    GT_Size             entries() const override
                            { return mySize; }
    GT_Type             getTypeInfo() const override
                            { return myType; }

    uint8               getU8(GT_Offset offset, int index=0) const override
                        {
                            offset = offset * myTupleSize + index;
                            UT_ASSERT_P(offset>=0 && offset<mySize*myTupleSize);
                            return myData[offset];
                        }
    int32               getI32(GT_Offset offset, int index=0) const override
                        {
                            offset = offset * myTupleSize + index;
                            UT_ASSERT_P(offset>=0 && offset<mySize*myTupleSize);
                            return myData[offset];
                        }
    int64               getI64(GT_Offset offset, int index=0) const override
                        {
                            offset = offset * myTupleSize + index;
                            UT_ASSERT_P(offset>=0 && offset<mySize*myTupleSize);
                            return myData[offset];
                        }
    fpreal16            getF16(GT_Offset offset, int index=0) const override
                        {
                            offset = offset * myTupleSize + index;
                            UT_ASSERT_P(offset>=0 && offset<mySize*myTupleSize);
                            return myData[offset];
                        }
    fpreal32            getF32(GT_Offset offset, int index=0) const override
                        {
                            offset = offset * myTupleSize + index;
                            UT_ASSERT_P(offset>=0 && offset<mySize*myTupleSize);
                            return myData[offset];
                        }
    fpreal64            getF64(GT_Offset offset, int index=0) const override
                        {
                            offset = offset * myTupleSize + index;
                            UT_ASSERT_P(offset>=0 && offset<mySize*myTupleSize);
                            return myData[offset];
                        }
    GT_String           getS(GT_Offset, int) const override
                            { return UT_StringHolder::theEmptyString; }
    GT_Size             getStringIndexCount() const override
                            { return -1; }
    GT_Offset           getStringIndex(GT_Offset, int) const override
                            { return -1; }
    void                getIndexedStrings(UT_StringArray &,
                                          UT_IntArray &) const override {}
    GT_Size                             getDictIndexCount() const override 
                                                { return -1; }
    GT_Offset                   getDictIndex(GT_Offset, int) const override 
                                                { return -1; }
    void                getIndexedDicts(UT_Array<UT_OptionsHolder> &,
                                          UT_IntArray &) const override {}
    /// @}

    template<typename U>
    const U                     *getT(GT_Offset offset, SYS_MAYBE_UNUSED U *buf, int size) const
                    {
                        const T *data = myData + offset*myTupleSize;
                        UT_ASSERT_P(offset < mySize && size <= myTupleSize);
                        if constexpr (SYSisSame<T, U>())
                        {
                                return data;
                        }
                        else
                        {
                                for (int i = 0; i < size; i++)
                                                buf[i] = data[i];
                                return buf;
                        }
                    }

        const uint8                     *get(GT_Offset offset, 
                                                         uint8 *buf, int size) const override
                        {
                                return getT(offset, buf, size);
                        }

    const int8                  *get(GT_Offset offset, 
                                                 int8 *buf, int size) const override
                {
                        return getT(offset, buf, size);
                }

    const int16                 *get(GT_Offset offset, 
                                                 int16 *buf, int size) const override
                {
                        return getT(offset, buf, size);
                }

    const int32         *get(GT_Offset offset,
                             int32 *buf, int size) const override
                        {
                            return getT(offset, buf, size);
                        }
    const int64         *get(GT_Offset offset,
                             int64 *buf, int size) const override
                        {
                            return getT(offset, buf, size);
                        }
    const fpreal16      *get(GT_Offset offset,
                             fpreal16 *buf, int size) const override
                        {
                            return getT(offset, buf, size);
                        }
    const fpreal32      *get(GT_Offset offset,
                             fpreal32 *buf, int size) const override
                        {
                            return getT(offset, buf, size);
                        }
    const fpreal64      *get(GT_Offset offset,
                             fpreal64 *buf, int size) const override
                        {
                            return getT(offset, buf, size);
                        }
private:
    const T     *myData;
    GT_Size      myTupleSize;
    GT_Size      mySize;
    GT_Type      myType;
};

typedef GT_DAValues<int32>      GT_I32Values;
typedef GT_DAValues<int64>      GT_I64Values;
typedef GT_DAValues<fpreal16>   GT_F16Values;
typedef GT_DAValues<fpreal32>   GT_F32Values;
typedef GT_DAValues<fpreal64>   GT_F64Values;

#endif