/src/tinysparql/src/libtinysparql/tracker-deserializer-json-ld.c

Source
/*
 * Copyright (C) 2022, Red Hat Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 *
 * Author: Carlos Garnacho <carlosg@gnome.org>
 */

/* Deserialization to cursors for the JSON format defined at:
 *  https://www.w3.org/TR/json-ld/
 */

#include "config.h"

#include "tracker-deserializer-json-ld.h"

#include <json-glib/json-glib.h>

enum {
  STATE_INITIAL,
  STATE_ROOT_LIST,
  STATE_MAYBE_GRAPH,
  STATE_OBJECT_LIST,
  STATE_PROPERTIES,
  STATE_VALUE_LIST,
  STATE_VALUE,
  STATE_VALUE_AS_OBJECT,
  STATE_FINAL,
};

enum {
  STACK_ARRAY,
  STACK_OBJECT,
};

typedef struct {
  guint type;
  guint state;
  union {
    struct {
      gint idx;
      guint elements;
    } array;
    struct {
      gint idx;
      gchar **members;
      gchar *id;
      gboolean is_graph;
    } object;
  } data;
} StateStack;

struct _TrackerDeserializerJsonLD {
  TrackerDeserializer parent_instance;
  JsonParser *parser;
  JsonReader *reader;
  GArray *state_stack;
  gchar *default_lang;
  gchar *cur_graph;
  gchar *cur_subject;
  gchar *cur_predicate;
  gchar *cur_object;
  gchar *cur_object_lang;
  TrackerSparqlValueType object_type;
  guint state;
  gboolean has_row;
  guint blank_node_idx;
  GError *init_error;
};

G_DEFINE_TYPE (TrackerDeserializerJsonLD,
               tracker_deserializer_json_ld,
               TRACKER_TYPE_DESERIALIZER_RDF)

static void
tracker_deserializer_json_ld_finalize (GObject *object)
{
  TrackerDeserializerJsonLD *deserializer =
    TRACKER_DESERIALIZER_JSON_LD (object);

  tracker_sparql_cursor_close (TRACKER_SPARQL_CURSOR (deserializer));

  g_clear_object (&deserializer->reader);
  g_clear_object (&deserializer->parser);
  g_array_unref (deserializer->state_stack);
  g_clear_pointer (&deserializer->default_lang, g_free);
  g_clear_pointer (&deserializer->cur_graph, g_free);
  g_clear_pointer (&deserializer->cur_subject, g_free);
  g_clear_pointer (&deserializer->cur_predicate, g_free);
  g_clear_pointer (&deserializer->cur_object, g_free);
  g_clear_pointer (&deserializer->cur_object_lang, g_free);

  G_OBJECT_CLASS (tracker_deserializer_json_ld_parent_class)->finalize (object);
}

static void
tracker_deserializer_json_ld_constructed (GObject *object)
{
  TrackerDeserializerJsonLD *deserializer =
    TRACKER_DESERIALIZER_JSON_LD (object);
  GInputStream *stream;

  G_OBJECT_CLASS (tracker_deserializer_json_ld_parent_class)->constructed (object);

  stream = tracker_deserializer_get_stream (TRACKER_DESERIALIZER (object));

  if (json_parser_load_from_stream (deserializer->parser,
                                    stream,
                                    NULL,
                                    &deserializer->init_error)) {
    JsonNode *root;

    root = json_parser_get_root (deserializer->parser);
    deserializer->reader = json_reader_new (root);
  }
}

static void
state_clear (gpointer user_data)
{
  StateStack *elem = user_data;

  if (elem->type == STACK_OBJECT) {
    g_strfreev (elem->data.object.members);
    g_free (elem->data.object.id);
  }
}

static gboolean
advance_stack (TrackerDeserializerJsonLD *deserializer)
{
  StateStack *elem;

  g_assert (deserializer->state_stack->len > 0);

  elem = &g_array_index (deserializer->state_stack,
                         StateStack,
                         deserializer->state_stack->len - 1);

  if (elem->type == STACK_ARRAY) {
    if (elem->data.array.idx >= 0)
      json_reader_end_element (deserializer->reader);

    elem->data.array.idx++;

    if (elem->data.array.idx >= (gint) elem->data.array.elements)
      return FALSE;

    return json_reader_read_element (deserializer->reader,
                                     elem->data.array.idx);
  } else if (elem->type == STACK_OBJECT) {
    if (elem->data.object.idx >= 0)
      json_reader_end_member (deserializer->reader);

    elem->data.object.idx++;

    if (elem->data.object.members[elem->data.array.idx] == NULL)
      return FALSE;

    return json_reader_read_member (deserializer->reader,
                                    elem->data.object.members[elem->data.array.idx]);
  }

  return FALSE;
}

