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

#ifndef __GT_DAIndexedDict__
#define __GT_DAIndexedDict__

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

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

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

    UT_NON_COPYABLE(GT_DAIndexedDict)

    const char* className() const override
                { 
                    return "GT_DAIndexedDict"; 
                }
    GT_DataArrayHandle harden() const override
                {
                    return GT_DataArrayHandle(SYSconst_cast(this));
                }
    GT_Storage  getStorage() const override
                { 
                    return GT_STORE_DICT;
                }
    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 myDictionaries.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, 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 myDictionaries.getItemIdUpperBound() + 1;
                }
    GT_Offset   getDictIndex(GT_Offset offset, int idx) const override 
                { 
                    return getI32(offset, idx);
                }
    void        getIndexedDicts(
                        UT_Array<UT_OptionsHolder> &dicts,
                        UT_IntArray &indices) const override;
   
    GT_Dict     getDict(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;
                    UT_IndexedHashSetItemId id = myData[offset];
                    return (id >= 0) ? *myDictionaries.get(id)
                                     : UT_OptionsHolder::theEmptyOptions;
                }

    void        setDict(GT_Size offset, 
                    int index,
                    const GT_Dict &dict)
                {
                    UT_ASSERT_P(offset >= 0 && offset < mySize);
                    UT_ASSERT_P(index >= 0 && index < myTupleSize);
                    if (!dict || dict.isEmpty())
                        freeDictionary(offset, index);
                    else
                    {
                        offset = offset * myTupleSize + index;
                        UT_IndexedHashSetItemId old_id = myData[offset];
                        myData[offset] = myDictionaries.add(dict);
                        myDictionaries.remove(old_id);
                    }
                }

private:
    void        resize(GT_Size size)
                {
                    if (!size)
                    {
                        GT_Memory::Free(
                            GT_MEM_DATA, myData,
                            mySize * myTupleSize * sizeof(int32));
                        myDictionaries.clear();
                    }
                    else
                    {
                        for (GT_Size i = size; i < mySize; ++i)
                        {
                            for (GT_Size j = 0; j < myTupleSize; ++j)
                                freeDictionary(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;
                    }
                }

    void        freeDictionary(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)
                    {
                        myDictionaries.remove(myData[offset]);
                        myData[offset] = -1;
                    }
                }

    UT_IndexedHashSet<UT_OptionsHolder> myDictionaries;
    int32               *myData;
    GT_Size             mySize;
    GT_Size             myTupleSize;
};

#endif