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

#ifndef __GT_DAList__
#define __GT_DAList__

#include "GT_API.h"
#include "GT_DataArray.h"
#include "GT_CountArray.h"
#include <UT/UT_Array.h>
#include <UT/UT_IntArray.h>

/// @brief A list which "merges" multiple data arrays into a single array
class GT_API GT_DAList : public GT_DataArray {
public:
    /// Default constructor
    GT_DAList()
        : myFirst(NULL)
        , myStorage(GT_STORE_INVALID)
        , GT_DataArray()
    {
    }
    /// Useful constructor
    GT_DAList(const UT_Array<GT_DataArrayHandle> &list)
        : myFirst(NULL)
        , myStorage(GT_STORE_INVALID)
        , GT_DataArray()
    {
        init(list);
    }
    /// Copy constructor
    GT_DAList(const GT_DAList &src)
        : myFirst(NULL)
        , myStorage(src.getStorage())
        , GT_DataArray(src)
    {
        init(src.myList);
    }
    /// Destructor
    ~GT_DAList() override;

    const char  *className() const override { return "GT_DAList"; }
    
    /// Initialize with given data
    void        init(const UT_Array<GT_DataArrayHandle> &list);

    /// Test whether the array is valid
    bool        isValid() const override { return myFirst != NULL; }

    /// @{
    /// Method defined on GT_DataArray
    GT_Storage          getStorage() const override
                            { return myFirst->getStorage(); }
    GT_Size             getTupleSize() const override
                            { return myFirst->getTupleSize(); }
    GT_Type             getTypeInfo() const override
                            { return myFirst->getTypeInfo(); }
    GT_Size             entries() const override
                            { return myTotalEntries; }
    bool                hasArrayEntries() const override
                            {
                                UT_ASSERT(isValid());
                                return myFirst->hasArrayEntries();
                            }
    GT_Size             itemSize(GT_Offset offset) const override;
    GT_Size             getTotalArrayEntries() const override
                            { return myTotalArrayEntries; }

    int64               getMemoryUsage() const override;
    bool                getPointerAliasing(const void *data) const override;
    /// @}

    /// @{
    /// Not supported since there's no easy way to merge string indices
    GT_Size             getStringIndexCount() const override { return 0; }
    GT_Offset           getStringIndex(GT_Offset, int idx) const override
                            { return -1; }
    void                getIndexedStrings(UT_StringArray &,
                                          UT_IntArray&) const override
                            {}

    /// Not supported since there's no easy way to merge dictionary indices
    GT_Size                             getDictIndexCount() const override { return 0; }
    GT_Offset                   getDictIndex(GT_Offset, int idx) const override 
                                                { return -1; }
    void                getIndexedDicts(UT_Array<UT_OptionsHolder> &,
                                          UT_IntArray&) const override {}
    /// @}

protected:
    /// @{
    /// Data accessor
    fpreal16            getF16(GT_Offset offset, int idx=0) const override
                        {
                            const GT_DataArray  *h = getList(offset);
                            return h->getF16(offset, idx);
                        }
    fpreal32            getF32(GT_Offset offset, int idx=0) const override
                        {
                            const GT_DataArray  *h = getList(offset);
                            return h->getF32(offset, idx);
                        }
    fpreal64            getF64(GT_Offset offset, int idx=0) const override
                        {
                            const GT_DataArray  *h = getList(offset);
                            return h->getF64(offset, idx);
                        }
    uint8               getU8(GT_Offset offset, int idx=0) const override
                        {
                            const GT_DataArray  *h = getList(offset);
                            return h->getU8(offset, idx);
                        }
    int32               getI32(GT_Offset offset, int idx=0) const override
                        {
                            const GT_DataArray  *h = getList(offset);
                            return h->getI32(offset, idx);
                        }
    int64               getI64(GT_Offset offset, int idx=0) const override
                        {
                            const GT_DataArray  *h = getList(offset);
                            return h->getI64(offset, idx);
                        }
    GT_String           getS(GT_Offset offset, int idx=0) const override
                        {
                            const GT_DataArray  *h = getList(offset);
                            return h->getS(offset, idx);
                        }
    bool                getSA(UT_StringArray &a,
                              GT_Offset offset) const override
                        {
                            const GT_DataArray  *h = getList(offset);
                            return h->getSA(a, offset);
                        }