static void
push_stack (TrackerDeserializerJsonLD *deserializer,
            guint                      state)
{
  StateStack elem = { 0 };
  const gchar *id = NULL;

  if (json_reader_is_array (deserializer->reader)) {
    elem.type = STACK_ARRAY;
    elem.data.array.idx = -1;
    elem.data.array.elements =
      json_reader_count_elements (deserializer->reader);
  } else if (json_reader_is_object (deserializer->reader)) {
    elem.type = STACK_OBJECT;
    elem.data.object.idx = -1;
    elem.data.object.members =
      json_reader_list_members (deserializer->reader);

    elem.data.object.is_graph =
      json_reader_read_member (deserializer->reader, "@graph");
    json_reader_end_member (deserializer->reader);

    if (json_reader_read_member (deserializer->reader, "@id"))
      id = json_reader_get_string_value (deserializer->reader);
    json_reader_end_member (deserializer->reader);

    if (id) {
      TrackerNamespaceManager *namespaces;

      namespaces = tracker_deserializer_get_namespaces (TRACKER_DESERIALIZER (deserializer));
      elem.data.object.id =
        tracker_namespace_manager_expand_uri (namespaces, id);
    }
  } else {
    g_assert_not_reached ();
  }

  elem.state = state;
  g_array_append_val (deserializer->state_stack, elem);
  deserializer->state = state;
}

static void
pop_stack (TrackerDeserializerJsonLD *deserializer)
{
  StateStack *elem;

  g_assert (deserializer->state_stack->len > 0);

  g_array_set_size (deserializer->state_stack,
                    deserializer->state_stack->len - 1);

  if (deserializer->state_stack->len > 0) {
    elem = &g_array_index (deserializer->state_stack,
                           StateStack,
                           deserializer->state_stack->len - 1);
    deserializer->state = elem->state;
  } else {
    deserializer->state = STATE_FINAL;
  }
}

static guint
stack_state (TrackerDeserializerJsonLD *deserializer)
{
  StateStack *elem;

  g_assert (deserializer->state_stack->len > 0);

  elem = &g_array_index (deserializer->state_stack,
                         StateStack,
                         deserializer->state_stack->len - 1);

  return elem->state;
}

static const gchar *
current_member (TrackerDeserializerJsonLD *deserializer)
{
  StateStack *elem;
  gint i;

  g_assert (deserializer->state_stack->len > 0);

  for (i = (gint) deserializer->state_stack->len - 1; i >= 0; i--) {
    elem = &g_array_index (deserializer->state_stack,
                           StateStack, i);

    if (elem->type == STACK_OBJECT) {
      return elem->data.object.idx >= 0 ?
             elem->data.object.members[elem->data.object.idx] :
             NULL;
    }
  }

  return NULL;
}

static const gchar *
current_id (TrackerDeserializerJsonLD *deserializer)
{
  StateStack *elem;
  gint i;

  g_assert (deserializer->state_stack->len > 0);

  for (i = (gint) deserializer->state_stack->len - 1; i >= 0; i--) {
    elem = &g_array_index (deserializer->state_stack,
                           StateStack, i);
    if (elem->type == STACK_OBJECT &&
        !elem->data.object.is_graph &&
        elem->data.object.id)
      return elem->data.object.id;
  }

  return NULL;
}

static const gchar *
current_graph (TrackerDeserializerJsonLD *deserializer)
{
  StateStack *elem;
  gint i;

  g_assert (deserializer->state_stack->len > 0);

  for (i = (gint) deserializer->state_stack->len - 1; i >= 0; i--) {
    elem = &g_array_index (deserializer->state_stack,
                           StateStack, i);
    if (elem->type == STACK_OBJECT &&
        elem->data.object.is_graph)
      return elem->data.object.id;
  }

  return NULL;
}

