static int
avro_datum_value_append(const avro_value_iface_t *iface,
			void *vself, avro_value_t *child_out, size_t *new_index)
{
	AVRO_UNUSED(iface);
	avro_datum_t  self = (avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	if (!is_avro_array(self)) {
		avro_set_error("Can only append to array");
		return EINVAL;
	}

	int  rval;

	avro_schema_t  array_schema = avro_datum_get_schema(self);
	avro_schema_t  child_schema = avro_schema_array_items(array_schema);
	avro_datum_t  child_datum = avro_datum_from_schema(child_schema);
	if (child_datum == NULL) {
		return ENOMEM;
	}

	rval = avro_array_append_datum(self, child_datum);
	avro_datum_decref(child_datum);
	if (rval != 0) {
		return rval;
	}

	if (new_index != NULL) {
		*new_index = avro_array_size(self) - 1;
	}
	return avro_datum_as_child_value(child_out, child_datum);
}
Exemple #2
0
static avro_datum_t json_t_to_avro_value(
		const avro_schema_t schema, const json_t *json)
{
	avro_datum_t datum = avro_datum_from_schema(schema);
	if (datum == NULL) return NULL;
	int rval = json_t_to_avro_value_helper(schema, json, datum);
	if (rval) {
		avro_datum_decref(datum);
		return NULL;
	}
	return datum;
}
static int
avro_datum_value_add(const avro_value_iface_t *iface,
		     void *vself, const char *key,
		     avro_value_t *child, size_t *index, int *is_new)
{
	AVRO_UNUSED(iface);
	avro_datum_t  self = (avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	if (!is_avro_map(self)) {
		avro_set_error("Can only add to map");
		return EINVAL;
	}

	int  rval;
	avro_datum_t  child_datum;

	if (avro_map_get(self, key, &child_datum) == 0) {
		/* key already exists */
		if (is_new != NULL) {
			*is_new = 0;
		}
		if (index != NULL) {
			int  real_index;
			avro_map_get_index(self, key, &real_index);
			*index = real_index;
		}
		return avro_datum_as_child_value(child, child_datum);
	}

	/* key is new */
	avro_schema_t  map_schema = avro_datum_get_schema(self);
	avro_schema_t  child_schema = avro_schema_map_values(map_schema);
	child_datum = avro_datum_from_schema(child_schema);
	if (child_datum == NULL) {
		return ENOMEM;
	}

	rval = avro_map_set(self, key, child_datum);
	avro_datum_decref(child_datum);
	if (rval != 0) {
		return rval;
	}

	if (is_new != NULL) {
		*is_new = 1;
	}
	if (index != NULL) {
		*index = avro_map_size(self) - 1;
	}

	return avro_datum_as_child_value(child, child_datum);
}
Exemple #4
0
static int test_union(void)
{
    avro_schema_t schema = avro_schema_union();
    avro_datum_t union_datum;
    avro_datum_t datum;
    avro_datum_t union_datum1;
    avro_datum_t datum1;

    avro_schema_union_append(schema, avro_schema_string());
    avro_schema_union_append(schema, avro_schema_int());
    avro_schema_union_append(schema, avro_schema_null());

    datum = avro_givestring("Follow your bliss.", NULL);
    union_datum = avro_union(schema, 0, datum);

    if (avro_union_discriminant(union_datum) != 0) {
        fprintf(stderr, "Unexpected union discriminant\n");
        exit(EXIT_FAILURE);
    }

    if (avro_union_current_branch(union_datum) != datum) {
        fprintf(stderr, "Unexpected union branch datum\n");
        exit(EXIT_FAILURE);
    }

    union_datum1 = avro_datum_from_schema(schema);
    avro_union_set_discriminant(union_datum1, 0, &datum1);
    avro_givestring_set(datum1, "Follow your bliss.", NULL);

    if (!avro_datum_equal(datum, datum1)) {
        fprintf(stderr, "Union values should be equal\n");
        exit(EXIT_FAILURE);
    }

    write_read_check(schema, union_datum, NULL, NULL, "union");
    test_json(union_datum, "{\"string\": \"Follow your bliss.\"}");

    avro_datum_decref(datum);
    avro_union_set_discriminant(union_datum, 2, &datum);
    test_json(union_datum, "null");

    avro_datum_decref(union_datum);
    avro_datum_decref(datum);
    avro_datum_decref(union_datum1);
    avro_schema_decref(schema);
    return 0;
}
Exemple #5
0
static int test_nested_record(void)
{
    const char  *json =
        "{"
        "  \"type\": \"record\","
        "  \"name\": \"list\","
        "  \"fields\": ["
        "    { \"name\": \"x\", \"type\": \"int\" },"
        "    { \"name\": \"y\", \"type\": \"int\" },"
        "    { \"name\": \"next\", \"type\": [\"null\",\"list\"]}"
        "  ]"
        "}";

    int  rval;

    avro_schema_t schema = NULL;
    avro_schema_error_t error;
    avro_schema_from_json(json, strlen(json), &schema, &error);

    avro_datum_t  head = avro_datum_from_schema(schema);
    avro_record_set_field_value(rval, head, int32, "x", 10);
    avro_record_set_field_value(rval, head, int32, "y", 10);

    avro_datum_t  next = NULL;
    avro_datum_t  tail = NULL;

    avro_record_get(head, "next", &next);
    avro_union_set_discriminant(next, 1, &tail);
    avro_record_set_field_value(rval, tail, int32, "x", 20);
    avro_record_set_field_value(rval, tail, int32, "y", 20);

    avro_record_get(tail, "next", &next);
    avro_union_set_discriminant(next, 0, NULL);

    write_read_check(schema, head, NULL, NULL, "nested record");

    avro_schema_decref(schema);
    avro_datum_decref(head);

    return 0;
}
Exemple #6
0
avro_datum_t avro_datum_from_schema(const avro_schema_t schema)
{
	check_param(NULL, is_avro_schema(schema), "schema");

	switch (avro_typeof(schema)) {
		case AVRO_STRING:
			return avro_givestring("", NULL);

		case AVRO_BYTES:
			return avro_givebytes("", 0, NULL);

		case AVRO_INT32:
			return avro_int32(0);

		case AVRO_INT64:
			return avro_int64(0);

		case AVRO_FLOAT:
			return avro_float(0);

		case AVRO_DOUBLE:
			return avro_double(0);

		case AVRO_BOOLEAN:
			return avro_boolean(0);

		case AVRO_NULL:
			return avro_null();

		case AVRO_RECORD:
			{
				const struct avro_record_schema_t *record_schema =
				    avro_schema_to_record(schema);

				avro_datum_t  rec = avro_record(schema);

				int  i;
				for (i = 0; i < record_schema->fields->num_entries; i++) {
					union {
						st_data_t data;
						struct avro_record_field_t *field;
					} val;
					st_lookup(record_schema->fields, i, &val.data);

					avro_datum_t  field =
					    avro_datum_from_schema(val.field->type);
					avro_record_set(rec, val.field->name, field);
					avro_datum_decref(field);
				}

				return rec;
			}

		case AVRO_ENUM:
			return avro_enum(schema, 0);

		case AVRO_FIXED:
			{
				const struct avro_fixed_schema_t *fixed_schema =
				    avro_schema_to_fixed(schema);
				return avro_givefixed(schema, NULL, fixed_schema->size, NULL);
			}

		case AVRO_MAP:
			return avro_map(schema);

		case AVRO_ARRAY:
			return avro_array(schema);

		case AVRO_UNION:
			return avro_union(schema, -1, NULL);

		case AVRO_LINK:
			{
				const struct avro_link_schema_t *link_schema =
				    avro_schema_to_link(schema);
				return avro_datum_from_schema(link_schema->to);
			}

		default:
			avro_set_error("Unknown schema type");
			return NULL;
	}
}