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_IndexedHashMapT.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;

    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);
                    
                    // Find out which dictionary
                    int dict_idx;
                    const UT_IndexedHashMapItemKeyContainer<MapKey> *item;
                    UT_OptionsHolder opt = UT_OptionsHolder::theEmptyOptions;

                    dict_idx = getI32(offset, index);
                    if (dict_idx >= 0 && (item = myDictionaries.get(dict_idx)))
                    {
                        MapKey key = item->getKey();
                        opt = key.getOpt();
                    }
                    return opt;
                }

    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
                    {
                        int old_id;
                        UT_IndexedHashMapItemId new_id;

                        offset = offset * myTupleSize + index;
                        old_id = myData[offset];
                        myDictionaries.add(dict, NULL, &new_id);
                        if (old_id >= 0)
                            myDictionaries.remove(old_id);
                        myData[offset] = new_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;
                    }
                }

   class MapKey
   {
   public:
       MapKey(const UT_OptionsHolder &opt) : myOpt(opt) {}
       MapKey(const MapKey &src) : myOpt(src.myOpt) {}
       uint hash() const
       {
           return myOpt ? myOpt.hash() : 123456789;
       }
       bool isEqual(const MapKey &src) const
       {
           if (!myOpt || !src.myOpt)
               return myOpt == src.myOpt;

           return myOpt.isEqual(src.myOpt, 0.0);
       }
       bool operator==(const MapKey &key) const
       {
           return isEqual(key);
       }
       SYS_FORCE_INLINE
       const UT_OptionsHolder &getOpt() const { return myOpt; }

       bool operator<(const MapKey &src) const
       {
           return myOpt.options() < src.myOpt.options();
       }
       int64 getMemoryUsage(bool inclusive) const
       {
           int64 mem = inclusive ? sizeof(*this) : 0;
           mem += myOpt.getMemoryUsage(true);
           return mem;
       }

   private:
       UT_OptionsHolder myOpt;
   };

   using MapItem = UT_IndexedHashMapItemKeyContainer<MapKey>;
   using MapAlloc = ut_IndexedHashMapDeferItemAlloc<MapKey, MapItem>;

    /// A dictionary map
    using UT_IndexedDictMap = UT_IndexedHashMapT<MapKey, MapItem, MapAlloc>;

    UT_IndexedDictMap   myDictionaries;
    int32               *myData;
    GT_Size             mySize;
    GT_Size             myTupleSize;
};

#endif