UT/UT_JSONValueMap.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.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        UT_JSONValueMap.h ( UT Library, C++)
 *
 * COMMENTS:    The order is maintained as objects are added to the map
 */

#ifndef __UT_JSONValueMap__
#define __UT_JSONValueMap__

#include "UT_API.h"
#include "UT_PtrArray.h"
#include "UT_SymbolTable.h"
#include <SYS/SYS_AtomicInt.h>
#include <SYS/SYS_AtomicIntImpl.h>

class UT_JSONValue;
class UT_JSONWriter;
class UT_StringArray;

/// @brief UT_JSONValueMap stores a map/dictionary of UT_JSONValue objects
///
/// UT_JSONValueMap stores a map of UT_JSONValue objects.  Unlike a standard
/// Houdini UT_SymbolTable, this object maintains the sort order in which
/// objects were added.
///
/// @see UT_JSONValue, UT_JSONValueArray
class UT_API UT_JSONValueMap {
public:
     UT_JSONValueMap();
    ~UT_JSONValueMap();

    /// Reference count (for shared maps).
    void                 bumpRef(int d)
                         {
                             if (!myRef.add(d))
                                 delete this;
                         }
    /// Get the number of references to this map.
    int                  getRef() const { return myRef; }

    /// Save to an output stream
    bool                 save(UT_JSONWriter &os) const;

    /// Get the list of keys
    int64                getKeys(UT_StringArray &keys) const;

    /// Get a list of the keys.  However, rather than duplicating the string
    /// values, this method simply keeps shallow references.  While it's more
    /// efficient, it's also relies on the fact that the map will not change
    /// while the string array exists.
    int64                getKeyReferences(UT_StringArray &keys) const;

    /// Return the number of entries in the map
    int64                entries() const        { return myArray.entries(); }

    /// Access const entry by index
    const UT_JSONValue  *operator()(int64 i) const { return get(i); }
    /// Access entry by index
    UT_JSONValue        *operator()(int64 i)    { return get(i); }
    /// Access const entry by name (may be NULL pointer if k is not a key)
    const UT_JSONValue  *operator()(const char *k) const { return get(k); }
    /// Access entry by name (may be NULL pointer if k is not a key)
    UT_JSONValue        *operator()(const char *k)      { return get(k); }

    /// Access const entry by index
    const UT_JSONValue  *operator[](int64 i) const { return get(i); }
    /// Access entry by index
    UT_JSONValue        *operator[](int64 i)    { return get(i); }
    /// Access const entry by name (may be NULL pointer if k is not a key)
    const UT_JSONValue  *operator[](const char *k) const { return get(k); }
    /// Access entry by name (may be NULL pointer if k is not a key)
    UT_JSONValue        *operator[](const char *k)      { return get(k); }

    /// Access a const entry by index
    const UT_JSONValue  *get(int64 i) const { return myArray(i); }
    /// Access an entry by index
    UT_JSONValue        *get(int64 i) { return myArray(i); }
    /// Access const entry by name (may be NULL pointer if k is not a key)
    const UT_JSONValue  *get(const char *k) const;
    /// Access entry by name (may be NULL pointer if k is not a key)
    UT_JSONValue        *get(const char *k);

    /// Add key/value pair to the map.  If the key already exists, the previous
    /// value will be deleted.
    int64                append(const char *key, UT_JSONValue *v);
private:
    UT_PtrArray<UT_JSONValue *> myArray;
    UT_SymbolTable              myMap;
    SYS_AtomicInt32             myRef;
};

#endif

---