Removed reflection and other extraneous things from the core library. (#158)
* Removed reflection and other extraneous things from the core library. * Added missing files and ran buildifier. * New CMakeLists.txt. * Made table its own cc_library() for internal usage.pull/13171/head
Joshua Haberman
6 years ago
committed by
GitHub
parent
00f96cb947
commit
928ef7f2c0
19 changed files with 900 additions and 930 deletions
@ -0,0 +1,401 @@ |
|||||||
|
|
||||||
|
#include "upb/legacy_msg_reflection.h" |
||||||
|
|
||||||
|
#include <string.h> |
||||||
|
#include "upb/table.int.h" |
||||||
|
#include "upb/msg.h" |
||||||
|
|
||||||
|
bool upb_fieldtype_mapkeyok(upb_fieldtype_t type) { |
||||||
|
return type == UPB_TYPE_BOOL || type == UPB_TYPE_INT32 || |
||||||
|
type == UPB_TYPE_UINT32 || type == UPB_TYPE_INT64 || |
||||||
|
type == UPB_TYPE_UINT64 || type == UPB_TYPE_STRING; |
||||||
|
} |
||||||
|
|
||||||
|
#define PTR_AT(msg, ofs, type) (type*)((char*)msg + ofs) |
||||||
|
#define VOIDPTR_AT(msg, ofs) PTR_AT(msg, ofs, void) |
||||||
|
#define ENCODE_MAX_NESTING 64 |
||||||
|
#define CHECK_TRUE(x) if (!(x)) { return false; } |
||||||
|
|
||||||
|
/** upb_msgval ****************************************************************/ |
||||||
|
|
||||||
|
/* These functions will generate real memcpy() calls on ARM sadly, because
|
||||||
|
* the compiler assumes they might not be aligned. */ |
||||||
|
|
||||||
|
static upb_msgval upb_msgval_read(const void *p, size_t ofs, |
||||||
|
uint8_t size) { |
||||||
|
upb_msgval val; |
||||||
|
p = (char*)p + ofs; |
||||||
|
memcpy(&val, p, size); |
||||||
|
return val; |
||||||
|
} |
||||||
|
|
||||||
|
static void upb_msgval_write(void *p, size_t ofs, upb_msgval val, |
||||||
|
uint8_t size) { |
||||||
|
p = (char*)p + ofs; |
||||||
|
memcpy(p, &val, size); |
||||||
|
} |
||||||
|
|
||||||
|
static size_t upb_msgval_sizeof(upb_fieldtype_t type) { |
||||||
|
switch (type) { |
||||||
|
case UPB_TYPE_DOUBLE: |
||||||
|
case UPB_TYPE_INT64: |
||||||
|
case UPB_TYPE_UINT64: |
||||||
|
return 8; |
||||||
|
case UPB_TYPE_ENUM: |
||||||
|
case UPB_TYPE_INT32: |
||||||
|
case UPB_TYPE_UINT32: |
||||||
|
case UPB_TYPE_FLOAT: |
||||||
|
return 4; |
||||||
|
case UPB_TYPE_BOOL: |
||||||
|
return 1; |
||||||
|
case UPB_TYPE_MESSAGE: |
||||||
|
return sizeof(void*); |
||||||
|
case UPB_TYPE_BYTES: |
||||||
|
case UPB_TYPE_STRING: |
||||||
|
return sizeof(upb_strview); |
||||||
|
} |
||||||
|
UPB_UNREACHABLE(); |
||||||
|
} |
||||||
|
|
||||||
|
static uint8_t upb_msg_fieldsize(const upb_msglayout_field *field) { |
||||||
|
if (field->label == UPB_LABEL_REPEATED) { |
||||||
|
return sizeof(void*); |
||||||
|
} else { |
||||||
|
return upb_msgval_sizeof(upb_desctype_to_fieldtype[field->descriptortype]); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* TODO(haberman): this is broken right now because upb_msgval can contain
|
||||||
|
* a char* / size_t pair, which is too big for a upb_value. To fix this |
||||||
|
* we'll probably need to dynamically allocate a upb_msgval and store a |
||||||
|
* pointer to that in the tables for extensions/maps. */ |
||||||
|
static upb_value upb_toval(upb_msgval val) { |
||||||
|
upb_value ret; |
||||||
|
UPB_UNUSED(val); |
||||||
|
memset(&ret, 0, sizeof(upb_value)); /* XXX */ |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
static upb_msgval upb_msgval_fromval(upb_value val) { |
||||||
|
upb_msgval ret; |
||||||
|
UPB_UNUSED(val); |
||||||
|
memset(&ret, 0, sizeof(upb_msgval)); /* XXX */ |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
static upb_ctype_t upb_fieldtotabtype(upb_fieldtype_t type) { |
||||||
|
switch (type) { |
||||||
|
case UPB_TYPE_FLOAT: return UPB_CTYPE_FLOAT; |
||||||
|
case UPB_TYPE_DOUBLE: return UPB_CTYPE_DOUBLE; |
||||||
|
case UPB_TYPE_BOOL: return UPB_CTYPE_BOOL; |
||||||
|
case UPB_TYPE_BYTES: |
||||||
|
case UPB_TYPE_MESSAGE: |
||||||
|
case UPB_TYPE_STRING: return UPB_CTYPE_CONSTPTR; |
||||||
|
case UPB_TYPE_ENUM: |
||||||
|
case UPB_TYPE_INT32: return UPB_CTYPE_INT32; |
||||||
|
case UPB_TYPE_UINT32: return UPB_CTYPE_UINT32; |
||||||
|
case UPB_TYPE_INT64: return UPB_CTYPE_INT64; |
||||||
|
case UPB_TYPE_UINT64: return UPB_CTYPE_UINT64; |
||||||
|
default: UPB_ASSERT(false); return 0; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** upb_msg *******************************************************************/ |
||||||
|
|
||||||
|
/* If we always read/write as a consistent type to each address, this shouldn't
|
||||||
|
* violate aliasing. |
||||||
|
*/ |
||||||
|
#define DEREF(msg, ofs, type) *PTR_AT(msg, ofs, type) |
||||||
|
|
||||||
|
static const upb_msglayout_field *upb_msg_checkfield(int field_index, |
||||||
|
const upb_msglayout *l) { |
||||||
|
UPB_ASSERT(field_index >= 0 && field_index < l->field_count); |
||||||
|
return &l->fields[field_index]; |
||||||
|
} |
||||||
|
|
||||||
|
static bool upb_msg_inoneof(const upb_msglayout_field *field) { |
||||||
|
return field->presence < 0; |
||||||
|
} |
||||||
|
|
||||||
|
static uint32_t *upb_msg_oneofcase(const upb_msg *msg, int field_index, |
||||||
|
const upb_msglayout *l) { |
||||||
|
const upb_msglayout_field *field = upb_msg_checkfield(field_index, l); |
||||||
|
UPB_ASSERT(upb_msg_inoneof(field)); |
||||||
|
return PTR_AT(msg, ~field->presence, uint32_t); |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_msg_has(const upb_msg *msg, |
||||||
|
int field_index, |
||||||
|
const upb_msglayout *l) { |
||||||
|
const upb_msglayout_field *field = upb_msg_checkfield(field_index, l); |
||||||
|
|
||||||
|
UPB_ASSERT(field->presence); |
||||||
|
|
||||||
|
if (upb_msg_inoneof(field)) { |
||||||
|
/* Oneofs are set when the oneof number is set to this field. */ |
||||||
|
return *upb_msg_oneofcase(msg, field_index, l) == field->number; |
||||||
|
} else { |
||||||
|
/* Other fields are set when their hasbit is set. */ |
||||||
|
uint32_t hasbit = field->presence; |
||||||
|
return DEREF(msg, hasbit / 8, char) | (1 << (hasbit % 8)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
upb_msgval upb_msg_get(const upb_msg *msg, int field_index, |
||||||
|
const upb_msglayout *l) { |
||||||
|
const upb_msglayout_field *field = upb_msg_checkfield(field_index, l); |
||||||
|
int size = upb_msg_fieldsize(field); |
||||||
|
return upb_msgval_read(msg, field->offset, size); |
||||||
|
} |
||||||
|
|
||||||
|
void upb_msg_set(upb_msg *msg, int field_index, upb_msgval val, |
||||||
|
const upb_msglayout *l) { |
||||||
|
const upb_msglayout_field *field = upb_msg_checkfield(field_index, l); |
||||||
|
int size = upb_msg_fieldsize(field); |
||||||
|
upb_msgval_write(msg, field->offset, val, size); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** upb_array *****************************************************************/ |
||||||
|
|
||||||
|
#define DEREF_ARR(arr, i, type) ((type*)arr->data)[i] |
||||||
|
|
||||||
|
size_t upb_array_size(const upb_array *arr) { |
||||||
|
return arr->len; |
||||||
|
} |
||||||
|
|
||||||
|
upb_fieldtype_t upb_array_type(const upb_array *arr) { |
||||||
|
return arr->type; |
||||||
|
} |
||||||
|
|
||||||
|
upb_msgval upb_array_get(const upb_array *arr, size_t i) { |
||||||
|
size_t element_size = upb_msgval_sizeof(arr->type); |
||||||
|
UPB_ASSERT(i < arr->len); |
||||||
|
return upb_msgval_read(arr->data, i * element_size, element_size); |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_array_set(upb_array *arr, size_t i, upb_msgval val) { |
||||||
|
size_t element_size = upb_msgval_sizeof(arr->type); |
||||||
|
UPB_ASSERT(i <= arr->len); |
||||||
|
|
||||||
|
if (i == arr->len) { |
||||||
|
/* Extending the array. */ |
||||||
|
|
||||||
|
if (i == arr->size) { |
||||||
|
/* Need to reallocate. */ |
||||||
|
size_t new_size = UPB_MAX(arr->size * 2, 8); |
||||||
|
size_t new_bytes = new_size * element_size; |
||||||
|
size_t old_bytes = arr->size * element_size; |
||||||
|
upb_alloc *alloc = upb_arena_alloc(arr->arena); |
||||||
|
upb_msgval *new_data = |
||||||
|
upb_realloc(alloc, arr->data, old_bytes, new_bytes); |
||||||
|
|
||||||
|
if (!new_data) { |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
arr->data = new_data; |
||||||
|
arr->size = new_size; |
||||||
|
} |
||||||
|
|
||||||
|
arr->len = i + 1; |
||||||
|
} |
||||||
|
|
||||||
|
upb_msgval_write(arr->data, i * element_size, val, element_size); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** upb_map *******************************************************************/ |
||||||
|
|
||||||
|
struct upb_map { |
||||||
|
upb_fieldtype_t key_type; |
||||||
|
upb_fieldtype_t val_type; |
||||||
|
/* We may want to optimize this to use inttable where possible, for greater
|
||||||
|
* efficiency and lower memory footprint. */ |
||||||
|
upb_strtable strtab; |
||||||
|
upb_arena *arena; |
||||||
|
}; |
||||||
|
|
||||||
|
static void upb_map_tokey(upb_fieldtype_t type, upb_msgval *key, |
||||||
|
const char **out_key, size_t *out_len) { |
||||||
|
switch (type) { |
||||||
|
case UPB_TYPE_STRING: |
||||||
|
/* Point to string data of the input key. */ |
||||||
|
*out_key = key->str.data; |
||||||
|
*out_len = key->str.size; |
||||||
|
return; |
||||||
|
case UPB_TYPE_BOOL: |
||||||
|
case UPB_TYPE_INT32: |
||||||
|
case UPB_TYPE_UINT32: |
||||||
|
case UPB_TYPE_INT64: |
||||||
|
case UPB_TYPE_UINT64: |
||||||
|
/* Point to the key itself. XXX: big-endian. */ |
||||||
|
*out_key = (const char*)key; |
||||||
|
*out_len = upb_msgval_sizeof(type); |
||||||
|
return; |
||||||
|
case UPB_TYPE_BYTES: |
||||||
|
case UPB_TYPE_DOUBLE: |
||||||
|
case UPB_TYPE_ENUM: |
||||||
|
case UPB_TYPE_FLOAT: |
||||||
|
case UPB_TYPE_MESSAGE: |
||||||
|
break; /* Cannot be a map key. */ |
||||||
|
} |
||||||
|
UPB_UNREACHABLE(); |
||||||
|
} |
||||||
|
|
||||||
|
static upb_msgval upb_map_fromkey(upb_fieldtype_t type, const char *key, |
||||||
|
size_t len) { |
||||||
|
switch (type) { |
||||||
|
case UPB_TYPE_STRING: |
||||||
|
return upb_msgval_makestr(key, len); |
||||||
|
case UPB_TYPE_BOOL: |
||||||
|
case UPB_TYPE_INT32: |
||||||
|
case UPB_TYPE_UINT32: |
||||||
|
case UPB_TYPE_INT64: |
||||||
|
case UPB_TYPE_UINT64: |
||||||
|
return upb_msgval_read(key, 0, upb_msgval_sizeof(type)); |
||||||
|
case UPB_TYPE_BYTES: |
||||||
|
case UPB_TYPE_DOUBLE: |
||||||
|
case UPB_TYPE_ENUM: |
||||||
|
case UPB_TYPE_FLOAT: |
||||||
|
case UPB_TYPE_MESSAGE: |
||||||
|
break; /* Cannot be a map key. */ |
||||||
|
} |
||||||
|
UPB_UNREACHABLE(); |
||||||
|
} |
||||||
|
|
||||||
|
upb_map *upb_map_new(upb_fieldtype_t ktype, upb_fieldtype_t vtype, |
||||||
|
upb_arena *a) { |
||||||
|
upb_ctype_t vtabtype = upb_fieldtotabtype(vtype); |
||||||
|
upb_alloc *alloc = upb_arena_alloc(a); |
||||||
|
upb_map *map = upb_malloc(alloc, sizeof(upb_map)); |
||||||
|
|
||||||
|
if (!map) { |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_ASSERT(upb_fieldtype_mapkeyok(ktype)); |
||||||
|
map->key_type = ktype; |
||||||
|
map->val_type = vtype; |
||||||
|
map->arena = a; |
||||||
|
|
||||||
|
if (!upb_strtable_init2(&map->strtab, vtabtype, alloc)) { |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
|
||||||
|
return map; |
||||||
|
} |
||||||
|
|
||||||
|
size_t upb_map_size(const upb_map *map) { |
||||||
|
return upb_strtable_count(&map->strtab); |
||||||
|
} |
||||||
|
|
||||||
|
upb_fieldtype_t upb_map_keytype(const upb_map *map) { |
||||||
|
return map->key_type; |
||||||
|
} |
||||||
|
|
||||||
|
upb_fieldtype_t upb_map_valuetype(const upb_map *map) { |
||||||
|
return map->val_type; |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_map_get(const upb_map *map, upb_msgval key, upb_msgval *val) { |
||||||
|
upb_value tabval; |
||||||
|
const char *key_str; |
||||||
|
size_t key_len; |
||||||
|
bool ret; |
||||||
|
|
||||||
|
upb_map_tokey(map->key_type, &key, &key_str, &key_len); |
||||||
|
ret = upb_strtable_lookup2(&map->strtab, key_str, key_len, &tabval); |
||||||
|
if (ret) { |
||||||
|
memcpy(val, &tabval, sizeof(tabval)); |
||||||
|
} |
||||||
|
|
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_map_set(upb_map *map, upb_msgval key, upb_msgval val, |
||||||
|
upb_msgval *removed) { |
||||||
|
const char *key_str; |
||||||
|
size_t key_len; |
||||||
|
upb_value tabval = upb_toval(val); |
||||||
|
upb_value removedtabval; |
||||||
|
upb_alloc *a = upb_arena_alloc(map->arena); |
||||||
|
|
||||||
|
upb_map_tokey(map->key_type, &key, &key_str, &key_len); |
||||||
|
|
||||||
|
/* TODO(haberman): add overwrite operation to minimize number of lookups. */ |
||||||
|
if (upb_strtable_lookup2(&map->strtab, key_str, key_len, NULL)) { |
||||||
|
upb_strtable_remove3(&map->strtab, key_str, key_len, &removedtabval, a); |
||||||
|
memcpy(&removed, &removedtabval, sizeof(removed)); |
||||||
|
} |
||||||
|
|
||||||
|
return upb_strtable_insert3(&map->strtab, key_str, key_len, tabval, a); |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_map_del(upb_map *map, upb_msgval key) { |
||||||
|
const char *key_str; |
||||||
|
size_t key_len; |
||||||
|
upb_alloc *a = upb_arena_alloc(map->arena); |
||||||
|
|
||||||
|
upb_map_tokey(map->key_type, &key, &key_str, &key_len); |
||||||
|
return upb_strtable_remove3(&map->strtab, key_str, key_len, NULL, a); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** upb_mapiter ***************************************************************/ |
||||||
|
|
||||||
|
struct upb_mapiter { |
||||||
|
upb_strtable_iter iter; |
||||||
|
upb_fieldtype_t key_type; |
||||||
|
}; |
||||||
|
|
||||||
|
size_t upb_mapiter_sizeof() { |
||||||
|
return sizeof(upb_mapiter); |
||||||
|
} |
||||||
|
|
||||||
|
void upb_mapiter_begin(upb_mapiter *i, const upb_map *map) { |
||||||
|
upb_strtable_begin(&i->iter, &map->strtab); |
||||||
|
i->key_type = map->key_type; |
||||||
|
} |
||||||
|
|
||||||
|
upb_mapiter *upb_mapiter_new(const upb_map *t, upb_alloc *a) { |
||||||
|
upb_mapiter *ret = upb_malloc(a, upb_mapiter_sizeof()); |
||||||
|
|
||||||
|
if (!ret) { |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
|
||||||
|
upb_mapiter_begin(ret, t); |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
void upb_mapiter_free(upb_mapiter *i, upb_alloc *a) { |
||||||
|
upb_free(a, i); |
||||||
|
} |
||||||
|
|
||||||
|
void upb_mapiter_next(upb_mapiter *i) { |
||||||
|
upb_strtable_next(&i->iter); |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_mapiter_done(const upb_mapiter *i) { |
||||||
|
return upb_strtable_done(&i->iter); |
||||||
|
} |
||||||
|
|
||||||
|
upb_msgval upb_mapiter_key(const upb_mapiter *i) { |
||||||
|
return upb_map_fromkey(i->key_type, upb_strtable_iter_key(&i->iter), |
||||||
|
upb_strtable_iter_keylength(&i->iter)); |
||||||
|
} |
||||||
|
|
||||||
|
upb_msgval upb_mapiter_value(const upb_mapiter *i) { |
||||||
|
return upb_msgval_fromval(upb_strtable_iter_value(&i->iter)); |
||||||
|
} |
||||||
|
|
||||||
|
void upb_mapiter_setdone(upb_mapiter *i) { |
||||||
|
upb_strtable_iter_setdone(&i->iter); |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_mapiter_isequal(const upb_mapiter *i1, const upb_mapiter *i2) { |
||||||
|
return upb_strtable_iter_isequal(&i1->iter, &i2->iter); |
||||||
|
} |
||||||
@ -0,0 +1,186 @@ |
|||||||
|
|
||||||
|
#ifndef UPB_LEGACY_MSG_REFLECTION_H_ |
||||||
|
#define UPB_LEGACY_MSG_REFLECTION_H_ |
||||||
|
|
||||||
|
#include "upb/upb.h" |
||||||
|
#include "upb/msg.h" |
||||||
|
|
||||||
|
struct upb_map; |
||||||
|
typedef struct upb_map upb_map; |
||||||
|
|
||||||
|
struct upb_mapiter; |
||||||
|
typedef struct upb_mapiter upb_mapiter; |
||||||
|
|
||||||
|
/** upb_msgval ****************************************************************/ |
||||||
|
|
||||||
|
/* A union representing all possible protobuf values. Used for generic get/set
|
||||||
|
* operations. */ |
||||||
|
|
||||||
|
typedef union { |
||||||
|
bool b; |
||||||
|
float flt; |
||||||
|
double dbl; |
||||||
|
int32_t i32; |
||||||
|
int64_t i64; |
||||||
|
uint32_t u32; |
||||||
|
uint64_t u64; |
||||||
|
const upb_map* map; |
||||||
|
const upb_msg* msg; |
||||||
|
const upb_array* arr; |
||||||
|
const void* ptr; |
||||||
|
upb_strview str; |
||||||
|
} upb_msgval; |
||||||
|
|
||||||
|
#define ACCESSORS(name, membername, ctype) \ |
||||||
|
UPB_INLINE ctype upb_msgval_get ## name(upb_msgval v) { \
|
||||||
|
return v.membername; \
|
||||||
|
} \
|
||||||
|
UPB_INLINE void upb_msgval_set ## name(upb_msgval *v, ctype cval) { \
|
||||||
|
v->membername = cval; \
|
||||||
|
} \
|
||||||
|
UPB_INLINE upb_msgval upb_msgval_ ## name(ctype v) { \
|
||||||
|
upb_msgval ret; \
|
||||||
|
ret.membername = v; \
|
||||||
|
return ret; \
|
||||||
|
} |
||||||
|
|
||||||
|
ACCESSORS(bool, b, bool) |
||||||
|
ACCESSORS(float, flt, float) |
||||||
|
ACCESSORS(double, dbl, double) |
||||||
|
ACCESSORS(int32, i32, int32_t) |
||||||
|
ACCESSORS(int64, i64, int64_t) |
||||||
|
ACCESSORS(uint32, u32, uint32_t) |
||||||
|
ACCESSORS(uint64, u64, uint64_t) |
||||||
|
ACCESSORS(map, map, const upb_map*) |
||||||
|
ACCESSORS(msg, msg, const upb_msg*) |
||||||
|
ACCESSORS(ptr, ptr, const void*) |
||||||
|
ACCESSORS(arr, arr, const upb_array*) |
||||||
|
ACCESSORS(str, str, upb_strview) |
||||||
|
|
||||||
|
#undef ACCESSORS |
||||||
|
|
||||||
|
UPB_INLINE upb_msgval upb_msgval_makestr(const char *data, size_t size) { |
||||||
|
return upb_msgval_str(upb_strview_make(data, size)); |
||||||
|
} |
||||||
|
|
||||||
|
/** upb_msg *******************************************************************/ |
||||||
|
|
||||||
|
/* A upb_msg represents a protobuf message. It always corresponds to a specific
|
||||||
|
* upb_msglayout, which describes how it is laid out in memory. */ |
||||||
|
|
||||||
|
/* Read-only message API. Can be safely called by anyone. */ |
||||||
|
|
||||||
|
/* Returns the value associated with this field:
|
||||||
|
* - for scalar fields (including strings), the value directly. |
||||||
|
* - return upb_msg*, or upb_map* for msg/map. |
||||||
|
* If the field is unset for these field types, returns NULL. |
||||||
|
* |
||||||
|
* TODO(haberman): should we let users store cached array/map/msg |
||||||
|
* pointers here for fields that are unset? Could be useful for the |
||||||
|
* strongly-owned submessage model (ie. generated C API that doesn't use |
||||||
|
* arenas). |
||||||
|
*/ |
||||||
|
upb_msgval upb_msg_get(const upb_msg *msg, |
||||||
|
int field_index, |
||||||
|
const upb_msglayout *l); |
||||||
|
|
||||||
|
/* May only be called for fields where upb_fielddef_haspresence(f) == true. */ |
||||||
|
bool upb_msg_has(const upb_msg *msg, |
||||||
|
int field_index, |
||||||
|
const upb_msglayout *l); |
||||||
|
|
||||||
|
/* Mutable message API. May only be called by the owner of the message who
|
||||||
|
* knows its ownership scheme and how to keep it consistent. */ |
||||||
|
|
||||||
|
/* Sets the given field to the given value. Does not perform any memory
|
||||||
|
* management: if you overwrite a pointer to a msg/array/map/string without |
||||||
|
* cleaning it up (or using an arena) it will leak. |
||||||
|
*/ |
||||||
|
void upb_msg_set(upb_msg *msg, |
||||||
|
int field_index, |
||||||
|
upb_msgval val, |
||||||
|
const upb_msglayout *l); |
||||||
|
|
||||||
|
/* For a primitive field, set it back to its default. For repeated, string, and
|
||||||
|
* submessage fields set it back to NULL. This could involve releasing some |
||||||
|
* internal memory (for example, from an extension dictionary), but it is not |
||||||
|
* recursive in any way and will not recover any memory that may be used by |
||||||
|
* arrays/maps/strings/msgs that this field may have pointed to. |
||||||
|
*/ |
||||||
|
bool upb_msg_clearfield(upb_msg *msg, |
||||||
|
int field_index, |
||||||
|
const upb_msglayout *l); |
||||||
|
|
||||||
|
/* TODO(haberman): copyfrom()/mergefrom()? */ |
||||||
|
|
||||||
|
/** upb_array *****************************************************************/ |
||||||
|
|
||||||
|
/* A upb_array stores data for a repeated field. The memory management
|
||||||
|
* semantics are the same as upb_msg. A upb_array allocates dynamic |
||||||
|
* memory internally for the array elements. */ |
||||||
|
|
||||||
|
upb_fieldtype_t upb_array_type(const upb_array *arr); |
||||||
|
|
||||||
|
/* Read-only interface. Safe for anyone to call. */ |
||||||
|
|
||||||
|
size_t upb_array_size(const upb_array *arr); |
||||||
|
upb_msgval upb_array_get(const upb_array *arr, size_t i); |
||||||
|
|
||||||
|
/* Write interface. May only be called by the message's owner who can enforce
|
||||||
|
* its memory management invariants. */ |
||||||
|
|
||||||
|
bool upb_array_set(upb_array *arr, size_t i, upb_msgval val); |
||||||
|
|
||||||
|
/** upb_map *******************************************************************/ |
||||||
|
|
||||||
|
/* A upb_map stores data for a map field. The memory management semantics are
|
||||||
|
* the same as upb_msg, with one notable exception. upb_map will internally |
||||||
|
* store a copy of all string keys, but *not* any string values or submessages. |
||||||
|
* So you must ensure that any string or message values outlive the map, and you |
||||||
|
* must delete them manually when they are no longer required. */ |
||||||
|
|
||||||
|
upb_map *upb_map_new(upb_fieldtype_t ktype, upb_fieldtype_t vtype, |
||||||
|
upb_arena *a); |
||||||
|
|
||||||
|
/* Read-only interface. Safe for anyone to call. */ |
||||||
|
|
||||||
|
size_t upb_map_size(const upb_map *map); |
||||||
|
upb_fieldtype_t upb_map_keytype(const upb_map *map); |
||||||
|
upb_fieldtype_t upb_map_valuetype(const upb_map *map); |
||||||
|
bool upb_map_get(const upb_map *map, upb_msgval key, upb_msgval *val); |
||||||
|
|
||||||
|
/* Write interface. May only be called by the message's owner who can enforce
|
||||||
|
* its memory management invariants. */ |
||||||
|
|
||||||
|
/* Sets or overwrites an entry in the map. Return value indicates whether
|
||||||
|
* the operation succeeded or failed with OOM, and also whether an existing |
||||||
|
* key was replaced or not. */ |
||||||
|
bool upb_map_set(upb_map *map, |
||||||
|
upb_msgval key, upb_msgval val, |
||||||
|
upb_msgval *valremoved); |
||||||
|
|
||||||
|
/* Deletes an entry in the map. Returns true if the key was present. */ |
||||||
|
bool upb_map_del(upb_map *map, upb_msgval key); |
||||||
|
|
||||||
|
/** upb_mapiter ***************************************************************/ |
||||||
|
|
||||||
|
/* For iterating over a map. Map iterators are invalidated by mutations to the
|
||||||
|
* map, but an invalidated iterator will never return junk or crash the process. |
||||||
|
* An invalidated iterator may return entries that were already returned though, |
||||||
|
* and if you keep invalidating the iterator during iteration, the program may |
||||||
|
* enter an infinite loop. */ |
||||||
|
|
||||||
|
size_t upb_mapiter_sizeof(); |
||||||
|
|
||||||
|
void upb_mapiter_begin(upb_mapiter *i, const upb_map *t); |
||||||
|
upb_mapiter *upb_mapiter_new(const upb_map *t, upb_alloc *a); |
||||||
|
void upb_mapiter_free(upb_mapiter *i, upb_alloc *a); |
||||||
|
void upb_mapiter_next(upb_mapiter *i); |
||||||
|
bool upb_mapiter_done(const upb_mapiter *i); |
||||||
|
|
||||||
|
upb_msgval upb_mapiter_key(const upb_mapiter *i); |
||||||
|
upb_msgval upb_mapiter_value(const upb_mapiter *i); |
||||||
|
void upb_mapiter_setdone(upb_mapiter *i); |
||||||
|
bool upb_mapiter_isequal(const upb_mapiter *i1, const upb_mapiter *i2); |
||||||
|
|
||||||
|
#endif // UPB_LEGACY_MSG_REFLECTION_H_
|
||||||
@ -1,20 +0,0 @@ |
|||||||
/*
|
|
||||||
** structs.int.h: structures definitions that are internal to upb. |
|
||||||
*/ |
|
||||||
|
|
||||||
#ifndef UPB_STRUCTS_H_ |
|
||||||
#define UPB_STRUCTS_H_ |
|
||||||
|
|
||||||
#include "upb/upb.h" |
|
||||||
|
|
||||||
struct upb_array { |
|
||||||
upb_fieldtype_t type; |
|
||||||
uint8_t element_size; |
|
||||||
void *data; /* Each element is element_size. */ |
|
||||||
size_t len; /* Measured in elements. */ |
|
||||||
size_t size; /* Measured in elements. */ |
|
||||||
upb_arena *arena; |
|
||||||
}; |
|
||||||
|
|
||||||
#endif /* UPB_STRUCTS_H_ */ |
|
||||||
|
|
||||||
Loading…
Reference in new issue