Esempio n. 1
0
static void *
test_allocator(void *ud, void *ptr, size_t osize, size_t nsize)
{
    AVRO_UNUSED(ud);
    AVRO_UNUSED(osize);

    if (nsize == 0) {
        size_t  *size = ((size_t *) ptr) - 1;
        if (osize != *size) {
            fprintf(stderr,
                    "Error freeing %p:\n"
                    "Size passed to avro_free (%" PRIsz ") "
                    "doesn't match size passed to "
                    "avro_malloc (%" PRIsz ")\n",
                    ptr, osize, *size);
            abort();
            //exit(EXIT_FAILURE);
        }
        free(size);
        return NULL;
    } else {
        size_t  real_size = nsize + sizeof(size_t);
        size_t  *old_size = ptr? ((size_t *) ptr)-1: NULL;
        size_t  *size = (size_t *) realloc(old_size, real_size);
        *size = nsize;
        return (size + 1);
    }
}
Esempio n. 2
0
static int
avro_memoize_free_key(avro_memoize_key_t *key, void *result, void *dummy)
{
	AVRO_UNUSED(result);
	AVRO_UNUSED(dummy);
	avro_freet(avro_memoize_key_t, key);
	return ST_CONTINUE;
}
Esempio n. 3
0
static int union_free_foreach(int i, avro_schema_t schema, void *arg)
{
	AVRO_UNUSED(i);
	AVRO_UNUSED(arg);

	avro_schema_decref(schema);
	return ST_DELETE;
}
Esempio n. 4
0
static int enum_free_foreach(int i, char *sym, void *arg)
{
	AVRO_UNUSED(i);
	AVRO_UNUSED(arg);

	avro_str_free(sym);
	return ST_DELETE;
}
Esempio n. 5
0
static int
avro_datum_value_set_string_len(const avro_value_iface_t *iface,
				void *vself, const char *str, size_t size)
{
	AVRO_UNUSED(iface);
	AVRO_UNUSED(size);
	avro_datum_t  self = (avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");
	return avro_string_set(self, str);
}
Esempio n. 6
0
static int record_free_foreach(int i, struct avro_record_field_t *field,
			       void *arg)
{
	AVRO_UNUSED(i);
	AVRO_UNUSED(arg);

	avro_str_free(field->name);
	avro_schema_decref(field->type);
	avro_freet(struct avro_record_field_t, field);
	return ST_DELETE;
}
Esempio n. 7
0
static void *
avro_default_allocator(void *ud, void *ptr, size_t osize, size_t nsize)
{
    AVRO_UNUSED(ud);
    AVRO_UNUSED(osize);

    if (nsize == 0) {
        free(ptr);
        return NULL;
    } else {
        return realloc(ptr, nsize);
    }
}
Esempio n. 8
0
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);
}
Esempio n. 9
0
static int
read_record(avro_reader_t reader, const avro_encoding_t * enc,
	    avro_consumer_t *consumer, void *ud)
{
	int rval;
	size_t  num_fields;
	unsigned int  i;

	AVRO_UNUSED(enc);

	check(rval, avro_consumer_call(consumer, record_start, ud));

	num_fields = avro_schema_record_size(consumer->schema);
	for (i = 0; i < num_fields; i++) {
		avro_consumer_t  *field_consumer = NULL;
		void  *field_ud = NULL;

		check(rval, avro_consumer_call(consumer, record_field,
					       i, &field_consumer, &field_ud,
					       ud));

		if (field_consumer) {
			check(rval, avro_consume_binary(reader, field_consumer, field_ud));
		} else {
			avro_schema_t  field_schema =
			    avro_schema_record_field_get_by_index(consumer->schema, i);
			check(rval, avro_skip_data(reader, field_schema));
		}
	}

	return 0;
}
Esempio n. 10
0
static int
avro_datum_value_get_size(const avro_value_iface_t *iface,
			  const void *vself, size_t *size)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	if (is_avro_array(self)) {
		*size = avro_array_size(self);
		return 0;
	}

	if (is_avro_map(self)) {
		*size = avro_map_size(self);
		return 0;
	}

	if (is_avro_record(self)) {
		avro_schema_t  schema = avro_datum_get_schema(self);
		*size = avro_schema_record_size(schema);
		return 0;
	}

	avro_set_error("Can only get size of array, map, or record, %d", avro_typeof(self));
	return EINVAL;
}
Esempio n. 11
0
static avro_schema_t
avro_datum_value_get_schema(const avro_value_iface_t *iface, const void *vself)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(NULL, self, "datum instance");
	return avro_datum_get_schema(self);
}
Esempio n. 12
0
static int
avro_datum_value_set_null(const avro_value_iface_t *iface, void *vself)
{
	AVRO_UNUSED(iface);
	avro_datum_t  self = (avro_datum_t) vself;
	check_param(EINVAL, is_avro_null(self), "datum instance");
	return 0;
}
Esempio n. 13
0
static int
write_enum(avro_writer_t writer, const avro_encoding_t * enc,
	   struct avro_enum_schema_t *enump, struct avro_enum_datum_t *datum)
{
	AVRO_UNUSED(enump);

