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

#ifndef __UT_JSONPath__
#define __UT_JSONPath__

#include "UT_API.h"
#include "UT_Set.h"
#include "UT_StringHolder.h"
#include "UT_JSONValueArray.h"
#include "UT_JSONValueMap.h"
#include "UT_WorkBuffer.h"
#include <SYS/SYS_ParseNumber.h>

/// @{
/// Utility functions to help with parsing
UT_API extern const char *UTjsonExtractPath(UT_StringView &path, const char *x);
UT_API extern bool UTjsonSplitComma(UT_StringView &part, UT_StringView &path);
/// @}

/// @brief Implement simple JSONPath parser.
///
/// This supports a very simple JSONPath syntax:
/// - `$`:  root object
/// - `@, this`:  current object
/// - `path`: named operator
/// - `. or []`: child operator (path or index)
/// - `[,]`: union operator (union of paths or indices)
/// - `..`: recursive descent
/// - `*`: wildcard
///
/// Limitations:
/// - Array slicing is not supported
/// - No expression support - you can't do `$.book[?(@.cost<7)].title`)
/// Extensions:
/// - `path` objects can be regex expressions
///
/// As there's no formal syntax for JSONPath, this class was inspired from
/// https://goessner.net/articles/JsonPath/
///
/// For example, with the JSON: @code
///    {
///        "animals" : [
///            {
///                "type" : "cow",
///                "legs" : 4,
///                "wings" : false
///            },
///            {
///                "type" : "cat",
///                "legs" : 4,
///                "wings" : false
///            },
///            {
///                "type" : "budgie",
///                "legs" : 2,
///                "wings" : true
///            }
///        ],
///        "vehicles" : [ ]
///    }
/// @endcode
///
/// Paths would resolve:
/// @code
///    $.animals[1]            -> { "type" : "cat", "legs" : 4, "wings : false }
///    $.animals[0,1]."type"   -> [ "cow", "cat" ]
///    $[animals].."type"      -> [ "cow", "cat", "budgie" ]
///    $[vehicles]             -> [ ]
/// @endcode
///
/// The template expects a functor class to provide information about the
/// object, which needs to have:
/// - `static inline bool isArray(const T *obj);`
/// - `static inline bool isMap(const T *obj);`
/// - `static inline const T *arrayItem(const T *obj, exint idx);`
/// - `static inline const T *mapItem(const T *obj, const char *name);`
/// - `static inline iterator arrayBegin(const T &obj);`
/// - `static inline iterator arrayEnd(const T &obj);`
/// - `static inline iterator mapBegin(const T &obj);`
/// - `static inline iterator mapEnd(const T &obj);`
template <typename T, class FUNC>
class UT_JSONPath_T
{
public:
    static inline bool find(UT_Set<const T *> &matches, const T &src,
                        const char *expr)
    {
        matches.clear();
        if (!UTisstring(expr))
            return false;
        traverse(matches, &src, &src, expr);

        return matches.size() > 0;
    }

private:
    static inline void traverseArray(const T &item,
                    UT_Set<const T *> &matches,
                    const T *root,
                    const char *expr)
    {
        for (auto it = FUNC::arrayBegin(item), n = FUNC::arrayEnd(item);
                it != n; ++it)
            traverse(matches, root, *it, expr);
    }
    static inline void traverseMap(const T &item,
                    UT_Set<const T *> &matches,
                    const T *root,
                    const char *expr)
    {
        for (auto it = FUNC::mapBegin(item), n = FUNC::mapEnd(item);
                it != n; ++it)
            traverse(matches, root, it->second, expr);
    }

    static inline void traverse(UT_Set<const T *> &matches,
                        const T *root,
                        const T *src,
                        const char *expr)
    {
        if (*expr == '$')
        {
            src = root;
            expr++;
        }
        if (!*expr)
        {
            matches.insert(src);
            return;
        }
        if (!FUNC::isArray(src) && !FUNC::isMap(src))
        {
            // Made it to a leaf without matching the expression
            return;
        }
        UT_StringView   path;
        switch (*expr)
        {
            case '.':
                if (!expr[1])
                    return;             // Invalid . terminator
                if (expr[1] == '.')     // Recursive match
                {
                    if (expr[2] == '.')
                        return;         // Invalid ... expression
                    if (FUNC::isArray(src))
                        traverseArray(*src, matches, root, expr);
                    else
                        traverseMap(*src, matches, root, expr);
                    // Now, advnce to the next dot and check if our children
                    // match
                    traverse(matches, root, src, expr+2);
                    return;
                }
                expr = UTjsonExtractPath(path, expr+1);
                if (!path)
                    return;     // Invalid path;
                break;
            case '[':
                if (!expr[1])
                    return;             // Invalid [] terminator
                expr = UTjsonExtractPath(path, expr+1);
                if (!path)
                    return;
                if (*expr == ']')
                    ++expr;
                else if (*expr == '.')
                    return;             // Invalid [.] expression
                break;
            default:            // Explicit path
                expr = UTjsonExtractPath(path, expr);
                break;
        }
        if (!path)
            return;

        UT_StringView   part;
        while (UTjsonSplitComma(part, path))
        {
            if (part == "*")
            {
                if (FUNC::isArray(src))
                    traverseArray(*src, matches, root, expr);
                else
                    traverseMap(*src, matches, root, expr);
            }
            else if (FUNC::isArray(src))
            {
                exint            idx;
                const char      *end = part.end();
                if (SYSparseInteger(part.begin(), end, idx)
                        == SYS_ParseStatus::Success)
                {
                    const T     *kid = FUNC::arrayItem(src, idx);
                    if (kid)
                        traverse(matches, root, kid, expr);
                }
            }
            else
            {
                UT_WorkBuffer   str;
                str.append(part.begin(), part.length());
                const T *kid = FUNC::mapItem(src, str.buffer());
                if (kid)
                    traverse(matches, root, kid, expr);
            }
        }
    }
};

/// @brief Class to implement UT_JSONPath_T parsing for a UT_JSONValue.
class UT_API UT_JSONPath_JSONValue
{
public:
    using array_iterator = UT_JSONValueArray::const_iterator;
    using map_iterator = UT_JSONValueMap::const_iterator;
    static inline bool isArray(const UT_JSONValue *obj)
    {
        return obj->getType() == UT_JSONValue::JSON_ARRAY;
    }
    static inline bool isMap(const UT_JSONValue *obj)
    {
        return obj->getType() == UT_JSONValue::JSON_MAP;
    }
    static inline const UT_JSONValue *
    arrayItem(const UT_JSONValue *obj, exint idx)
    {
        const UT_JSONValueArray *arr = obj->getArray();
        return arr && idx >= 0 && idx < arr->size() ? arr->get(idx) : nullptr;
    }

    static inline const UT_JSONValue *
    mapItem(const UT_JSONValue *obj, const char *name)
    {
        const UT_JSONValueMap *map = obj->getMap();
        return map ? map->get(name) : nullptr;
    }
    static inline array_iterator arrayBegin(const UT_JSONValue &obj)
        { return obj.getArray()->begin(); }
    static inline array_iterator arrayEnd(const UT_JSONValue &obj)
        { return obj.getArray()->end(); }
    static inline map_iterator mapBegin(const UT_JSONValue &obj)
        { return obj.getMap()->begin(); }
    static inline map_iterator mapEnd(const UT_JSONValue &obj)
        { return obj.getMap()->end(); }
};

/// @class UT_JSONPath
/// Specialization of UT_JSONPath_T for UT_JSONValue.
using UT_JSONPath = UT_JSONPath_T<UT_JSONValue, UT_JSONPath_JSONValue>;

#endif