static void _update_dynamic_handles(NVTable *self, NVRegistry *logmsg_nv_registry, NVHandle *handles_to_update, guint8 num_handles_to_update) { guint16 i; NVHandle *updated_handles = g_new0(NVHandle, num_handles_to_update); NVDynValue* dyn_entries = nv_table_get_dyn_entries(self); for (i = 0; i < self->num_dyn_entries; i++) { NVHandle new_handle; NVDynValue *dyn_entry = &dyn_entries[i]; const gchar *name = _get_entry_name(self, dyn_entry); if (!name) continue; new_handle = nv_registry_alloc_handle(logmsg_nv_registry, name); _set_updated_handle(dyn_entry, new_handle, handles_to_update, updated_handles, num_handles_to_update); } _copy_handles(handles_to_update, updated_handles, num_handles_to_update); qsort(dyn_entries, self->num_dyn_entries, sizeof(NVDynValue), _dyn_entry_cmp); g_free(updated_handles); }
static gboolean nv_table_reserve_table_entry(NVTable *self, NVHandle handle, NVDynValue **dyn_slot) { if (G_UNLIKELY(!(*dyn_slot) && handle > self->num_static_entries)) { /* this is a dynamic value */ NVDynValue *dyn_entries = nv_table_get_dyn_entries(self);; gint l, h, m, ndx; gboolean found = FALSE; if (!nv_table_alloc_check(self, sizeof(dyn_entries[0]))) return FALSE; l = 0; h = self->num_dyn_entries - 1; ndx = -1; while (l <= h) { guint16 mv; m = (l+h) >> 1; mv = NV_TABLE_DYNVALUE_HANDLE(dyn_entries[m]); if (mv == handle) { ndx = m; found = TRUE; break; } else if (mv > handle) { h = m - 1; } else { l = m + 1; } } /* if we find the proper slot we set that, if we don't, we insert a new entry */ if (!found) ndx = l; g_assert(ndx >= 0 && ndx <= self->num_dyn_entries); if (ndx < self->num_dyn_entries) { memmove(&dyn_entries[ndx + 1], &dyn_entries[ndx], (self->num_dyn_entries - ndx) * sizeof(dyn_entries[0])); } *dyn_slot = &dyn_entries[ndx]; /* we set ofs to zero here, which means that the NVEntry won't be found even if the slot is present in dyn_entries */ (**dyn_slot).handle = handle; (**dyn_slot).ofs = 0; if (!found) self->num_dyn_entries++; }
static gboolean _deserialize_dynamic_entries(SerializeArchive *sa, NVTable *res) { guint32 i; NVDynValue *dyn_entries; dyn_entries = nv_table_get_dyn_entries(res); for (i = 0; i < res->num_dyn_entries; i++) { if (!_deserialize_dyn_value(sa, &dyn_entries[i])) return FALSE; } return TRUE; }
static void _update_all_indirect_entries(NVTable *self, NVRegistry *logmsg_nv_registry) { int i; NVDynValue *dyn_entries = nv_table_get_dyn_entries(self); for (i = 0; i < self->num_dyn_entries; i++) { NVEntry *entry = nv_table_get_entry_at_ofs(self, NV_TABLE_DYNVALUE_OFS(dyn_entries[i])); if (_is_indirect(entry)) _update_indirect_entry(self, logmsg_nv_registry, entry); } }
NVEntry * nv_table_get_entry_slow(NVTable *self, NVHandle handle, NVDynValue **dyn_slot) { guint32 ofs; gint l, h, m; NVDynValue *dyn_entries = nv_table_get_dyn_entries(self); guint32 mv; if (!self->num_dyn_entries) { *dyn_slot = NULL; return NULL; } /* open-coded binary search */ *dyn_slot = NULL; l = 0; h = self->num_dyn_entries - 1; ofs = 0; while (l <= h) { m = (l+h) >> 1; mv = NV_TABLE_DYNVALUE_HANDLE(dyn_entries[m]); if (mv == handle) { *dyn_slot = &dyn_entries[m]; ofs = NV_TABLE_DYNVALUE_OFS(dyn_entries[m]); break; } else if (mv > handle) { h = m - 1; } else { l = m + 1; } } NVEntry *entry = nv_table_get_entry_at_ofs(self, ofs); return entry; }
static void _write_struct(SerializeArchive *sa, NVTable *self) { guint16 i; NVDynValue *dyn_entries; serialize_write_uint32(sa, self->size); serialize_write_uint32(sa, self->used); serialize_write_uint16(sa, self->num_dyn_entries); serialize_write_uint8(sa, self->num_static_entries); for (i = 0; i < self->num_static_entries; i++) { serialize_write_uint32(sa, self->static_entries[i]); } dyn_entries = nv_table_get_dyn_entries(self); for (i = 0; i < self->num_dyn_entries; i++) { _serialize_nv_dyn_value(sa, &dyn_entries[i]); } }