C++ (Cpp) avro_map_get_key Examples

Example #1

File: test_avro_data.c Project: nagaral/warp

static int test_map(void)
{
    avro_schema_t schema = avro_schema_map(avro_schema_long());
    avro_datum_t datum = avro_map(schema);
    int64_t i = 0;
    char *nums[] =
    { "zero", "one", "two", "three", "four", "five", "six", NULL };
    while (nums[i]) {
        avro_datum_t i_datum = avro_int64(i);
        avro_map_set(datum, nums[i], i_datum);
        avro_datum_decref(i_datum);
        i++;
    }

    if (avro_array_size(datum) != 7) {
        fprintf(stderr, "Unexpected map size\n");
        exit(EXIT_FAILURE);
    }

    avro_datum_t value;
    const char  *key;
    avro_map_get_key(datum, 2, &key);
    avro_map_get(datum, key, &value);
    int64_t  val;
    avro_int64_get(value, &val);

    if (val != 2) {
        fprintf(stderr, "Unexpected map value 2\n");
        exit(EXIT_FAILURE);
    }

    int  index;
    if (avro_map_get_index(datum, "two", &index)) {
        fprintf(stderr, "Can't get index for key \"two\": %s\n",
                avro_strerror());
        exit(EXIT_FAILURE);
    }
    if (index != 2) {
        fprintf(stderr, "Unexpected index for key \"two\"\n");
        exit(EXIT_FAILURE);
    }
    if (!avro_map_get_index(datum, "foobar", &index)) {
        fprintf(stderr, "Unexpected index for key \"foobar\"\n");
        exit(EXIT_FAILURE);
    }

    write_read_check(schema, datum, NULL, NULL, "map");
    test_json(datum,
              "{\"zero\": 0, \"one\": 1, \"two\": 2, \"three\": 3, "
              "\"four\": 4, \"five\": 5, \"six\": 6}");
    avro_datum_decref(datum);
    avro_schema_decref(schema);
    return 0;
}

Example #2

File: datum_value.c Project: clayreimann/ObjectiveAvro

static int
avro_datum_value_get_by_index(const avro_value_iface_t *iface,
			      const void *vself, size_t index,
			      avro_value_t *child, const char **name)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	int  rval;
	avro_datum_t  child_datum;

	if (is_avro_array(self)) {
		check(rval, avro_array_get(self, index, &child_datum));
		return avro_datum_as_child_value(child, child_datum);
	}

	if (is_avro_map(self)) {
		const char  *real_key;
		check(rval, avro_map_get_key(self, index, &real_key));
		if (name != NULL) {
			*name = real_key;
		}
		check(rval, avro_map_get(self, real_key, &child_datum));
		return avro_datum_as_child_value(child, child_datum);
	}

	if (is_avro_record(self)) {
		avro_schema_t  schema = avro_datum_get_schema(self);
		const char  *field_name =
		    avro_schema_record_field_name(schema, index);
		if (field_name == NULL) {
			return EINVAL;
		}
		if (name != NULL) {
			*name = field_name;
		}
		check(rval, avro_record_get(self, field_name, &child_datum));
		return avro_datum_as_child_value(child, child_datum);
	}

	avro_set_error("Can only get by index from array, map, or record");
	return EINVAL;
}