void
PhraseCompiler_serialize(PhraseCompiler *self, OutStream *outstream)
{
Compiler_serialize((Compiler*)self, outstream);
OutStream_Write_F32(outstream, self->idf);
OutStream_Write_F32(outstream, self->raw_weight);
OutStream_Write_F32(outstream, self->query_norm_factor);
OutStream_Write_F32(outstream, self->normalized_weight);
}
void
TermCompiler_Serialize_IMP(TermCompiler *self, OutStream *outstream) {
TermCompilerIVARS *const ivars = TermCompiler_IVARS(self);
TermCompiler_Serialize_t super_serialize
= SUPER_METHOD_PTR(TERMCOMPILER, LUCY_TermCompiler_Serialize);
super_serialize(self, outstream);
OutStream_Write_F32(outstream, ivars->idf);
OutStream_Write_F32(outstream, ivars->raw_weight);
OutStream_Write_F32(outstream, ivars->query_norm_factor);
OutStream_Write_F32(outstream, ivars->normalized_weight);
}
void
PhraseCompiler_Serialize_IMP(PhraseCompiler *self, OutStream *outstream) {
PhraseCompilerIVARS *const ivars = PhraseCompiler_IVARS(self);
PhraseCompiler_Serialize_t super_serialize
= (PhraseCompiler_Serialize_t)SUPER_METHOD_PTR(PHRASECOMPILER,
LUCY_PhraseCompiler_Serialize);
super_serialize(self, outstream);
OutStream_Write_F32(outstream, ivars->idf);
OutStream_Write_F32(outstream, ivars->raw_weight);
OutStream_Write_F32(outstream, ivars->query_norm_factor);
OutStream_Write_F32(outstream, ivars->normalized_weight);
}
void
ProximityCompiler_Serialize_IMP(ProximityCompiler *self,
OutStream *outstream) {
ProximityCompiler_Serialize_t super_serialize
= SUPER_METHOD_PTR(PROXIMITYCOMPILER, LUCY_ProximityCompiler_Serialize);
super_serialize(self, outstream);
ProximityCompilerIVARS *const ivars = ProximityCompiler_IVARS(self);
OutStream_Write_F32(outstream, ivars->idf);
OutStream_Write_F32(outstream, ivars->raw_weight);
OutStream_Write_F32(outstream, ivars->query_norm_factor);
OutStream_Write_F32(outstream, ivars->normalized_weight);
OutStream_Write_C32(outstream, ivars->within);
}
void
PhraseQuery_serialize(PhraseQuery *self, OutStream *outstream)
{
OutStream_Write_F32(outstream, self->boost);
CB_Serialize(self->field, outstream);
VA_Serialize(self->terms, outstream);
}
void
PhraseQuery_Serialize_IMP(PhraseQuery *self, OutStream *outstream) {
PhraseQueryIVARS *const ivars = PhraseQuery_IVARS(self);
OutStream_Write_F32(outstream, ivars->boost);
Freezer_serialize_string(ivars->field, outstream);
Freezer_serialize_varray(ivars->terms, outstream);
}
void
TermQuery_Serialize_IMP(TermQuery *self, OutStream *outstream) {
TermQueryIVARS *const ivars = TermQuery_IVARS(self);
Freezer_serialize_string(ivars->field, outstream);
FREEZE(ivars->term, outstream);
OutStream_Write_F32(outstream, ivars->boost);
}
void
Compiler_serialize(Compiler *self, OutStream *outstream) {
ABSTRACT_CLASS_CHECK(self, COMPILER);
OutStream_Write_F32(outstream, self->boost);
FREEZE(self->parent, outstream);
FREEZE(self->sim, outstream);
}
void
HitDoc_Serialize_IMP(HitDoc *self, OutStream *outstream) {
HitDocIVARS *const ivars = HitDoc_IVARS(self);
HitDoc_Serialize_t super_serialize
= SUPER_METHOD_PTR(HITDOC, LUCY_HitDoc_Serialize);
super_serialize(self, outstream);
OutStream_Write_F32(outstream, ivars->score);
}
void
PolyQuery_Serialize_IMP(PolyQuery *self, OutStream *outstream) {
PolyQueryIVARS *const ivars = PolyQuery_IVARS(self);
const uint32_t num_kids = (uint32_t)Vec_Get_Size(ivars->children);
OutStream_Write_F32(outstream, ivars->boost);
OutStream_Write_U32(outstream, num_kids);
for (uint32_t i = 0; i < num_kids; i++) {
Query *child = (Query*)Vec_Fetch(ivars->children, i);
FREEZE(child, outstream);
}
}
void
LeafQuery_Serialize_IMP(LeafQuery *self, OutStream *outstream) {
LeafQueryIVARS *const ivars = LeafQuery_IVARS(self);
if (ivars->field) {
OutStream_Write_U8(outstream, true);
Freezer_serialize_string(ivars->field, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
Freezer_serialize_string(ivars->text, outstream);
OutStream_Write_F32(outstream, ivars->boost);
}
void
RangeQuery_serialize(RangeQuery *self, OutStream *outstream) {
OutStream_Write_F32(outstream, self->boost);
CB_Serialize(self->field, outstream);
if (self->lower_term) {
OutStream_Write_U8(outstream, true);
FREEZE(self->lower_term, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
if (self->upper_term) {
OutStream_Write_U8(outstream, true);
FREEZE(self->upper_term, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
OutStream_Write_U8(outstream, self->include_lower);
OutStream_Write_U8(outstream, self->include_upper);
}
void
RangeQuery_Serialize_IMP(RangeQuery *self, OutStream *outstream) {
RangeQueryIVARS *const ivars = RangeQuery_IVARS(self);
OutStream_Write_F32(outstream, ivars->boost);
Freezer_serialize_string(ivars->field, outstream);
if (ivars->lower_term) {
OutStream_Write_U8(outstream, true);
FREEZE(ivars->lower_term, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
if (ivars->upper_term) {
OutStream_Write_U8(outstream, true);
FREEZE(ivars->upper_term, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
OutStream_Write_U8(outstream, ivars->include_lower);
OutStream_Write_U8(outstream, ivars->include_upper);
}
void
DocWriter_Add_Inverted_Doc_IMP(DocWriter *self, Inverter *inverter,
int32_t doc_id) {
DocWriterIVARS *const ivars = DocWriter_IVARS(self);
OutStream *dat_out = S_lazy_init(self);
OutStream *ix_out = ivars->ix_out;
uint32_t num_stored = 0;
int64_t start = OutStream_Tell(dat_out);
int64_t expected = OutStream_Tell(ix_out) / 8;
// Verify doc id.
if (doc_id != expected) {
THROW(ERR, "Expected doc id %i64 but got %i32", expected, doc_id);
}
// Write the number of stored fields.
Inverter_Iterate(inverter);
while (Inverter_Next(inverter)) {
FieldType *type = Inverter_Get_Type(inverter);
if (FType_Stored(type)) { num_stored++; }
}
OutStream_Write_C32(dat_out, num_stored);
Inverter_Iterate(inverter);
while (Inverter_Next(inverter)) {
// Only store fields marked as "stored".
FieldType *type = Inverter_Get_Type(inverter);
if (FType_Stored(type)) {
String *field = Inverter_Get_Field_Name(inverter);
Obj *value = Inverter_Get_Value(inverter);
Freezer_serialize_string(field, dat_out);
switch (FType_Primitive_ID(type) & FType_PRIMITIVE_ID_MASK) {
case FType_TEXT: {
const char *buf = Str_Get_Ptr8((String*)value);
size_t size = Str_Get_Size((String*)value);
OutStream_Write_C32(dat_out, size);
OutStream_Write_Bytes(dat_out, buf, size);
break;
}
case FType_BLOB: {
char *buf = BB_Get_Buf((ByteBuf*)value);
size_t size = BB_Get_Size((ByteBuf*)value);
OutStream_Write_C32(dat_out, size);
OutStream_Write_Bytes(dat_out, buf, size);
break;
}
case FType_INT32: {
int32_t val = Int32_Get_Value((Integer32*)value);
OutStream_Write_C32(dat_out, val);
break;
}
case FType_INT64: {
int64_t val = Int64_Get_Value((Integer64*)value);
OutStream_Write_C64(dat_out, val);
break;
}
case FType_FLOAT32: {
float val = Float32_Get_Value((Float32*)value);
OutStream_Write_F32(dat_out, val);
break;
}
case FType_FLOAT64: {
double val = Float64_Get_Value((Float64*)value);
OutStream_Write_F64(dat_out, val);
break;
}
default:
THROW(ERR, "Unrecognized type: %o", type);
}
}
}
// Write file pointer.
OutStream_Write_I64(ix_out, start);
}
void
Query_Serialize_IMP(Query *self, OutStream *outstream) {
OutStream_Write_F32(outstream, Query_IVARS(self)->boost);
}
static void
S_write_val(Obj *val, int8_t prim_id, OutStream *ix_out, OutStream *dat_out,
int64_t dat_start) {
if (val) {
switch (prim_id & FType_PRIMITIVE_ID_MASK) {
case FType_TEXT: {
String *string = (String*)val;
int64_t dat_pos = OutStream_Tell(dat_out) - dat_start;
OutStream_Write_I64(ix_out, dat_pos);
OutStream_Write_Bytes(dat_out, Str_Get_Ptr8(string),
Str_Get_Size(string));
break;
}
case FType_BLOB: {
Blob *blob = (Blob*)val;
int64_t dat_pos = OutStream_Tell(dat_out) - dat_start;
OutStream_Write_I64(ix_out, dat_pos);
OutStream_Write_Bytes(dat_out, Blob_Get_Buf(blob),
Blob_Get_Size(blob));
break;
}
case FType_INT32: {
int32_t i32 = (int32_t)Int_Get_Value((Integer*)val);
OutStream_Write_I32(dat_out, i32);
break;
}
case FType_INT64: {
int64_t i64 = Int_Get_Value((Integer*)val);
OutStream_Write_I64(dat_out, i64);
break;
}
case FType_FLOAT32: {
float f32 = (float)Float_Get_Value((Float*)val);
OutStream_Write_F32(dat_out, f32);
break;
}
case FType_FLOAT64: {
double f64 = Float_Get_Value((Float*)val);
OutStream_Write_F64(dat_out, f64);
break;
}
default:
THROW(ERR, "Unrecognized primitive id: %i32", (int32_t)prim_id);
}
}
else {
switch (prim_id & FType_PRIMITIVE_ID_MASK) {
case FType_TEXT:
case FType_BLOB: {
int64_t dat_pos = OutStream_Tell(dat_out) - dat_start;
OutStream_Write_I64(ix_out, dat_pos);
}
break;
case FType_INT32:
OutStream_Write_I32(dat_out, 0);
break;
case FType_INT64:
OutStream_Write_I64(dat_out, 0);
break;
case FType_FLOAT64:
OutStream_Write_F64(dat_out, 0.0);
break;
case FType_FLOAT32:
OutStream_Write_F32(dat_out, 0.0f);
break;
default:
THROW(ERR, "Unrecognized primitive id: %i32", (int32_t)prim_id);
}
}
}
