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]);
}
}
