Obj*
TextSortCache_Value_IMP(TextSortCache *self, int32_t ord) {
TextSortCacheIVARS *const ivars = TextSortCache_IVARS(self);
if (ord == ivars->null_ord) {
return NULL;
}
InStream_Seek(ivars->ix_in, ord * sizeof(int64_t));
int64_t offset = InStream_Read_I64(ivars->ix_in);
if (offset == NULL_SENTINEL) {
return NULL;
}
else {
uint32_t next_ord = ord + 1;
int64_t next_offset;
while (1) {
InStream_Seek(ivars->ix_in, next_ord * sizeof(int64_t));
next_offset = InStream_Read_I64(ivars->ix_in);
if (next_offset != NULL_SENTINEL) { break; }
next_ord++;
}
// Read character data into String.
size_t len = (size_t)(next_offset - offset);
char *ptr = (char*)MALLOCATE(len + 1);
InStream_Seek(ivars->dat_in, offset);
InStream_Read_Bytes(ivars->dat_in, ptr, len);
ptr[len] = '\0';
return (Obj*)Str_new_steal_utf8(ptr, len);
}
}
Hash*
Freezer_deserialize_hash(Hash *hash, InStream *instream) {
uint32_t size = InStream_Read_C32(instream);
Hash_init(hash, size);
while (size--) {
uint32_t len = InStream_Read_C32(instream);
char *key_buf = (char*)MALLOCATE(len + 1);
InStream_Read_Bytes(instream, key_buf, len);
key_buf[len] = '\0';
String *key = Str_new_steal_utf8(key_buf, len);
Hash_Store(hash, key, THAW(instream));
DECREF(key);
}
return hash;
}
static void
test_new(TestBatchRunner *runner) {
static char chars[] = "A string " SMILEY " with a smile.";
{
char *buffer = (char*)MALLOCATE(sizeof(chars));
strcpy(buffer, chars);
String *thief = Str_new_steal_utf8(buffer, sizeof(chars) - 1);
TEST_TRUE(runner, Str_Equals_Utf8(thief, chars, sizeof(chars) - 1),
"Str_new_steal_utf8");
DECREF(thief);
}
{
char *buffer = (char*)MALLOCATE(sizeof(chars));
strcpy(buffer, chars);
String *thief
= Str_new_steal_trusted_utf8(buffer, sizeof(chars) - 1);
TEST_TRUE(runner, Str_Equals_Utf8(thief, chars, sizeof(chars) - 1),
"Str_new_steal_trusted_utf8");
DECREF(thief);
}
{
String *wrapper = Str_new_wrap_utf8(chars, sizeof(chars) - 1);
TEST_TRUE(runner, Str_Equals_Utf8(wrapper, chars, sizeof(chars) - 1),
"Str_new_wrap_utf8");
DECREF(wrapper);
}
{
String *wrapper = Str_new_wrap_trusted_utf8(chars, sizeof(chars) - 1);
TEST_TRUE(runner, Str_Equals_Utf8(wrapper, chars, sizeof(chars) - 1),
"Str_new_wrap_trusted_utf8");
DECREF(wrapper);
}
{
String *smiley_str = Str_new_from_char(smiley_cp);
TEST_TRUE(runner, Str_Equals_Utf8(smiley_str, smiley, smiley_len),
"Str_new_from_char");
DECREF(smiley_str);
}
}
HitDoc*
DefDocReader_Fetch_Doc_IMP(DefaultDocReader *self, int32_t doc_id) {
DefaultDocReaderIVARS *const ivars = DefDocReader_IVARS(self);
Schema *const schema = ivars->schema;
InStream *const dat_in = ivars->dat_in;
InStream *const ix_in = ivars->ix_in;
Hash *const fields = Hash_new(1);
int64_t start;
uint32_t num_fields;
uint32_t field_name_cap = 31;
char *field_name = (char*)MALLOCATE(field_name_cap + 1);
// Get data file pointer from index, read number of fields.
InStream_Seek(ix_in, (int64_t)doc_id * 8);
start = InStream_Read_U64(ix_in);
InStream_Seek(dat_in, start);
num_fields = InStream_Read_C32(dat_in);
// Decode stored data and build up the doc field by field.
while (num_fields--) {
uint32_t field_name_len;
Obj *value;
FieldType *type;
// Read field name.
field_name_len = InStream_Read_C32(dat_in);
if (field_name_len > field_name_cap) {
field_name_cap = field_name_len;
field_name = (char*)REALLOCATE(field_name,
field_name_cap + 1);
}
InStream_Read_Bytes(dat_in, field_name, field_name_len);
// Find the Field's FieldType.
StackString *field_name_str
= SSTR_WRAP_UTF8(field_name, field_name_len);
type = Schema_Fetch_Type(schema, (String*)field_name_str);
// Read the field value.
switch (FType_Primitive_ID(type) & FType_PRIMITIVE_ID_MASK) {
case FType_TEXT: {
uint32_t value_len = InStream_Read_C32(dat_in);
char *buf = (char*)MALLOCATE(value_len + 1);
InStream_Read_Bytes(dat_in, buf, value_len);
buf[value_len] = '\0';
value = (Obj*)Str_new_steal_utf8(buf, value_len);
break;
}
case FType_BLOB: {
uint32_t value_len = InStream_Read_C32(dat_in);
char *buf = (char*)MALLOCATE(value_len);
InStream_Read_Bytes(dat_in, buf, value_len);
value = (Obj*)BB_new_steal_bytes(
buf, value_len, value_len);
break;
}
case FType_FLOAT32:
value = (Obj*)Float32_new(
InStream_Read_F32(dat_in));
break;
case FType_FLOAT64:
value = (Obj*)Float64_new(
InStream_Read_F64(dat_in));
break;
case FType_INT32:
value = (Obj*)Int32_new(
(int32_t)InStream_Read_C32(dat_in));
break;
case FType_INT64:
value = (Obj*)Int64_new(
(int64_t)InStream_Read_C64(dat_in));
break;
default:
value = NULL;
THROW(ERR, "Unrecognized type: %o", type);
}
// Store the value.
Hash_Store_Utf8(fields, field_name, field_name_len, value);
}
FREEMEM(field_name);
HitDoc *retval = HitDoc_new(fields, doc_id, 0.0);
DECREF(fields);
return retval;
}