C++ (Cpp) jd_get_idx Examples

Example #1

File: jsonpath.c Project: AndyA/jsondata

static int path_iter_f(jd_var *result, jd_var *context, jd_var *arg) {
  jd_var *var = jd_get_idx(context, 0);
  jd_var *stack = jd_get_idx(context, 1);

  (void) arg;

  jd_set_void(result);
  if (jd_count(stack) == 0) return 1;

  scope {
    jd_var *slot = jd_nv();
    int i;
    size_t cnt;

    jd_pop(stack, 1, result);
    slot = jd_rv(var, jd_bytes(result, NULL));
    if (!slot) jd_die("Can't find %s", jd_bytes(result, NULL));

    if (slot->type == ARRAY) {
      cnt = jd_count(slot);
      for (i = cnt - 1; i >= 0; i--)
        jd_sprintf(jd_push(stack, 1), "%V.%u", result, i);
    }
    else if (slot->type == HASH) {
      jd_var *keys = jd_keys(jd_nv(), slot);
      cnt = jd_count(keys);
      for (i = cnt - 1; i >= 0; i--)
        jd_sprintf(jd_push(stack, 1), "%V.%V", result, jd_get_idx(keys, i));
    }
  }

  return 1;
}

Example #2

File: block-for.c Project: bbcarchdev/quilt

static jd_var *
for_current(LIQUIFYCTX *ctx, struct for_data *data)
{
	jd_var *k, *v;
	size_t count;

	(void) ctx;

	if(data->keys.type == ARRAY)
	{
		count = jd_count(&(data->keys));
		if(count <= data->idx)
		{
			return NULL;
		}
		k = jd_get_idx(&(data->keys), count - data->idx - 1);
		if(!k)
		{
			return NULL;
		}
		v = jd_get_key(&(data->list), k, 0);
	}
	else if(data->list.type == ARRAY)
	{
		if(jd_count(&(data->list)) <= data->idx)
		{
			return NULL;
		}
		v = jd_get_idx(&(data->list), data->idx);
	}
	else
	{
		v = NULL;
	}
	return v;
}

Example #3

File: jd_path.c Project: AndyA/emitron

jd_var *jd_get_context(jd_var *root, jd_var *path,
                       jd_path_context *ctx, int vivify) {
  jd_var *ptr = NULL;

  JD_SCOPE {
    JD_2VARS(part, elt);

    if (path->type == ARRAY)
      jd_clone(part, path, 0);
    else
      jd_split(part, path, jd_nsv("."));

    if (!jd_shift(part, 1, elt) || jd_compare(elt, jd_nsv("$")))
      jd_throw("Bad path");

    for (ptr = root; ptr && jd_shift(part, 1, elt);) {
      if (ptr->type == VOID) {
        /* empty slot: type depends on key format */
        if (is_positive_int(elt))
          jd_set_array(ptr, 1);
        else
          jd_set_hash(ptr, 1);
      }

      if (ptr->type == ARRAY) {
        size_t ac = jd_count(ptr);
        jd_int ix = jd_get_int(elt);
        if (ix == ac && vivify)
          ptr = jd_push(ptr, 1);
        else if (ix < ac)
          ptr = jd_get_idx(ptr, ix);
        else {
          ptr = NULL;
        }
      }
      else if (ptr->type == HASH) {
        ptr = jd_get_key(ptr, elt, vivify);
      }
      else {
        jd_throw("Unexpected element in structure");
      }
    }
  }

  return ptr;
}