static gchar *
object_to_value (TrackerDeserializerJsonLD  *deserializer,
                 TrackerNamespaceManager    *namespaces,
                 gchar                     **langtag,
                 TrackerSparqlValueType     *value_type)
{
  const gchar *value = NULL, *type = NULL;

  if (json_reader_read_member (deserializer->reader, "@value"))
    value = json_reader_get_string_value (deserializer->reader);
  json_reader_end_member (deserializer->reader);

  if (json_reader_read_member (deserializer->reader, "@language"))
    *langtag = g_strdup (json_reader_get_string_value (deserializer->reader));
  json_reader_end_member (deserializer->reader);

  if (json_reader_read_member (deserializer->reader, "@type"))
    type = json_reader_get_string_value (deserializer->reader);
  json_reader_end_member (deserializer->reader);

  if (g_strcmp0 (type, TRACKER_PREFIX_XSD "string") == 0 ||
      g_strcmp0 (type, TRACKER_PREFIX_RDF "langString") == 0)
    *value_type = TRACKER_SPARQL_VALUE_TYPE_STRING;
  else if (g_strcmp0 (type, TRACKER_PREFIX_XSD "integer") == 0)
    *value_type = TRACKER_SPARQL_VALUE_TYPE_INTEGER;
  else if (g_strcmp0 (type, TRACKER_PREFIX_XSD "boolean") == 0)
    *value_type = TRACKER_SPARQL_VALUE_TYPE_BOOLEAN;
  else if (g_strcmp0 (type, TRACKER_PREFIX_XSD "double") == 0)
    *value_type = TRACKER_SPARQL_VALUE_TYPE_DOUBLE;
  else if (g_strcmp0 (type, TRACKER_PREFIX_XSD "date") == 0 ||
           g_strcmp0 (type, TRACKER_PREFIX_XSD "dateTime") == 0)
    *value_type = TRACKER_SPARQL_VALUE_TYPE_DATETIME;
  else
    *value_type = TRACKER_SPARQL_VALUE_TYPE_STRING;

  return g_strdup (value);
}

static gchar *
node_to_value (JsonNode                *node,
               TrackerNamespaceManager *namespaces,
               TrackerSparqlValueType  *value_type)
{
  GValue value = G_VALUE_INIT;
  GType type;
  gchar *str = NULL;

  json_node_get_value (node, &value);
  type = json_node_get_value_type (node);

  if (type == G_TYPE_INT64) {
    *value_type = TRACKER_SPARQL_VALUE_TYPE_INTEGER;
    str = g_strdup_printf ("%" G_GINT64_FORMAT, g_value_get_int64 (&value));
  } else if (type == G_TYPE_STRING) {
    *value_type = TRACKER_SPARQL_VALUE_TYPE_STRING;
    str = tracker_namespace_manager_expand_uri (namespaces, g_value_get_string (&value));
  } else if (type == G_TYPE_DOUBLE) {
    gchar buf[G_ASCII_DTOSTR_BUF_SIZE];

    g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, g_value_get_double (&value));
    *value_type = TRACKER_SPARQL_VALUE_TYPE_DOUBLE;
    str = g_strdup (buf);
  } else if (type == G_TYPE_BOOLEAN) {
    *value_type = TRACKER_SPARQL_VALUE_TYPE_BOOLEAN;
    str = g_strdup (g_value_get_boolean (&value) ? "true" : "false");
  } else {
    *value_type = TRACKER_SPARQL_VALUE_TYPE_UNBOUND;
  }

  g_value_unset (&value);

  return str;
}

static void
load_special_key (TrackerDeserializerJsonLD *deserializer,
                  const gchar               *key)
{
  const gchar *value;

  if (json_reader_read_member (deserializer->reader, key)) {
    value = json_reader_get_string_value (deserializer->reader);

    if (g_strcmp0 (key, "@language") == 0) {
      g_clear_pointer (&deserializer->default_lang, g_free);
      deserializer->default_lang = g_strdup (value);
    }
  }

  json_reader_end_member (deserializer->reader);
}

