GA_ATIDictArray.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:        GA_ATIDictArray.h ( GA Library, C++)
 *
 * COMMENTS:    Dict Array ATI (Attribute Type Implementation)
 */

#pragma once

#ifndef __GA_ATIDictArray__
#define __GA_ATIDictArray__

#include "GA_API.h"
#include "GA_Attribute.h"
#include "GA_ATIBlobArray.h"
#include "GA_AIFSharedDictTuple.h"
#include "GA_AIFSharedStringTuple.h"
#include "GA_Types.h"

#include <UT/UT_ArrayMap.h>
#include <UT/UT_Options.h>
#include <UT/UT_StringHolder.h>
#include <SYS/SYS_Inline.h>
#include <SYS/SYS_Types.h>


class GA_AIFSharedDictArray;
class GA_AIFJSON;
class GA_AttributeType;
class GA_IndexMap;

template <typename T> class UT_Array;


class GA_API GA_ATIDictArray : public GA_ATIBlobArray
{
public:
    static void registerType();

    SYS_FORCE_INLINE
    static const UT_StringHolder &getTypeName()
    { return theAttributeType->getTypeName(); }
    SYS_FORCE_INLINE
    static const GA_AttributeType &getType() { return *theAttributeType; }

    SYS_FORCE_INLINE
    static bool isType(const GA_Attribute *attrib)
    {
        return attrib && &attrib->getType() == theAttributeType;
    }
    SYS_FORCE_INLINE
    static GA_ATIDictArray *cast(GA_Attribute *attrib)
    {
        if (attrib && &attrib->getType() == theAttributeType)
            return static_cast<GA_ATIDictArray *>(attrib);
        return nullptr;
    }
    SYS_FORCE_INLINE
    static const GA_ATIDictArray *cast(const GA_Attribute *attrib)
    {
        if (attrib && &attrib->getType() == theAttributeType)
            return static_cast<const GA_ATIDictArray *>(attrib);
        return nullptr;
    }

    static GA_Attribute *create(const GA_IndexMap &index_map,
                                GA_AttributeScope scope,
                                const UT_StringHolder &name,
                                const GA_AttributeOptions
                                                *attribute_options = nullptr);
    static GA_Attribute *create(const GA_IndexMap &index_map,
                                const UT_StringHolder &name)
                { return create(index_map, GA_SCOPE_PUBLIC, name); }

    GA_ATIDictArray(const GA_AttributeType &type,
                        const GA_IndexMap &index_map,
                        GA_AttributeScope scope,
                        const UT_StringHolder &name,
                        int tuple_size);
    ~GA_ATIDictArray() override;

    // AIFCopyData is implemented in GA_ATIBlob.
    const GA_AIFSharedDictArray     *getAIFSharedDictArray() const override
                                        { return myAIFSharedDictArray; }

    /// @section JSON-GA_ATIDictArray JSON Schema: GA_ATIDictArray
    /// @code
    /// {
    ///     "name"          : "GA_ATIDictArray",
    ///     "description"   : "An tuple array of indexed strings",
    ///     "type"          : "orderedmap",
    ///     "properties": {
    ///         "storage": {
    ///             "type"        : "string",
    ///             "description" : "Tuple storage",
    ///             "enum"        : [ "int8", "int16", "int32", "int64" ],
    ///         },
    ///         "strings": {
    ///             "type"  : { "$ref":"GA_BlobData", },
    ///             "description" : "Array of strings used in the attribute",
    ///         },
    ///         "indices": {
    ///             "type"  : {"$ref":"GA_DataArrayTuple"},
    ///             "description" : "Int index for each element of the array",
    ///         },
    ///     },
    /// }
    /// @endcode
    /// @see @ref JSON_FileFormat
    const GA_AIFJSON    *getAIFJSON() const override    { return myAIFJSON; }

    /// @{
    /// Get a string
    void                 getDict(UT_Array<UT_OptionsHolder> &strings, GA_Offset offset) const;
    void                 getDictIndex(UT_Array<GA_DictIndexType> &indices, GA_Offset offset) const;
    /// @}
    /// @{
    /// Set a string
    void                 setDict(GA_Offset offset, const UT_Array<UT_OptionsHolder> &strings);
    void                 setDictIndex(GA_Offset offset, const UT_Array<GA_DictIndexType> &indices);
    /// @}

protected:
    // Create a new ATIBlob
    GA_Attribute         *doClone(const GA_IndexMap &index_map,
                                  const UT_StringHolder &name) const override;
private:
    UT_OptionsHolder     lookupDict(GA_StringIndexType handle) const;
    UT_OptionsHolder     lookupOrderedDict(exint handle) const;
    GA_DictIndexType     lookupHandle(const UT_OptionsRef &s) const;
    GA_DictIndexType     validateHandle(GA_DictIndexType h) const;
    bool                 replaceDict(GA_DictIndexType handle,
                                    const UT_OptionsHolder &s);

    /// @{ GA_AIFDictTuple
    /// @warning If you call addDictReference(), at some point, you must call
    /// delHandleReference() on the string you added.
    GA_DictIndexType    addDictReference(const UT_OptionsHolder &s);
    void        delHandleReference(GA_DictIndexType handle);
    bool        tupleGet(GA_Offset di, GA_DictIndexType &v, int vi) const;
    bool        tupleSet(GA_Offset di, GA_DictIndexType v, int vi);
    /// @}

    static GA_AIFSharedDictArray        *myAIFSharedDictArray;
    static GA_AIFJSON                   *myAIFJSON;

    static const GA_AttributeType *theAttributeType;

    /// @cond INTERNAL_DOX
    friend class ga_DictArray;
    friend class ga_DictJSON;
    friend class GA_ATIDictArrayDelayedWriter;
    /// @endcond
};

//
// Designed to delay all the reference count adjustments
// until this object is flushed.  Also maintains a local
// table for looking up the string indices with, thus avoiding
// concurrency issues.
//
class GA_API GA_ATIDictArrayDelayedWriter
{
public:
    GA_ATIDictArrayDelayedWriter();
    GA_ATIDictArrayDelayedWriter(GA_ATIDictArray *attrib);
    ~GA_ATIDictArrayDelayedWriter();

    void                bind(GA_ATIDictArray *attrib);


    // The index cache is provided to avoid having to potentially resize
    // this inside this function.
    void                setDict(GA_Offset offset, const UT_Array<UT_OptionsHolder> &strings, UT_Array<GA_DictIndexType> &indexcache);
    // Directly set the index.
    void                setDictIndex(GA_Offset offset, const UT_Array<GA_DictIndexType> &idx);

    void                flush();

    SYS_FORCE_INLINE bool hasChanges() const
    {
        return myHasChanges;
    }

private:
    void                setDict(GA_Offset offset, const UT_OptionsHolder *strings, exint n, UT_Array<GA_DictIndexType> &indexcache);

    GA_ATIDictArray *myAttribute;
    volatile bool myHasChanges;

    UT_ArrayMap<GA_DictIndexType, exint> myRefCountChanges;
    UT_ArrayMap<UT_OptionsHolder, GA_DictIndexType> myDictToIndex;
};

#endif