	return enc->write_long(writer, datum->value);
}
Esempio n. 14
0
static int
avro_datum_value_reset(const avro_value_iface_t *iface, void *vself)
{
	AVRO_UNUSED(iface);
	avro_datum_t  self = (avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");
	return avro_datum_reset(self);
}
Esempio n. 15
0
static int
avro_datum_value_set_long(const avro_value_iface_t *iface,
			  void *vself, int64_t val)
{
	AVRO_UNUSED(iface);
	avro_datum_t  self = (avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");
	return avro_int64_set(self, val);
}
Esempio n. 16
0
static int
avro_datum_value_set_fixed(const avro_value_iface_t *iface,
			   void *vself, void *buf, size_t size)
{
	AVRO_UNUSED(iface);
	avro_datum_t  self = (avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");
	return avro_fixed_set(self, (const char *) buf, size);
}
Esempio n. 17
0
static int
avro_datum_value_get_enum(const avro_value_iface_t *iface,
			  const void *vself, int *out)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, is_avro_enum(self), "datum instance");
	*out = avro_enum_get(self);
	return 0;
}
Esempio n. 18
0
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);
}
Esempio n. 19
0
int
avro_schema_from_json(const char *jsontext, const int32_t len,
		      avro_schema_t *schema, avro_schema_error_t *e)
{
	check_param(EINVAL, jsontext, "JSON text");
	check_param(EINVAL, schema, "schema pointer");

	json_t  *root;
	json_error_t  json_error;

	AVRO_UNUSED(len);
	AVRO_UNUSED(e);

	root = json_loads(jsontext, 0, &json_error);
	if (!root) {
		avro_set_error("Error parsing JSON: %s", json_error.text);
		return EINVAL;
	}

	return avro_schema_from_json_root(root, schema);
}
Esempio n. 20
0
int
main(int argc, char **argv)
{
	AVRO_UNUSED(argc);
	AVRO_UNUSED(argv);

	avro_value_t  v1;
	avro_value_t  v2;

	try(avro_generic_string_new(&v1, "test string a"),
	    "Cannot create string value");
	try(avro_generic_string_new(&v2, "test string b"),
	    "Cannot create string value");

	if (avro_value_equal(&v1, &v2)) {
		fprintf(stderr, "Unexpected avro_value_equal\n");
		return EXIT_FAILURE;
	}

	if (avro_value_equal_fast(&v1, &v2)) {
		fprintf(stderr, "Unexpected avro_value_equal_fast\n");
		return EXIT_FAILURE;
	}

	if (avro_value_cmp(&v1, &v2) >= 0) {
		fprintf(stderr, "Unexpected avro_value_cmp\n");
		return EXIT_FAILURE;
	}

	if (avro_value_cmp_fast(&v1, &v2) >= 0) {
		fprintf(stderr, "Unexpected avro_value_cmp_fast\n");
		return EXIT_FAILURE;
	}

	avro_value_decref(&v1);
	avro_value_decref(&v2);
	return 0;
}
Esempio n. 21
0
static int
avro_datum_value_get_long(const avro_value_iface_t *iface,
			  const void *vself, int64_t *out)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	int  rval;
	int64_t  value;
	check(rval, avro_int64_get(self, &value));
	*out = value;
	return 0;
}
Esempio n. 22
0
static int
avro_datum_value_get_discriminant(const avro_value_iface_t *iface,
				  const void *vself, int *out)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	if (!is_avro_union(self)) {
		avro_set_error("Can only get discriminant of union");
		return EINVAL;
	}

	*out = avro_union_discriminant(self);
	return 0;
}
Esempio n. 23
0
static int
avro_datum_value_get_current_branch(const avro_value_iface_t *iface,
				    const void *vself, avro_value_t *branch)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	if (!is_avro_union(self)) {
		avro_set_error("Can only get current branch of union");
		return EINVAL;
	}

	avro_datum_t  child_datum = avro_union_current_branch(self);
	return avro_datum_as_child_value(branch, child_datum);
}
Esempio n. 24
0
static int
avro_datum_value_grab_fixed(const avro_value_iface_t *iface,
			    const void *vself, avro_wrapped_buffer_t *dest)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	int  rval;
	char  *bytes;
	int64_t  sz;
	check(rval, avro_fixed_get(self, &bytes, &sz));

	/* nothing clever, just make a copy */
	return avro_wrapped_buffer_new_copy(dest, bytes, sz);
}
Esempio n. 25
0
static int
avro_datum_value_grab_string(const avro_value_iface_t *iface,
			     const void *vself, avro_wrapped_buffer_t *dest)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	int  rval;
	char  *str;
	size_t  sz;
	check(rval, avro_string_get(self, &str));
	sz = strlen(str);

	/* nothing clever, just make a copy */
	/* sz doesn't contain NUL terminator */
	return avro_wrapped_buffer_new_copy(dest, str, sz+1);
}
Esempio n. 26
0
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;
}
Esempio n. 27
0
static int
avro_datum_value_get_string(const avro_value_iface_t *iface,
			    const void *vself, const char **str, size_t *size)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	int  rval;
	char  *value;
	check(rval, avro_string_get(self, &value));
	if (str != NULL) {
		*str = (const char *) value;
	}
	if (size != NULL) {
		*size = strlen(value)+1;
	}
	return 0;
}
Esempio n. 28
0
static int
avro_datum_value_set_branch(const avro_value_iface_t *iface,
			    void *vself, int discriminant,
			    avro_value_t *branch)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	if (!is_avro_union(self)) {
		avro_set_error("Can only set branch of union");
		return EINVAL;
	}

	int  rval;
	avro_datum_t  child_datum;
	check(rval, avro_union_set_discriminant(self, discriminant, &child_datum));
	return avro_datum_as_child_value(branch, child_datum);
}
Esempio n. 29
0
static int
avro_datum_value_get_fixed(const avro_value_iface_t *iface,
			   const void *vself, const void **buf, size_t *size)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
	check_param(EINVAL, self, "datum instance");

	int  rval;
	char  *bytes;
	int64_t  sz;
	check(rval, avro_fixed_get(self, &bytes, &sz));
	if (buf != NULL) {
		*buf = (const void *) bytes;
	}
	if (size != NULL) {
		*size = sz;
	}
	return 0;
}
Esempio n. 30
0
static avro_type_t
avro_datum_value_get_type(const avro_value_iface_t *iface, const void *vself)
{
	AVRO_UNUSED(iface);
	const avro_datum_t  self = (const avro_datum_t) vself;
#ifdef _WIN32
#pragma message("#warning: Bug: EINVAL is not of type avro_type_t.")
#else
//#warning "Bug: EINVAL is not of type avro_type_t."
#endif
        /* We shouldn't use EINVAL as the return value to
         * check_param(), because EINVAL (= 22) is not a valid enum
         * avro_type_t. This is a structural issue -- we would need a
         * different interface on all the get_type functions to fix
         * this. For now, suppressing the error by casting EINVAL to
         * (avro_type_t) so the code compiles under C++.
         */
	check_param((avro_type_t) EINVAL, self, "datum instance");
	return avro_typeof(self);
}