    void                doImport(GT_Offset off, uint8 *d,
                                 GT_Size sz) const override
                        {
                            const GT_DataArray  *h = getList(off);
                            h->import(off, d, sz);
                        }
    void                doImport(GT_Offset off, int8 *d,
                                 GT_Size sz) const override
                        {
                            const GT_DataArray  *h = getList(off);
                            h->import(off, d, sz);
                        }
    void                doImport(GT_Offset off, int16 *d,
                                 GT_Size sz) const override
                        {
                            const GT_DataArray  *h = getList(off);
                            h->import(off, d, sz);
                        }
    void                doImport(GT_Offset off, int32 *d,
                                 GT_Size sz) const override
                        {
                            const GT_DataArray  *h = getList(off);
                            h->import(off, d, sz);
                        }
    void                doImport(GT_Offset off, int64 *d,
                                 GT_Size sz) const override
                        {
                            const GT_DataArray  *h = getList(off);
                            h->import(off, d, sz);
                        }
    void                doImport(GT_Offset off, fpreal16 *d,
                                 GT_Size sz) const override
                        {
                            const GT_DataArray  *h = getList(off);
                            h->import(off, d, sz);
                        }
    void                doImport(GT_Offset off, fpreal32 *d,
                                 GT_Size sz) const override
                        {
                            const GT_DataArray  *h = getList(off);
                            h->import(off, d, sz);
                        }
    void                doImport(GT_Offset off, fpreal64 *d,
                                 GT_Size sz) const override
                        {
                            const GT_DataArray  *h = getList(off);
                            h->import(off, d, sz);
                        }

#define GT_IMPL_IMPORT_ARRAY(TYPE) \
    virtual void        doImportArray(GT_Offset off, UT_ValArray<TYPE> &data) const override \
                        { \
                            const GT_DataArray  *h = getList(off); \
                            h->import(off, data); \
                        }

    GT_IMPL_IMPORT_ARRAY(fpreal16)
    GT_IMPL_IMPORT_ARRAY(fpreal32)
    GT_IMPL_IMPORT_ARRAY(fpreal64)
    GT_IMPL_IMPORT_ARRAY(uint8)
    GT_IMPL_IMPORT_ARRAY(int8)
    GT_IMPL_IMPORT_ARRAY(int16)
    GT_IMPL_IMPORT_ARRAY(int32)
    GT_IMPL_IMPORT_ARRAY(int64)

#undef GT_IMPL_IMPORT_ARRAY

    void                doFillArray(uint8 *data, GT_Offset start, GT_Size len,
                                int tsize, int stride) const override;
    void                doFillArray(int8 *data, GT_Offset start, GT_Size len,
                                int tsize, int stride) const override;
    void                doFillArray(int16 *data, GT_Offset start, GT_Size len,
                                int tsize, int stride) const override;
    void                doFillArray(int32 *data, GT_Offset start, GT_Size len,
                                int tsize, int stride) const override;
    void                doFillArray(int64 *data, GT_Offset start, GT_Size len,
                                int tsize, int stride) const override;
    void                doFillArray(fpreal16 *dat, GT_Offset start, GT_Size len,
                                int tsize, int stride) const override;
    void                doFillArray(fpreal32 *dat, GT_Offset start, GT_Size len,
                                int tsize, int stride) const override;
    void                doFillArray(fpreal64 *dat, GT_Offset start, GT_Size len,
                                int tsize, int stride) const override;
    /// @}


private:
    const GT_DataArray *getList(GT_Offset &offset) const
                        {
                            // Figure out which list is 
                            GT_Offset   list = myListFromOffset(offset);
                            // Now, adjust the offset to be relative for the
                            // list in question.
                            offset -= myListCounts.getOffset(list);
                            return myList(list).get();
                        }

    const GT_DataArray                  *myFirst;
    UT_Array<GT_DataArrayHandle>         myList;
    UT_IntArray                          myListFromOffset;
    GT_CountArray                        myListCounts;
    GT_Size                              myTotalEntries;
    GT_Size                              myTotalArrayEntries;
    GT_Storage                           myStorage;
};

#endif