static void
load_context (TrackerDeserializerJsonLD *deserializer)
{
  TrackerNamespaceManager *namespaces;

  namespaces = tracker_deserializer_get_namespaces (TRACKER_DESERIALIZER (deserializer));

  if (json_reader_read_member (deserializer->reader, "@context")) {
    gchar **members = json_reader_list_members (deserializer->reader);
    guint i;

    for (i = 0; members && members[i] != NULL; i++) {
      if (members[i][0] == '@') {
        load_special_key (deserializer, members[i]);
        continue;
      }

      if (tracker_namespace_manager_lookup_prefix (namespaces, members[i]))
        continue;

      if (json_reader_read_member (deserializer->reader, members[i])) {
        const gchar *expanded = json_reader_get_string_value (deserializer->reader);
        tracker_namespace_manager_add_prefix (namespaces, members[i], expanded);
      }

      json_reader_end_member (deserializer->reader);
    }

    g_strfreev (members);
  }

  json_reader_end_member (deserializer->reader);
}

static void
forward_state_for_value (TrackerDeserializerJsonLD *deserializer)
{
  if (json_reader_is_object (deserializer->reader)) {
    if (json_reader_read_member (deserializer->reader, "@value")) {
      json_reader_end_member (deserializer->reader);
      deserializer->state = STATE_VALUE_AS_OBJECT;
    } else {
      json_reader_end_member (deserializer->reader);
      push_stack (deserializer, STATE_PROPERTIES);
      deserializer->state = STATE_MAYBE_GRAPH;
    }
  } else {
    deserializer->state = STATE_VALUE;
  }
}

static gboolean
forward_state (TrackerDeserializerJsonLD  *deserializer,
               GError                    **error)
{
  TrackerNamespaceManager *namespaces;
  const gchar *member;

  namespaces = tracker_deserializer_get_namespaces (TRACKER_DESERIALIZER (deserializer));

  switch (deserializer->state) {
  case STATE_INITIAL:
    if (json_reader_is_array (deserializer->reader)) {
      push_stack (deserializer, STATE_ROOT_LIST);
    } else if (json_reader_is_object (deserializer->reader)) {
      push_stack (deserializer, STATE_PROPERTIES);
      deserializer->state = STATE_MAYBE_GRAPH;
    }
    break;
  case STATE_ROOT_LIST:
    if (!advance_stack (deserializer)) {
      pop_stack (deserializer);
      break;
    }

    if (json_reader_is_object (deserializer->reader)) {
      push_stack (deserializer, STATE_MAYBE_GRAPH);
    } else {
      g_set_error (error,
                   TRACKER_SPARQL_ERROR,
                   TRACKER_SPARQL_ERROR_PARSE,
                   "Expected graph or resource object");
      return FALSE;
    }
    break;
  case STATE_MAYBE_GRAPH:
    load_context (deserializer);

    if (json_reader_read_member (deserializer->reader, "@graph")) {
      g_clear_pointer (&deserializer->cur_graph, g_free);
      deserializer->cur_graph = g_strdup (current_graph (deserializer));

      if (json_reader_is_array (deserializer->reader)) {
        push_stack (deserializer, STATE_OBJECT_LIST);
      } else {
        g_set_error (error,
                     TRACKER_SPARQL_ERROR,
                     TRACKER_SPARQL_ERROR_PARSE,
                     "Expected resource list");
        return FALSE;
      }
    } else {
      json_reader_end_member (deserializer->reader);
      g_clear_pointer (&deserializer->cur_subject, g_free);
      deserializer->cur_subject = g_strdup (current_id (deserializer));
      deserializer->state = STATE_PROPERTIES;
    }
    break;
  case STATE_OBJECT_LIST:
    if (!advance_stack (deserializer)) {
      /* Pop the graph array, close manually the @graph
       * member, and pop the graph object too
       */
      pop_stack (deserializer);
      json_reader_end_member (deserializer->reader);
      pop_stack (deserializer);
      break;
    }

    if (json_reader_is_object (deserializer->reader)) {
      push_stack (deserializer, STATE_PROPERTIES);
      deserializer->state = STATE_MAYBE_GRAPH;
    } else {
      g_set_error (error,
                   TRACKER_SPARQL_ERROR,
                   TRACKER_SPARQL_ERROR_PARSE,
                   "Expected resource object");
      return FALSE;
    }
    break;
  case STATE_PROPERTIES:
    if (!advance_stack (deserializer)) {
      pop_stack (deserializer);

      if (deserializer->state == STATE_PROPERTIES ||
          deserializer->state == STATE_VALUE_LIST) {
        gchar *nested_object_id;

        /* The state popped belonged to a nested object,
         * switch subject/predicate back to the parent
         * object, and finalize the property that defined it.
         */
        nested_object_id = g_steal_pointer (&deserializer->cur_subject);

        deserializer->cur_subject = g_strdup (current_id (deserializer));
        g_clear_pointer (&deserializer->cur_predicate, g_free);
        deserializer->cur_predicate =
          tracker_namespace_manager_expand_uri (namespaces, current_member (deserializer));
        g_clear_pointer (&deserializer->cur_object, g_free);
        g_clear_pointer (&deserializer->cur_object_lang, g_free);
        deserializer->cur_object = nested_object_id;
        deserializer->object_type = TRACKER_SPARQL_VALUE_TYPE_STRING;
        deserializer->has_row = TRUE;
      }

      break;
    }

    member = current_member (deserializer);
    g_clear_pointer (&deserializer->cur_predicate, g_free);

    if (g_strcmp0 (member, "@type") == 0)
      deserializer->cur_predicate = g_strdup (TRACKER_PREFIX_RDF "type");
    else if (member[0] != '@')
      deserializer->cur_predicate = tracker_namespace_manager_expand_uri (namespaces, member);
    else
      break;

    if (json_reader_is_array (deserializer->reader))
      push_stack (deserializer, STATE_VALUE_LIST);
    else
      forward_state_for_value (deserializer);
    break;
  case STATE_VALUE_LIST:
    if (!advance_stack (deserializer)) {
      pop_stack (deserializer);
      break;
    }

    forward_state_for_value (deserializer);
    break;
  case STATE_VALUE_AS_OBJECT:
    g_clear_pointer (&deserializer->cur_object, g_free);
    g_clear_pointer (&deserializer->cur_object_lang, g_free);
    deserializer->cur_object = object_to_value (deserializer,
                                                namespaces,
                                                &deserializer->cur_object_lang,
                                                &deserializer->object_type);
    deserializer->has_row = TRUE;

    deserializer->state = stack_state (deserializer);
    break;
  case STATE_VALUE:
    g_clear_pointer (&deserializer->cur_object, g_free);
    g_clear_pointer (&deserializer->cur_object_lang, g_free);
    deserializer->cur_object = node_to_value (json_reader_get_value (deserializer->reader),
                                              namespaces,
                                              &deserializer->object_type);
    deserializer->has_row = TRUE;

    deserializer->state = stack_state (deserializer);
    break;
  case STATE_FINAL:
    break;
  }

  return deserializer->state_stack->len > 0;
}

