type
stringclasses 5
values | content
stringlengths 9
163k
|
|---|---|
defines
|
#define avro_resolved_reader_init(iface, self) \
|
defines
|
#define avro_resolved_reader_done(iface, self) \
|
defines
|
#define avro_resolved_reader_reset_wrappers(iface, self) \
|
defines
|
#define avro_resolved_record_field(iface, rec, index) \
|
defines
|
#define avro_resolved_wunion_branch(_wunion) \
|
structs
|
struct avro_resolved_reader {
avro_value_iface_t parent;
/** The reference count for this interface. */
volatile int refcount;
/** The writer schema. */
avro_schema_t wschema;
/** The reader schema. */
avro_schema_t rschema;
/* The size of the value instances for this resolver. */
size_t instance_size;
/* A function to calculate the instance size once the overall
* top-level resolver (and all of its children) have been
* constructed. */
void
(*calculate_size)(avro_resolved_reader_t *iface);
/* A free function for this resolver */
void
(*free_iface)(avro_resolved_reader_t *iface, st_table *freeing);
/* An initialization function for instances of this resolver. */
int
(*init)(const avro_resolved_reader_t *iface, void *self);
/* A finalization function for instances of this resolver. */
void
(*done)(const avro_resolved_reader_t *iface, void *self);
/* Clear out any existing wrappers, if any */
int
(*reset_wrappers)(const avro_resolved_reader_t *iface, void *self);
};
|
structs
|
struct avro_resolved_link_reader {
avro_resolved_reader_t parent;
/**
* A pointer to the “next” link resolver that we've had to
* create. We use this as we're creating the overall top-level
* resolver to keep track of which ones we have to fix up
* afterwards.
*/
avro_resolved_link_reader_t *next;
/** The target's implementation. */
avro_resolved_reader_t *target_resolver;
};
|
functions
|
void
avro_resolved_reader_set_source(avro_value_t *resolved,
avro_value_t *dest)
{
avro_value_t *self = (avro_value_t *) resolved->self;
if (self->self != NULL) {
avro_value_decref(self);
}
|
functions
|
void
avro_resolved_reader_clear_source(avro_value_t *resolved)
{
avro_value_t *self = (avro_value_t *) resolved->self;
if (self->self != NULL) {
avro_value_decref(self);
}
|
functions
|
int
avro_resolved_reader_new_value(avro_value_iface_t *viface,
avro_value_t *value)
{
int rval;
avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
void *self = avro_malloc(iface->instance_size + sizeof(volatile int));
if (self == NULL) {
value->iface = NULL;
value->self = NULL;
return ENOMEM;
}
|
functions
|
void
avro_resolved_reader_free_value(const avro_value_iface_t *viface, void *vself)
{
avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
avro_value_t *self = (avro_value_t *) vself;
avro_resolved_reader_done(iface, vself);
if (self->self != NULL) {
avro_value_decref(self);
}
|
functions
|
void
avro_resolved_reader_incref(avro_value_t *value)
{
/*
* This only works if you pass in the top-level value.
*/
volatile int *refcount = (volatile int *) ((char *) value->self - sizeof(volatile int));
avro_refcount_inc(refcount);
}
|
functions
|
void
avro_resolved_reader_decref(avro_value_t *value)
{
/*
* This only works if you pass in the top-level value.
*/
volatile int *refcount = (volatile int *) ((char *) value->self - sizeof(volatile int));
if (avro_refcount_dec(refcount)) {
avro_resolved_reader_free_value(value->iface, value->self);
}
|
functions
|
void
free_resolver(avro_resolved_reader_t *iface, st_table *freeing)
{
/* First check if we've already started freeing this resolver. */
if (st_lookup(freeing, (st_data_t) iface, NULL)) {
AVRO_DEBUG("Already freed %p", iface);
return;
}
|
functions
|
void
avro_resolved_reader_calculate_size_(avro_resolved_reader_t *iface)
{
/* Only calculate the size for any resolver once */
iface->calculate_size = NULL;
AVRO_DEBUG("Calculating size for %s->%s",
avro_schema_type_name((iface)->wschema),
avro_schema_type_name((iface)->rschema));
iface->instance_size = sizeof(avro_value_t);
}
|
functions
|
void
avro_resolved_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing)
{
AVRO_UNUSED(freeing);
avro_schema_decref(iface->wschema);
avro_schema_decref(iface->rschema);
avro_freet(avro_resolved_reader_t, iface);
}
|
functions
|
void
avro_resolved_reader_decref_iface(avro_value_iface_t *viface)
{
avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
AVRO_DEBUG("Decref resolver %p (before=%d)", iface, iface->refcount);
if (avro_refcount_dec(&iface->refcount)) {
st_table *freeing = st_init_numtable();
free_resolver(iface, freeing);
st_free_table(freeing);
}
|
functions
|
int
avro_resolved_reader_reset(const avro_value_iface_t *viface, void *vself)
{
/*
* To reset a wrapped value, we first clear out any wrappers,
* and then have the wrapped value reset itself.
*/
int rval;
avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
avro_value_t *self = (avro_value_t *) vself;
check(rval, avro_resolved_reader_reset_wrappers(iface, vself));
return avro_value_reset(self);
}
|
functions
|
avro_type_t
avro_resolved_reader_get_type(const avro_value_iface_t *viface, const void *vself)
{
AVRO_UNUSED(vself);
const avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
return avro_typeof(iface->rschema);
}
|
functions
|
avro_schema_t
avro_resolved_reader_get_schema(const avro_value_iface_t *viface, const void *vself)
{
AVRO_UNUSED(vself);
avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
return iface->rschema;
}
|
functions
|
void
avro_resolved_wlink_reader_calculate_size(avro_resolved_reader_t *iface)
{
/* Only calculate the size for any resolver once */
iface->calculate_size = NULL;
AVRO_DEBUG("Calculating size for [%s]->%s",
avro_schema_type_name((iface)->wschema),
avro_schema_type_name((iface)->rschema));
iface->instance_size = sizeof(avro_resolved_link_value_t);
}
|
functions
|
void
avro_resolved_rlink_reader_calculate_size(avro_resolved_reader_t *iface)
{
/* Only calculate the size for any resolver once */
iface->calculate_size = NULL;
AVRO_DEBUG("Calculating size for %s->[%s]",
avro_schema_type_name((iface)->wschema),
avro_schema_type_name((iface)->rschema));
iface->instance_size = sizeof(avro_resolved_link_value_t);
}
|
functions
|
void
avro_resolved_link_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing)
{
avro_resolved_link_reader_t *liface =
container_of(iface, avro_resolved_link_reader_t, parent);
if (liface->target_resolver != NULL) {
free_resolver(liface->target_resolver, freeing);
}
|
functions
|
int
avro_resolved_link_reader_init(const avro_resolved_reader_t *iface, void *vself)
{
int rval;
const avro_resolved_link_reader_t *liface =
container_of(iface, avro_resolved_link_reader_t, parent);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
size_t target_instance_size = liface->target_resolver->instance_size;
self->target.iface = &liface->target_resolver->parent;
self->target.self = avro_malloc(target_instance_size);
if (self->target.self == NULL) {
return ENOMEM;
}
|
functions
|
void
avro_resolved_link_reader_done(const avro_resolved_reader_t *iface, void *vself)
{
const avro_resolved_link_reader_t *liface =
container_of(iface, avro_resolved_link_reader_t, parent);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
size_t target_instance_size = liface->target_resolver->instance_size;
AVRO_DEBUG("Freeing <%p:%" PRIsz "> for link", self->target.self, target_instance_size);
avro_resolved_reader_done(liface->target_resolver, self->target.self);
avro_free(self->target.self, target_instance_size);
self->target.iface = NULL;
self->target.self = NULL;
}
|
functions
|
int
avro_resolved_link_reader_reset(const avro_resolved_reader_t *iface, void *vself)
{
const avro_resolved_link_reader_t *liface =
container_of(iface, avro_resolved_link_reader_t, parent);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
return avro_resolved_reader_reset_wrappers
(liface->target_resolver, self->target.self);
}
|
functions
|
avro_type_t
avro_resolved_link_reader_get_type(const avro_value_iface_t *iface, const void *vself)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_type(&self->target);
}
|
functions
|
avro_schema_t
avro_resolved_link_reader_get_schema(const avro_value_iface_t *iface, const void *vself)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_schema(&self->target);
}
|
functions
|
int
avro_resolved_link_reader_get_boolean(const avro_value_iface_t *iface,
const void *vself, int *out)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_boolean(&self->target, out);
}
|
functions
|
int
avro_resolved_link_reader_get_bytes(const avro_value_iface_t *iface,
const void *vself, const void **buf, size_t *size)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_bytes(&self->target, buf, size);
}
|
functions
|
int
avro_resolved_link_reader_grab_bytes(const avro_value_iface_t *iface,
const void *vself, avro_wrapped_buffer_t *dest)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_grab_bytes(&self->target, dest);
}
|
functions
|
int
avro_resolved_link_reader_get_double(const avro_value_iface_t *iface,
const void *vself, double *out)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_double(&self->target, out);
}
|
functions
|
int
avro_resolved_link_reader_get_float(const avro_value_iface_t *iface,
const void *vself, float *out)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_float(&self->target, out);
}
|
functions
|
int
avro_resolved_link_reader_get_int(const avro_value_iface_t *iface,
const void *vself, int32_t *out)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_int(&self->target, out);
}
|
functions
|
int
avro_resolved_link_reader_get_long(const avro_value_iface_t *iface,
const void *vself, int64_t *out)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_long(&self->target, out);
}
|
functions
|
int
avro_resolved_link_reader_get_null(const avro_value_iface_t *iface, const void *vself)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_null(&self->target);
}
|
functions
|
int
avro_resolved_link_reader_get_string(const avro_value_iface_t *iface,
const void *vself, const char **str, size_t *size)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_string(&self->target, str, size);
}
|
functions
|
int
avro_resolved_link_reader_grab_string(const avro_value_iface_t *iface,
const void *vself, avro_wrapped_buffer_t *dest)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_grab_string(&self->target, dest);
}
|
functions
|
int
avro_resolved_link_reader_get_enum(const avro_value_iface_t *iface,
const void *vself, int *out)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_enum(&self->target, out);
}
|
functions
|
int
avro_resolved_link_reader_get_fixed(const avro_value_iface_t *iface,
const void *vself, const void **buf, size_t *size)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_fixed(&self->target, buf, size);
}
|
functions
|
int
avro_resolved_link_reader_grab_fixed(const avro_value_iface_t *iface,
const void *vself, avro_wrapped_buffer_t *dest)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_grab_fixed(&self->target, dest);
}
|
functions
|
int
avro_resolved_link_reader_set_boolean(const avro_value_iface_t *iface,
void *vself, int val)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_boolean(&self->target, val);
}
|
functions
|
int
avro_resolved_link_reader_set_bytes(const avro_value_iface_t *iface,
void *vself, void *buf, size_t size)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_bytes(&self->target, buf, size);
}
|
functions
|
int
avro_resolved_link_reader_give_bytes(const avro_value_iface_t *iface,
void *vself, avro_wrapped_buffer_t *buf)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_give_bytes(&self->target, buf);
}
|
functions
|
int
avro_resolved_link_reader_set_double(const avro_value_iface_t *iface,
void *vself, double val)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_double(&self->target, val);
}
|
functions
|
int
avro_resolved_link_reader_set_float(const avro_value_iface_t *iface,
void *vself, float val)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_float(&self->target, val);
}
|
functions
|
int
avro_resolved_link_reader_set_int(const avro_value_iface_t *iface,
void *vself, int32_t val)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_int(&self->target, val);
}
|
functions
|
int
avro_resolved_link_reader_set_long(const avro_value_iface_t *iface,
void *vself, int64_t val)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_long(&self->target, val);
}
|
functions
|
int
avro_resolved_link_reader_set_null(const avro_value_iface_t *iface, void *vself)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_null(&self->target);
}
|
functions
|
int
avro_resolved_link_reader_set_string(const avro_value_iface_t *iface,
void *vself, const char *str)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_string(&self->target, str);
}
|
functions
|
int
avro_resolved_link_reader_set_string_len(const avro_value_iface_t *iface,
void *vself, const char *str, size_t size)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_string_len(&self->target, str, size);
}
|
functions
|
int
avro_resolved_link_reader_give_string_len(const avro_value_iface_t *iface,
void *vself, avro_wrapped_buffer_t *buf)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_give_string_len(&self->target, buf);
}
|
functions
|
int
avro_resolved_link_reader_set_enum(const avro_value_iface_t *iface,
void *vself, int val)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_enum(&self->target, val);
}
|
functions
|
int
avro_resolved_link_reader_set_fixed(const avro_value_iface_t *iface,
void *vself, void *buf, size_t size)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_fixed(&self->target, buf, size);
}
|
functions
|
int
avro_resolved_link_reader_give_fixed(const avro_value_iface_t *iface,
void *vself, avro_wrapped_buffer_t *buf)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_give_fixed(&self->target, buf);
}
|
functions
|
int
avro_resolved_link_reader_get_size(const avro_value_iface_t *iface,
const void *vself, size_t *size)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_size(&self->target, size);
}
|
functions
|
int
avro_resolved_link_reader_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_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_by_index(&self->target, index, child, name);
}
|
functions
|
int
avro_resolved_link_reader_get_by_name(const avro_value_iface_t *iface,
const void *vself, const char *name,
avro_value_t *child, size_t *index)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_by_name(&self->target, name, child, index);
}
|
functions
|
int
avro_resolved_link_reader_get_discriminant(const avro_value_iface_t *iface,
const void *vself, int *out)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_discriminant(&self->target, out);
}
|
functions
|
int
avro_resolved_link_reader_get_current_branch(const avro_value_iface_t *iface,
const void *vself, avro_value_t *branch)
{
AVRO_UNUSED(iface);
const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_get_current_branch(&self->target, branch);
}
|
functions
|
int
avro_resolved_link_reader_append(const avro_value_iface_t *iface,
void *vself, avro_value_t *child_out,
size_t *new_index)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_append(&self->target, child_out, new_index);
}
|
functions
|
int
avro_resolved_link_reader_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_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_add(&self->target, key, child, index, is_new);
}
|
functions
|
int
avro_resolved_link_reader_set_branch(const avro_value_iface_t *iface,
void *vself, int discriminant,
avro_value_t *branch)
{
AVRO_UNUSED(iface);
avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself;
avro_value_t *target_vself = (avro_value_t *) self->target.self;
*target_vself = self->wrapped;
return avro_value_set_branch(&self->target, discriminant, branch);
}
|
functions
|
int
avro_resolved_reader_get_boolean(const avro_value_iface_t *viface,
const void *vself, int *val)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting boolean from %p", src->self);
return avro_value_get_boolean(src, val);
}
|
functions
|
int
avro_resolved_reader_get_bytes(const avro_value_iface_t *viface,
const void *vself, const void **buf, size_t *size)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting bytes from %p", src->self);
return avro_value_get_bytes(src, buf, size);
}
|
functions
|
int
avro_resolved_reader_grab_bytes(const avro_value_iface_t *viface,
const void *vself, avro_wrapped_buffer_t *dest)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Grabbing bytes from %p", src->self);
return avro_value_grab_bytes(src, dest);
}
|
functions
|
int
avro_resolved_reader_get_double(const avro_value_iface_t *viface,
const void *vself, double *val)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting double from %p", src->self);
return avro_value_get_double(src, val);
}
|
functions
|
int
avro_resolved_reader_get_double_float(const avro_value_iface_t *viface,
const void *vself, double *val)
{
int rval;
float real_val;
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Promoting double from float %p", src->self);
check(rval, avro_value_get_float(src, &real_val));
*val = real_val;
return 0;
}
|
functions
|
int
avro_resolved_reader_get_double_int(const avro_value_iface_t *viface,
const void *vself, double *val)
{
int rval;
int32_t real_val;
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Promoting double from int %p", src->self);
check(rval, avro_value_get_int(src, &real_val));
*val = real_val;
return 0;
}
|
functions
|
int
avro_resolved_reader_get_double_long(const avro_value_iface_t *viface,
const void *vself, double *val)
{
int rval;
int64_t real_val;
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Promoting double from long %p", src->self);
check(rval, avro_value_get_long(src, &real_val));
*val = (double) real_val;
return 0;
}
|
functions
|
int
avro_resolved_reader_get_float(const avro_value_iface_t *viface,
const void *vself, float *val)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting float from %p", src->self);
return avro_value_get_float(src, val);
}
|
functions
|
int
avro_resolved_reader_get_float_int(const avro_value_iface_t *viface,
const void *vself, float *val)
{
int rval;
int32_t real_val;
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Promoting float from int %p", src->self);
check(rval, avro_value_get_int(src, &real_val));
*val = (float) real_val;
return 0;
}
|
functions
|
int
avro_resolved_reader_get_float_long(const avro_value_iface_t *viface,
const void *vself, float *val)
{
int rval;
int64_t real_val;
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Promoting float from long %p", src->self);
check(rval, avro_value_get_long(src, &real_val));
*val = (float) real_val;
return 0;
}
|
functions
|
int
avro_resolved_reader_get_int(const avro_value_iface_t *viface,
const void *vself, int32_t *val)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting int from %p", src->self);
return avro_value_get_int(src, val);
}
|
functions
|
int
avro_resolved_reader_get_long(const avro_value_iface_t *viface,
const void *vself, int64_t *val)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting long from %p", src->self);
return avro_value_get_long(src, val);
}
|
functions
|
int
avro_resolved_reader_get_long_int(const avro_value_iface_t *viface,
const void *vself, int64_t *val)
{
int rval;
int32_t real_val;
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Promoting long from int %p", src->self);
check(rval, avro_value_get_int(src, &real_val));
*val = real_val;
return 0;
}
|
functions
|
int
avro_resolved_reader_get_null(const avro_value_iface_t *viface,
const void *vself)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting null from %p", src->self);
return avro_value_get_null(src);
}
|
functions
|
int
avro_resolved_reader_get_string(const avro_value_iface_t *viface,
const void *vself, const char **str, size_t *size)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting string from %p", src->self);
return avro_value_get_string(src, str, size);
}
|
functions
|
int
avro_resolved_reader_grab_string(const avro_value_iface_t *viface,
const void *vself, avro_wrapped_buffer_t *dest)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Grabbing string from %p", src->self);
return avro_value_grab_string(src, dest);
}
|
functions
|
void
avro_resolved_array_reader_calculate_size(avro_resolved_reader_t *iface)
{
avro_resolved_array_reader_t *aiface =
container_of(iface, avro_resolved_array_reader_t, parent);
/* Only calculate the size for any resolver once */
iface->calculate_size = NULL;
AVRO_DEBUG("Calculating size for %s->%s",
avro_schema_type_name((iface)->wschema),
avro_schema_type_name((iface)->rschema));
iface->instance_size = sizeof(avro_resolved_array_value_t);
avro_resolved_reader_calculate_size(aiface->child_resolver);
}
|
functions
|
void
avro_resolved_array_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing)
{
avro_resolved_array_reader_t *aiface =
container_of(iface, avro_resolved_array_reader_t, parent);
free_resolver(aiface->child_resolver, freeing);
avro_schema_decref(iface->wschema);
avro_schema_decref(iface->rschema);
avro_freet(avro_resolved_array_reader_t, iface);
}
|
functions
|
int
avro_resolved_array_reader_init(const avro_resolved_reader_t *iface, void *vself)
{
const avro_resolved_array_reader_t *aiface =
container_of(iface, avro_resolved_array_reader_t, parent);
avro_resolved_array_value_t *self = (avro_resolved_array_value_t *) vself;
size_t child_instance_size = aiface->child_resolver->instance_size;
AVRO_DEBUG("Initializing child array (child_size=%" PRIsz ")", child_instance_size);
avro_raw_array_init(&self->children, child_instance_size);
return 0;
}
|
functions
|
void
avro_resolved_array_reader_free_elements(const avro_resolved_reader_t *child_iface,
avro_resolved_array_value_t *self)
{
size_t i;
for (i = 0; i < avro_raw_array_size(&self->children); i++) {
void *child_self = avro_raw_array_get_raw(&self->children, i);
avro_resolved_reader_done(child_iface, child_self);
}
|
functions
|
void
avro_resolved_array_reader_done(const avro_resolved_reader_t *iface, void *vself)
{
const avro_resolved_array_reader_t *aiface =
container_of(iface, avro_resolved_array_reader_t, parent);
avro_resolved_array_value_t *self = (avro_resolved_array_value_t *) vself;
avro_resolved_array_reader_free_elements(aiface->child_resolver, self);
avro_raw_array_done(&self->children);
}
|
functions
|
int
avro_resolved_array_reader_reset(const avro_resolved_reader_t *iface, void *vself)
{
const avro_resolved_array_reader_t *aiface =
container_of(iface, avro_resolved_array_reader_t, parent);
avro_resolved_array_value_t *self = (avro_resolved_array_value_t *) vself;
/* Clear out our cache of wrapped children */
avro_resolved_array_reader_free_elements(aiface->child_resolver, self);
avro_raw_array_clear(&self->children);
return 0;
}
|
functions
|
int
avro_resolved_array_reader_get_size(const avro_value_iface_t *viface,
const void *vself, size_t *size)
{
AVRO_UNUSED(viface);
const avro_resolved_array_value_t *self = (const avro_resolved_array_value_t *) vself;
return avro_value_get_size(&self->wrapped, size);
}
|
functions
|
int
avro_resolved_array_reader_get_by_index(const avro_value_iface_t *viface,
const void *vself, size_t index,
avro_value_t *child, const char **name)
{
int rval;
size_t old_size;
size_t new_size;
const avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
const avro_resolved_array_reader_t *aiface =
container_of(iface, avro_resolved_array_reader_t, parent);
avro_resolved_array_value_t *self = (avro_resolved_array_value_t *) vself;
/*
* Ensure that our child wrapper array is big enough to hold
* this many elements.
*/
new_size = index + 1;
check(rval, avro_raw_array_ensure_size0(&self->children, new_size));
old_size = avro_raw_array_size(&self->children);
if (old_size <= index) {
size_t i;
for (i = old_size; i < new_size; i++) {
check(rval, avro_resolved_reader_init
(aiface->child_resolver,
avro_raw_array_get_raw(&self->children, i)));
}
|
functions
|
int
avro_resolved_reader_get_enum(const avro_value_iface_t *viface,
const void *vself, int *val)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting enum from %p", src->self);
return avro_value_get_enum(src, val);
}
|
functions
|
int
avro_resolved_reader_get_fixed(const avro_value_iface_t *viface,
const void *vself, const void **buf, size_t *size)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Getting fixed from %p", vself);
return avro_value_get_fixed(src, buf, size);
}
|
functions
|
int
avro_resolved_reader_grab_fixed(const avro_value_iface_t *viface,
const void *vself, avro_wrapped_buffer_t *dest)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
AVRO_DEBUG("Grabbing fixed from %p", vself);
return avro_value_grab_fixed(src, dest);
}
|
functions
|
void
avro_resolved_map_reader_calculate_size(avro_resolved_reader_t *iface)
{
avro_resolved_map_reader_t *miface =
container_of(iface, avro_resolved_map_reader_t, parent);
/* Only calculate the size for any resolver once */
iface->calculate_size = NULL;
AVRO_DEBUG("Calculating size for %s->%s",
avro_schema_type_name((iface)->wschema),
avro_schema_type_name((iface)->rschema));
iface->instance_size = sizeof(avro_resolved_map_value_t);
avro_resolved_reader_calculate_size(miface->child_resolver);
}
|
functions
|
void
avro_resolved_map_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing)
{
avro_resolved_map_reader_t *miface =
container_of(iface, avro_resolved_map_reader_t, parent);
free_resolver(miface->child_resolver, freeing);
avro_schema_decref(iface->wschema);
avro_schema_decref(iface->rschema);
avro_freet(avro_resolved_map_reader_t, iface);
}
|
functions
|
int
avro_resolved_map_reader_init(const avro_resolved_reader_t *iface, void *vself)
{
const avro_resolved_map_reader_t *miface =
container_of(iface, avro_resolved_map_reader_t, parent);
avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself;
size_t child_instance_size = miface->child_resolver->instance_size;
AVRO_DEBUG("Initializing child array for map (child_size=%" PRIsz ")", child_instance_size);
avro_raw_array_init(&self->children, child_instance_size);
return 0;
}
|
functions
|
void
avro_resolved_map_reader_free_elements(const avro_resolved_reader_t *child_iface,
avro_resolved_map_value_t *self)
{
size_t i;
for (i = 0; i < avro_raw_array_size(&self->children); i++) {
void *child_self = avro_raw_array_get_raw(&self->children, i);
avro_resolved_reader_done(child_iface, child_self);
}
|
functions
|
void
avro_resolved_map_reader_done(const avro_resolved_reader_t *iface, void *vself)
{
const avro_resolved_map_reader_t *miface =
container_of(iface, avro_resolved_map_reader_t, parent);
avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself;
avro_resolved_map_reader_free_elements(miface->child_resolver, self);
avro_raw_array_done(&self->children);
}
|
functions
|
int
avro_resolved_map_reader_reset(const avro_resolved_reader_t *iface, void *vself)
{
const avro_resolved_map_reader_t *miface =
container_of(iface, avro_resolved_map_reader_t, parent);
avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself;
/* Clear out our cache of wrapped children */
avro_resolved_map_reader_free_elements(miface->child_resolver, self);
return 0;
}
|
functions
|
int
avro_resolved_map_reader_get_size(const avro_value_iface_t *viface,
const void *vself, size_t *size)
{
AVRO_UNUSED(viface);
const avro_value_t *src = (const avro_value_t *) vself;
return avro_value_get_size(src, size);
}
|
functions
|
int
avro_resolved_map_reader_get_by_index(const avro_value_iface_t *viface,
const void *vself, size_t index,
avro_value_t *child, const char **name)
{
int rval;
const avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
const avro_resolved_map_reader_t *miface =
container_of(iface, avro_resolved_map_reader_t, parent);
avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself;
/*
* Ensure that our child wrapper array is big enough to hold
* this many elements.
*/
check(rval, avro_raw_array_ensure_size0(&self->children, index+1));
if (avro_raw_array_size(&self->children) <= index) {
avro_raw_array_size(&self->children) = index+1;
}
|
functions
|
int
avro_resolved_map_reader_get_by_name(const avro_value_iface_t *viface,
const void *vself, const char *name,
avro_value_t *child, size_t *index)
{
int rval;
const avro_resolved_reader_t *iface =
container_of(viface, avro_resolved_reader_t, parent);
const avro_resolved_map_reader_t *miface =
container_of(iface, avro_resolved_map_reader_t, parent);
avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself;
/*
* This is a bit convoluted. We need to stash the wrapped child
* value somewhere in our children array. But we don't know
* where to put it until the wrapped map tells us what its index
* is.
*/
avro_value_t real_child;
size_t real_index;
AVRO_DEBUG("Getting element %s from map %p", name, self->wrapped.self);
check(rval, avro_value_get_by_name
(&self->wrapped, name, &real_child, &real_index));
/*
* Ensure that our child wrapper array is big enough to hold
* this many elements.
*/
check(rval, avro_raw_array_ensure_size0(&self->children, real_index+1));
if (avro_raw_array_size(&self->children) <= real_index) {
avro_raw_array_size(&self->children) = real_index+1;
}
|
functions
|
void
avro_resolved_record_reader_calculate_size(avro_resolved_reader_t *iface)
{
avro_resolved_record_reader_t *riface =
container_of(iface, avro_resolved_record_reader_t, parent);
/* Only calculate the size for any resolver once */
iface->calculate_size = NULL;
AVRO_DEBUG("Calculating size for %s->%s",
avro_schema_type_name((iface)->wschema),
avro_schema_type_name((iface)->rschema));
/*
* Once we've figured out which reader fields we actually need,
* calculate an offset for each one.
*/
size_t ri;
size_t next_offset = sizeof(avro_resolved_record_value_t);
for (ri = 0; ri < riface->field_count; ri++) {
riface->field_offsets[ri] = next_offset;
if (riface->field_resolvers[ri] != NULL) {
avro_resolved_reader_calculate_size
(riface->field_resolvers[ri]);
size_t field_size =
riface->field_resolvers[ri]->instance_size;
AVRO_DEBUG("Field %" PRIsz " has size %" PRIsz, ri, field_size);
next_offset += field_size;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.