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

#ifndef __UT_JSONValueArray__
#define __UT_JSONValueArray__

#include "UT_API.h"
#include "UT_Array.h"
#include "UT_JSONValue.h"
#include <SYS/SYS_AtomicInt.h>
#include <SYS/SYS_Compiler.h>
#include <SYS/SYS_Hash.h>
#include <SYS/SYS_Inline.h>
#include <SYS/SYS_Types.h>

class UT_JSONValue;
class UT_JSONWriter;
class UT_JSONValueMap;
struct UT_JSONFindResult;
class UT_StringArray;

/// @brief UT_JSONValueArray stores a list of UT_JSONValue objects
///
/// UT_JSONValueArray stores a list of UT_JSONValue objects.
///
/// @see UT_JSONValue, UT_JSONValueMap
class UT_API UT_JSONValueArray {
public:
     UT_JSONValueArray();
    ~UT_JSONValueArray();

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

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

    /// Dump to stdout (same as save to std::cout)
    void                 dump() const;

    SYS_HashType        hash() const;
    /// @{
    /// Check equality
    bool                operator==(const UT_JSONValueArray &arr) const;
    bool                operator!=(const UT_JSONValueArray &arr) const
                            { return !(*this == arr); }
    /// @}

    /// Arrays are typically stored as shared pointers.  This method will make a
    /// unique copy. May return "this" (if the reference count is already unique).
    UT_JSONValueArray   *makeUnique() const;

    /// Return size of the array
    SYS_FORCE_INLINE int64 size() const         { return myArray.size(); }
    /// Return the number of entries in the array
    SYS_FORCE_INLINE int64 entries() const      { return myArray.size(); }
    /// Access a const entry by index
    SYS_FORCE_INLINE const UT_JSONValue *operator()(int64 i) const { return myArray[i]; }
    /// Access an entry by index
    SYS_FORCE_INLINE UT_JSONValue *operator()(int64 i) { return myArray[i]; }
    /// Access a const entry by index
    SYS_FORCE_INLINE const UT_JSONValue *operator[](int64 i) const { return myArray[i]; }
    /// Access an entry by index
    SYS_FORCE_INLINE UT_JSONValue *operator[](int64 i) { return myArray[i]; }

    /// Access a const entry by index
    SYS_FORCE_INLINE const UT_JSONValue *get(int64 i) const { return myArray[i]; }
    /// Access an entry by index
    SYS_FORCE_INLINE UT_JSONValue *get(int64 i) { return myArray[i]; }
    /// Access a const object by index
    SYS_NO_DISCARD_RESULT const UT_JSONValueMap* getObject(int64 i) const;
    /// Access an object by index
    SYS_NO_DISCARD_RESULT UT_JSONValueMap* getObject(int64 i);
    /// Access a const array by index
    SYS_NO_DISCARD_RESULT const UT_JSONValueArray* getArray(int64 i) const;
    /// Access an array by index
    SYS_NO_DISCARD_RESULT UT_JSONValueArray* getArray(int64 i);

    /// Import an array of integer values (fails if the array size is too small
    /// or if one of the elements of the array cannot be interpreted as an
    /// integer).
    bool                import(int64 *result, int64 size) const;
    /// Import an array of float values (fails if the array size is too small
    /// or if one of the elements of the array cannot be interpreted as an
    /// integer).
    bool                import(fpreal64 *result, int64 size) const;

    /// Import an array of integer values (fails if the elements of the array
    /// cannot be interpreted as an integer).
    bool                import(UT_Array<int64> &array) const;
    /// Import an array of real values (fails if the elements of the array
    /// cannot be interpreted as such).
    bool                import(UT_Array<fpreal64> &array) const;
    /// Import an array of string values (fails if the elements of the array
    /// cannot be interpreted as such).
    bool                import(UT_StringArray &array) const;

    struct AppendResult
    {
        UT_JSONValue    *operator->() { return myValue; }
        UT_JSONValue    &operator*() { return *myValue; }
        int64            index() const { return myIndex; }
        UT_JSONValue    *value() const { return myValue; }

        int64            myIndex;
        UT_JSONValue    *myValue;
    };

    /// Add an element to the array
    AppendResult        append(const UT_JSONValue &v);

    /// Emplace an element in the array
    template <typename... ARGS>
    AppendResult        emplace(ARGS&&... args)
    {
        return append(UT_JSONValue(std::forward<ARGS>(args)...));
    }


    /// Remove and delete an element by index.
    void                remove(int64 index);

    /// Remove and delete an element.
    void                remove(const UT_JSONFindResult &v);

    /// Remove and delete the last added element.
    void                removeLast();

    /// Remove and delete all elements.
    void                clear();

    /// Inserts a value v before the given element after_value.
    AppendResult        insertBefore(const UT_JSONValue &v,
                                const UT_JSONFindResult &after_value);

    /// Adds a new array child to this map.
    UT_JSONValueArray   *appendArrayChild();

    /// Adds a new map child to this map.
    UT_JSONValueMap     *appendMapChild();

    using const_iterator = UT_Array<UT_JSONValue *>::const_iterator;
    const_iterator      begin() const { return myArray.begin(); }
    const_iterator      end() const { return myArray.end(); }

private:
    template <typename ARRAY_T>
    bool                 importArray(ARRAY_T &array) const;

private:
    UT_Array<UT_JSONValue *>    myArray;
    SYS_AtomicInt32             myRef;
};

#endif