static TrackerSparqlValueType
tracker_deserializer_json_ld_get_value_type (TrackerSparqlCursor  *cursor,
                                             gint                  column)
{
  TrackerDeserializerJsonLD *deserializer =
    TRACKER_DESERIALIZER_JSON_LD (cursor);

  switch (column) {
  case TRACKER_RDF_COL_SUBJECT:
    if (!deserializer->cur_subject)
      return TRACKER_SPARQL_VALUE_TYPE_UNBOUND;
    else if (strncmp (deserializer->cur_subject, "_:", 2) == 0)
      return TRACKER_SPARQL_VALUE_TYPE_BLANK_NODE;
    else
      return TRACKER_SPARQL_VALUE_TYPE_URI;
    break;
  case TRACKER_RDF_COL_PREDICATE:
    if (!deserializer->cur_predicate)
      return TRACKER_SPARQL_VALUE_TYPE_UNBOUND;
    else
      return TRACKER_SPARQL_VALUE_TYPE_URI;
    break;
  case TRACKER_RDF_COL_OBJECT:
    if (!deserializer->cur_object)
      return TRACKER_SPARQL_VALUE_TYPE_UNBOUND;
    else
      return deserializer->object_type;
    break;
  case TRACKER_RDF_COL_GRAPH:
    if (!deserializer->cur_graph)
      return TRACKER_SPARQL_VALUE_TYPE_UNBOUND;
    else
      return TRACKER_SPARQL_VALUE_TYPE_URI;
    break;
  default:
    return TRACKER_SPARQL_VALUE_TYPE_UNBOUND;
  }
}

