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

#ifndef __GT_DAIndexedString__
#define __GT_DAIndexedString__

#include "GT_API.h"
#include "GT_Handles.h"
#include "GT_DataArray.h"
#include "GT_Memory.h"

#include <UT/UT_Assert.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_IndexedHashSet.h>
#include <UT/UT_IndexedHashSetImpl.h>

class GT_API GT_DAIndexedString : public GT_DataArray
{
public:
    GT_DAIndexedString(GT_Size array_size, int tuple_size=1);
    ~GT_DAIndexedString() override;

    UT_NON_COPYABLE(GT_DAIndexedString)

    const char         *className() const override
                            { return "GT_DAIndexedString"; }
    
    /// @{
    /// Methods defined on GT_DataArray
    /// An indexed string array is hard to begin with
    GT_DataArrayHandle  harden() const override
                            { return GT_DataArrayHandle(SYSconst_cast(this)); }
    GT_Storage          getStorage() const override { return GT_STORE_STRING; }
    GT_Size             getTupleSize() const override { return myTupleSize; }
    GT_Size             entries() const override { return mySize; }
    GT_Type             getTypeInfo() const override { return GT_TYPE_NONE; }
    int64               getMemoryUsage() const override
                        {
#if 0
                            return myStrings.getMemoryUsage() +
                                        sizeof(int32)*mySize*myTupleSize;
#else
                            return sizeof(int32)*mySize*myTupleSize;
#endif
                        }

    uint8               getU8(GT_Offset offset, int index=0) const override
                        {
                            UT_ASSERT_P(offset >= 0 && offset < mySize);
                            UT_ASSERT_P(index >= 0 && index < myTupleSize);
                            offset = offset*myTupleSize + index;
                            return myData[offset];
                        }
    int32               getI32(GT_Offset offset, int index=0) const override
                        {
                            UT_ASSERT_P(offset >= 0 && offset < mySize);
                            UT_ASSERT_P(index >= 0 && index < myTupleSize);
                            offset = offset*myTupleSize + index;
                            return myData[offset];
                        }
    int64               getI64(GT_Offset offset, int index=0) const override
                        {
                            UT_ASSERT_P(offset >= 0 && offset < mySize);
                            UT_ASSERT_P(index >= 0 && index < myTupleSize);
                            offset = offset*myTupleSize + index;
                            return myData[offset];
                        }
    fpreal16            getF16(GT_Offset offset, int index=0) const override
                        {
                            UT_ASSERT_P(offset >= 0 && offset < mySize);
                            UT_ASSERT_P(index >= 0 && index < myTupleSize);
                            offset = offset*myTupleSize + index;
                            return myData[offset];
                        }
    fpreal32            getF32(GT_Offset offset, int index=0) const override
                        {
                            UT_ASSERT_P(offset >= 0 && offset < mySize);
                            UT_ASSERT_P(index >= 0 && index < myTupleSize);
                            offset = offset*myTupleSize + index;
                            return myData[offset];
                        }
    fpreal64            getF64(GT_Offset offset, int index=0) const override
                        {
                            UT_ASSERT_P(offset >= 0 && offset < mySize);
                            UT_ASSERT_P(index >= 0 && index < myTupleSize);
                            offset = offset*myTupleSize + index;
                            return myData[offset];
                        }
    GT_String           getS(GT_Offset offset, int index) const override
    {
        UT_ASSERT_P(offset >= 0 && offset < mySize);
        UT_ASSERT_P(index >= 0 && index < myTupleSize);
        offset = offset * myTupleSize + index;
        UT_IndexedHashSetItemId id = myData[offset];
        return (id >= 0) ? *myStrings.get(id) : UT_StringHolder::theEmptyString;
    }
    GT_Size             getStringIndexCount() const override
                        {
                            return myStrings.getItemIdUpperBound()+1;
                        }
    GT_Offset           getStringIndex(GT_Offset offset, int idx) const override
                        {
                            return getI32(offset, idx);
                        }
    void                getIndexedStrings(UT_StringArray &strings,
                                UT_IntArray &indices) const override;
    void                getStrings(UT_StringArray &strings) 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 {}
    /// @}

    void        resize(GT_Size size)
                {
                    if (!size)
                    {
                        GT_Memory::Free(GT_MEM_DATA, myData,
                                mySize*myTupleSize*sizeof(int32));
                        myStrings.clear();
                    }
                    else
                    {
                        for (GT_Size i = size; i < mySize; ++i)
                        {
                            for (GT_Size j = 0; j < myTupleSize; ++j)
                                freeString(i, j);
                        }
                        myData = (int32 *)GT_Memory::Realloc(GT_MEM_DATA,
                                            myData,
                                            mySize*myTupleSize*sizeof(int32),
                                            size*myTupleSize*sizeof(int32));
                        for (GT_Size i = mySize; i < size; ++i)
                        {
                            for (GT_Size j = 0; j < myTupleSize; ++j)
                                myData[i*myTupleSize+j] = -1;
                        }
                        mySize = size;
                    }
                }
    /// Set an index to a value
    void        setString(GT_Size offset, int index, const GT_String &str)
                {
                    UT_ASSERT_P(offset >= 0 && offset < mySize);
                    UT_ASSERT_P(index >= 0 && index < myTupleSize);
                    if (!str)
                        freeString(offset, index);
                    else
                    {
                        offset = offset * myTupleSize + index;
                        UT_IndexedHashSetItemId old_id = myData[offset];
                        myData[offset] = myStrings.add(str);
                        myStrings.remove(old_id);
                    }
                }
    /// Directly set the string index for a particular entry.
    void        setStringIndex(GT_Size offset, int index, GT_Offset str_id)
                {
                    UT_ASSERT_P(offset >= 0 && offset < mySize);
                    UT_ASSERT_P(index >= 0 && index < myTupleSize);
                    offset = offset*myTupleSize + index;

                    UT_IndexedHashSetItemId new_id = str_id;
                    UT_IndexedHashSetItemId old_id = myData[offset];
                    myStrings.addReference(new_id);
                    myStrings.remove(old_id);
                    myData[offset] = new_id;
                }
private:
    void        freeString(GT_Size offset, int index)
                {
                    UT_ASSERT_P(offset >= 0 && offset < mySize);
                    UT_ASSERT_P(index >= 0 && index < myTupleSize);
                    offset = offset*myTupleSize + index;
                    if (myData[offset] >= 0)
                    {
                        myStrings.remove(myData[offset]);
                        myData[offset] = -1;
                    }
                }

    UT_IndexedHashSet<GT_String> myStrings; // Shared string table
    int32               *myData;
    GT_Size              mySize;
    GT_Size              myTupleSize;
};

#endif