static const gchar *
tracker_deserializer_json_ld_get_string (TrackerSparqlCursor  *cursor,
                                         gint                  column,
                                         const gchar         **langtag,
                                         glong                *length)
{
  TrackerDeserializerJsonLD *deserializer =
    TRACKER_DESERIALIZER_JSON_LD (cursor);
  const gchar *str = NULL;

  if (length)
    *length = 0;
  if (langtag)
    *langtag = NULL;

  switch (column) {
  case TRACKER_RDF_COL_SUBJECT:
    str = deserializer->cur_subject;
    break;
  case TRACKER_RDF_COL_PREDICATE:
    str = deserializer->cur_predicate;
    break;
  case TRACKER_RDF_COL_OBJECT:
    if (langtag) {
      if (deserializer->cur_object_lang)
        *langtag = deserializer->cur_object_lang;
      else
        *langtag = deserializer->default_lang;
    }

    str = deserializer->cur_object;
    break;
  case TRACKER_RDF_COL_GRAPH:
    str = deserializer->cur_graph;
    break;
  default:
    break;
  }

  if (length && str)
    *length = strlen (str);

  return str;
}

static gboolean
tracker_deserializer_json_ld_next (TrackerSparqlCursor  *cursor,
                                   GCancellable         *cancellable,
                                   GError              **error)
{
  TrackerDeserializerJsonLD *deserializer =
    TRACKER_DESERIALIZER_JSON_LD (cursor);

  if (deserializer->init_error) {
    GError *init_error;

    init_error = g_steal_pointer (&deserializer->init_error);
    g_propagate_error (error, init_error);
    return FALSE;
  }

  deserializer->has_row = FALSE;

  while (!deserializer->has_row) {
    GError *inner_error = NULL;

    if (g_cancellable_set_error_if_cancelled (cancellable, error))
      return FALSE;

    if (!forward_state (deserializer, &inner_error)) {
      if (inner_error) {
        g_propagate_error (error, inner_error);
      } else {
        const GError *reader_error;

        reader_error = json_reader_get_error (deserializer->reader);
        if (error && reader_error)
          *error = g_error_copy (reader_error);
      }

      return FALSE;
    }
  }

  if (!deserializer->cur_subject)
    deserializer->cur_subject = g_strdup_printf ("_:%d", deserializer->blank_node_idx++);

  return TRUE;
}

static void
tracker_deserializer_json_ld_close (TrackerSparqlCursor *cursor)
{
}

gboolean
tracker_deserializer_json_ld_get_parser_location (TrackerDeserializer  *deserializer,
                                                  const char          **name,
                                                  goffset              *line_no,
                                                  goffset              *column_no)
{
  if (name)
    *name = tracker_deserializer_get_name (deserializer);

  return FALSE;
}

static void
tracker_deserializer_json_ld_class_init (TrackerDeserializerJsonLDClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  TrackerSparqlCursorClass *cursor_class =
    TRACKER_SPARQL_CURSOR_CLASS (klass);
  TrackerDeserializerClass *deserializer_class =
    TRACKER_DESERIALIZER_CLASS (klass);

  object_class->finalize = tracker_deserializer_json_ld_finalize;
  object_class->constructed = tracker_deserializer_json_ld_constructed;

  cursor_class->get_value_type = tracker_deserializer_json_ld_get_value_type;
  cursor_class->get_string = tracker_deserializer_json_ld_get_string;
  cursor_class->next = tracker_deserializer_json_ld_next;
  cursor_class->close = tracker_deserializer_json_ld_close;

  deserializer_class->get_parser_location =
    tracker_deserializer_json_ld_get_parser_location;
}

static void
tracker_deserializer_json_ld_init (TrackerDeserializerJsonLD *deserializer)
{
  deserializer->parser = json_parser_new ();
  deserializer->state_stack = g_array_new (FALSE, FALSE, sizeof (StateStack));
  g_array_set_clear_func (deserializer->state_stack, state_clear);
}

TrackerSparqlCursor *
tracker_deserializer_json_ld_new (GInputStream            *stream,
                                  TrackerNamespaceManager *namespaces)
{
  return g_object_new (TRACKER_TYPE_DESERIALIZER_JSON_LD,
                       "stream", stream,
                       "namespace-manager", namespaces,
                       NULL);
}

Coverage Report

Created: 2026-01-09 07:08