static Folder*
S_init_folder(Obj *index, bool create) {
Folder *folder = NULL;
// Validate or acquire a Folder.
if (Obj_is_a(index, FOLDER)) {
folder = (Folder*)INCREF(index);
}
else if (Obj_is_a(index, STRING)) {
folder = (Folder*)FSFolder_new((String*)index);
}
else {
THROW(ERR, "Invalid type for 'index': %o", Obj_get_class_name(index));
}
// Validate or create the index directory.
if (create) {
Folder_Initialize(folder);
}
else {
if (!Folder_Check(folder)) {
THROW(ERR, "Folder '%o' failed check", Folder_Get_Path(folder));
}
}
return folder;
}
void
Indexer_Add_Index_IMP(Indexer *self, Obj *index) {
IndexerIVARS *const ivars = Indexer_IVARS(self);
Folder *other_folder = NULL;
IndexReader *reader = NULL;
if (Obj_is_a(index, FOLDER)) {
other_folder = (Folder*)INCREF(index);
}
else if (Obj_is_a(index, STRING)) {
other_folder = (Folder*)FSFolder_new((String*)index);
}
else {
THROW(ERR, "Invalid type for 'index': %o", Obj_get_class_name(index));
}
reader = IxReader_open((Obj*)other_folder, NULL, NULL);
if (reader == NULL) {
THROW(ERR, "Index doesn't seem to contain any data");
}
else {
Schema *schema = ivars->schema;
Schema *other_schema = IxReader_Get_Schema(reader);
Vector *other_fields = Schema_All_Fields(other_schema);
Vector *seg_readers = IxReader_Seg_Readers(reader);
// Validate schema compatibility and add fields.
Schema_Eat(schema, other_schema);
// Add fields to Segment.
for (size_t i = 0, max = Vec_Get_Size(other_fields); i < max; i++) {
String *other_field = (String*)Vec_Fetch(other_fields, i);
Seg_Add_Field(ivars->segment, other_field);
}
DECREF(other_fields);
// Add all segments.
for (size_t i = 0, max = Vec_Get_Size(seg_readers); i < max; i++) {
SegReader *seg_reader = (SegReader*)Vec_Fetch(seg_readers, i);
DeletionsReader *del_reader
= (DeletionsReader*)SegReader_Fetch(
seg_reader, Class_Get_Name(DELETIONSREADER));
Matcher *deletions = del_reader
? DelReader_Iterator(del_reader)
: NULL;
I32Array *doc_map = DelWriter_Generate_Doc_Map(
ivars->del_writer, deletions,
SegReader_Doc_Max(seg_reader),
(int32_t)Seg_Get_Count(ivars->segment));
SegWriter_Add_Segment(ivars->seg_writer, seg_reader, doc_map);
DECREF(deletions);
DECREF(doc_map);
}
DECREF(seg_readers);
}
DECREF(reader);
DECREF(other_folder);
}
Obj*
Freezer_load(Obj *obj) {
if (Obj_is_a(obj, HASH)) {
return S_load_from_hash((Hash*)obj);
}
else if (Obj_is_a(obj, VECTOR)) {
return S_load_from_array((Vector*)obj);
}
else {
return Obj_Clone(obj);
}
}
bool
Float_Equals_IMP(Float *self, Obj *other) {
if (Obj_is_a(other, FLOAT)) {
Float *twin = (Float*)other;
return self->value == twin->value;
}
else if (Obj_is_a(other, INTEGER)) {
Integer *twin = (Integer*)other;
return S_equals_i64_f64(twin->value, self->value);
}
else {
return false;
}
}
int32_t
Float_Compare_To_IMP(Float *self, Obj *other) {
if (Obj_is_a(other, FLOAT)) {
Float *twin = (Float*)other;
return S_compare_f64(self->value, twin->value);
}
else if (Obj_is_a(other, INTEGER)) {
Integer *twin = (Integer*)other;
return -S_compare_i64_f64(twin->value, self->value);
}
else {
THROW(ERR, "Can't compare Float to %o", Obj_get_class_name(other));
UNREACHABLE_RETURN(int32_t);
}
}
bool
Blob_Equals_IMP(Blob *self, Obj *other) {
Blob *const twin = (Blob*)other;
if (twin == self) { return true; }
if (!Obj_is_a(other, BLOB)) { return false; }
return SI_equals_bytes(self, twin->buf, twin->size);
}
bool
Str_Equals_IMP(String *self, Obj *other) {
String *const twin = (String*)other;
if (twin == self) { return true; }
if (!Obj_is_a(other, STRING)) { return false; }
return Str_Equals_Utf8_IMP(self, twin->ptr, twin->size);
}
bool
LFLock_Maybe_Delete_File_IMP(LockFileLock *self, String *path,
bool delete_mine, bool delete_other) {
LockFileLockIVARS *const ivars = LFLock_IVARS(self);
Folder *folder = ivars->folder;
bool success = false;
// Only delete locks that start with our lock name.
if (!Str_Starts_With_Utf8(path, "locks", 5)) {
return false;
}
StringIterator *iter = Str_Top(path);
StrIter_Advance(iter, 5 + 1);
if (!StrIter_Starts_With(iter, ivars->name)) {
DECREF(iter);
return false;
}
DECREF(iter);
// Attempt to delete dead lock file.
if (Folder_Exists(folder, path)) {
Hash *hash = (Hash*)Json_slurp_json(folder, path);
if (hash != NULL && Obj_is_a((Obj*)hash, HASH)) {
String *pid_buf = (String*)Hash_Fetch_Utf8(hash, "pid", 3);
String *host = (String*)Hash_Fetch_Utf8(hash, "host", 4);
String *name = (String*)Hash_Fetch_Utf8(hash, "name", 4);
// Match hostname and lock name.
if (host != NULL
&& Str_is_a(host, STRING)
&& Str_Equals(host, (Obj*)ivars->host)
&& name != NULL
&& Str_is_a(name, STRING)
&& Str_Equals(name, (Obj*)ivars->name)
&& pid_buf != NULL
&& Str_is_a(pid_buf, STRING)
) {
// Verify that pid is either mine or dead.
int pid = (int)Str_To_I64(pid_buf);
if ((delete_mine && pid == PID_getpid()) // This process.
|| (delete_other && !PID_active(pid)) // Dead pid.
) {
if (Folder_Delete(folder, path)) {
success = true;
}
else {
String *mess
= MAKE_MESS("Can't delete '%o'", path);
DECREF(hash);
Err_throw_mess(ERR, mess);
}
}
}
}
DECREF(hash);
}
return success;
}
NumericType*
NumType_Load_IMP(NumericType *self, Obj *dump) {
UNUSED_VAR(self);
Hash *source = (Hash*)CERTIFY(dump, HASH);
// Get a Class
String *class_name = (String*)Hash_Fetch_Utf8(source, "_class", 6);
String *type_spec = (String*)Hash_Fetch_Utf8(source, "type", 4);
Class *klass = NULL;
if (class_name != NULL && Obj_is_a((Obj*)class_name, STRING)) {
klass = Class_singleton(class_name, NULL);
}
else if (type_spec != NULL && Obj_is_a((Obj*)type_spec, STRING)) {
if (Str_Equals_Utf8(type_spec, "i32_t", 5)) {
klass = INT32TYPE;
}
else if (Str_Equals_Utf8(type_spec, "i64_t", 5)) {
klass = INT64TYPE;
}
else if (Str_Equals_Utf8(type_spec, "f32_t", 5)) {
klass = FLOAT32TYPE;
}
else if (Str_Equals_Utf8(type_spec, "f64_t", 5)) {
klass = FLOAT64TYPE;
}
else {
THROW(ERR, "Unrecognized type string: '%o'", type_spec);
}
}
CERTIFY(klass, CLASS);
NumericType *loaded = (NumericType*)Class_Make_Obj(klass);
// Extract boost.
Obj *boost_dump = Hash_Fetch_Utf8(source, "boost", 5);
float boost = boost_dump ? (float)Json_obj_to_f64(boost_dump) : 1.0f;
// Find boolean properties.
Obj *indexed_dump = Hash_Fetch_Utf8(source, "indexed", 7);
Obj *stored_dump = Hash_Fetch_Utf8(source, "stored", 6);
Obj *sort_dump = Hash_Fetch_Utf8(source, "sortable", 8);
bool indexed = indexed_dump ? Json_obj_to_bool(indexed_dump) : true;
bool stored = stored_dump ? Json_obj_to_bool(stored_dump) : true;
bool sortable = sort_dump ? Json_obj_to_bool(sort_dump) : false;
return NumType_init2(loaded, boost, indexed, stored, sortable);
}
bool
StrIter_Equals_IMP(StringIterator *self, Obj *other) {
StringIterator *const twin = (StringIterator*)other;
if (twin == self) { return true; }
if (!Obj_is_a(other, STRINGITERATOR)) { return false; }
return self->string == twin->string
&& self->byte_offset == twin->byte_offset;
}
bool
ORQuery_Equals_IMP(ORQuery *self, Obj *other) {
if ((ORQuery*)other == self) { return true; }
if (!Obj_is_a(other, ORQUERY)) { return false; }
ORQuery_Equals_t super_equals
= (ORQuery_Equals_t)SUPER_METHOD_PTR(ORQUERY, LUCY_ORQuery_Equals);
return super_equals(self, other);
}
InStream*
InStream_do_open(InStream *self, Obj *file) {
InStreamIVARS *const ivars = InStream_IVARS(self);
// Init.
ivars->buf = NULL;
ivars->limit = NULL;
ivars->offset = 0;
ivars->window = FileWindow_new();
// Obtain a FileHandle.
if (Obj_is_a(file, FILEHANDLE)) {
ivars->file_handle = (FileHandle*)INCREF(file);
}
else if (Obj_is_a(file, RAMFILE)) {
ivars->file_handle
= (FileHandle*)RAMFH_open(NULL, FH_READ_ONLY, (RAMFile*)file);
}
else if (Obj_is_a(file, STRING)) {
ivars->file_handle
= (FileHandle*)FSFH_open((String*)file, FH_READ_ONLY);
}
else {
Err_set_error(Err_new(Str_newf("Invalid type for param 'file': '%o'",
Obj_get_class_name(file))));
DECREF(self);
return NULL;
}
if (!ivars->file_handle) {
ERR_ADD_FRAME(Err_get_error());
DECREF(self);
return NULL;
}
// Get length and filename from the FileHandle.
ivars->filename = Str_Clone(FH_Get_Path(ivars->file_handle));
ivars->len = FH_Length(ivars->file_handle);
if (ivars->len == -1) {
ERR_ADD_FRAME(Err_get_error());
DECREF(self);
return NULL;
}
return self;
}
bool
PolyAnalyzer_Equals_IMP(PolyAnalyzer *self, Obj *other) {
if ((PolyAnalyzer*)other == self) { return true; }
if (!Obj_is_a(other, POLYANALYZER)) { return false; }
PolyAnalyzerIVARS *const ivars = PolyAnalyzer_IVARS(self);
PolyAnalyzerIVARS *const ovars = PolyAnalyzer_IVARS((PolyAnalyzer*)other);
if (!Vec_Equals(ovars->analyzers, (Obj*)ivars->analyzers)) { return false; }
return true;
}
bool
SnowStemmer_Equals_IMP(SnowballStemmer *self, Obj *other) {
if ((SnowballStemmer*)other == self) { return true; }
if (!Obj_is_a(other, SNOWBALLSTEMMER)) { return false; }
SnowballStemmerIVARS *ivars = SnowStemmer_IVARS(self);
SnowballStemmerIVARS *ovars = SnowStemmer_IVARS((SnowballStemmer*)other);
if (!Str_Equals(ovars->language, (Obj*)ivars->language)) { return false; }
return true;
}
bool
Int64Type_Equals_IMP(Int64Type *self, Obj *other) {
if (self == (Int64Type*)other) { return true; }
if (!other) { return false; }
if (!Obj_is_a(other, INT64TYPE)) { return false; }
Int64Type_Equals_t super_equals
= SUPER_METHOD_PTR(INT64TYPE, LUCY_Int64Type_Equals);
return super_equals(self, other);
}
bool
Float32Type_Equals_IMP(Float32Type *self, Obj *other) {
if (self == (Float32Type*)other) { return true; }
if (!other) { return false; }
if (!Obj_is_a(other, FLOAT32TYPE)) { return false; }
Float32Type_Equals_t super_equals
= SUPER_METHOD_PTR(FLOAT32TYPE, LUCY_Float32Type_Equals);
return super_equals(self, other);
}
FullTextType*
FullTextType_Load_IMP(FullTextType *self, Obj *dump) {
UNUSED_VAR(self);
Hash *source = (Hash*)CERTIFY(dump, HASH);
String *class_name = (String*)Hash_Fetch_Utf8(source, "_class", 6);
Class *klass
= (class_name != NULL && Obj_is_a((Obj*)class_name, STRING))
? Class_singleton(class_name, NULL)
: FULLTEXTTYPE;
FullTextType *loaded = (FullTextType*)Class_Make_Obj(klass);
// Extract boost.
Obj *boost_dump = Hash_Fetch_Utf8(source, "boost", 5);
float boost = boost_dump ? (float)Json_obj_to_f64(boost_dump) : 1.0f;
// Find boolean properties.
Obj *indexed_dump = Hash_Fetch_Utf8(source, "indexed", 7);
Obj *stored_dump = Hash_Fetch_Utf8(source, "stored", 6);
Obj *sort_dump = Hash_Fetch_Utf8(source, "sortable", 8);
Obj *hl_dump = Hash_Fetch_Utf8(source, "highlightable", 13);
bool indexed = indexed_dump ? Json_obj_to_bool(indexed_dump) : true;
bool stored = stored_dump ? Json_obj_to_bool(stored_dump) : true;
bool sortable = sort_dump ? Json_obj_to_bool(sort_dump) : false;
bool hl = hl_dump ? Json_obj_to_bool(hl_dump) : false;
// Extract an Analyzer.
Obj *analyzer_dump = Hash_Fetch_Utf8(source, "analyzer", 8);
Analyzer *analyzer = NULL;
if (analyzer_dump) {
if (Obj_is_a(analyzer_dump, ANALYZER)) {
// Schema munged the dump and installed a shared analyzer.
analyzer = (Analyzer*)INCREF(analyzer_dump);
}
else if (Obj_is_a((Obj*)analyzer_dump, HASH)) {
analyzer = (Analyzer*)Freezer_load(analyzer_dump);
}
}
CERTIFY(analyzer, ANALYZER);
FullTextType_init2(loaded, analyzer, boost, indexed, stored,
sortable, hl);
DECREF(analyzer);
return loaded;
}
bool
PolyQuery_Equals_IMP(PolyQuery *self, Obj *other) {
if ((PolyQuery*)other == self) { return true; }
if (!Obj_is_a(other, POLYQUERY)) { return false; }
PolyQueryIVARS *const ivars = PolyQuery_IVARS(self);
PolyQueryIVARS *const ovars = PolyQuery_IVARS((PolyQuery*)other);
if (ivars->boost != ovars->boost) { return false; }
if (!Vec_Equals(ovars->children, (Obj*)ivars->children)) { return false; }
return true;
}
bool
TermQuery_Equals_IMP(TermQuery *self, Obj *other) {
if ((TermQuery*)other == self) { return true; }
if (!Obj_is_a(other, TERMQUERY)) { return false; }
TermQueryIVARS *const ivars = TermQuery_IVARS(self);
TermQueryIVARS *const ovars = TermQuery_IVARS((TermQuery*)other);
if (ivars->boost != ovars->boost) { return false; }
if (!Str_Equals(ivars->field, (Obj*)ovars->field)) { return false; }
if (!Obj_Equals(ivars->term, ovars->term)) { return false; }
return true;
}
bool
Schema_Equals_IMP(Schema *self, Obj *other) {
if ((Schema*)other == self) { return true; }
if (!Obj_is_a(other, SCHEMA)) { return false; }
SchemaIVARS *const ivars = Schema_IVARS(self);
SchemaIVARS *const ovars = Schema_IVARS((Schema*)other);
if (!Arch_Equals(ivars->arch, (Obj*)ovars->arch)) { return false; }
if (!Sim_Equals(ivars->sim, (Obj*)ovars->sim)) { return false; }
if (!Hash_Equals(ivars->types, (Obj*)ovars->types)) { return false; }
return true;
}
void
TextTermStepper_Write_Delta_IMP(TextTermStepper *self, OutStream *outstream,
Obj *value) {
TextTermStepperIVARS *const ivars = TextTermStepper_IVARS(self);
CharBuf *charbuf = (CharBuf*)ivars->value;
const char *last_text = CB_Get_Ptr8(charbuf);
size_t last_size = CB_Get_Size(charbuf);
const char *new_text = NULL;
size_t new_size = 0;
if (Obj_is_a(value, STRING)) {
String *new_string = (String*)value;
new_text = Str_Get_Ptr8(new_string);
new_size = Str_Get_Size(new_string);
}
else if (Obj_is_a(value, CHARBUF)) {
CharBuf *new_charbuf = (CharBuf*)value;
new_text = CB_Get_Ptr8(new_charbuf);
new_size = CB_Get_Size(new_charbuf);
}
else {
THROW(ERR, "'value' must be a String or CharBuf");
}
// Count how many bytes the strings share at the top.
const int32_t overlap = StrHelp_overlap(last_text, new_text,
last_size, new_size);
const char *const diff_start_str = new_text + overlap;
const size_t diff_len = new_size - overlap;
// Write number of common bytes and common bytes.
OutStream_Write_C32(outstream, overlap);
OutStream_Write_String(outstream, diff_start_str, diff_len);
// Update value.
CB_Mimic_Utf8(charbuf, new_text, new_size);
// Invalidate string.
DECREF(ivars->string);
ivars->string = NULL;
}
static Obj*
S_load_via_load_method(Class *klass, Obj *dump) {
Obj *dummy = Class_Make_Obj(klass);
Obj *loaded = NULL;
if (Obj_is_a(dummy, ANALYZER)) {
loaded = Analyzer_Load((Analyzer*)dummy, dump);
}
else if (Obj_is_a(dummy, DOC)) {
loaded = (Obj*)Doc_Load((Doc*)dummy, dump);
}
else if (Obj_is_a(dummy, SIMILARITY)) {
loaded = (Obj*)Sim_Load((Similarity*)dummy, dump);
}
else if (Obj_is_a(dummy, FIELDTYPE)) {
loaded = FType_Load((FieldType*)dummy, dump);
}
else if (Obj_is_a(dummy, SCHEMA)) {
loaded = (Obj*)Schema_Load((Schema*)dummy, dump);
}
else if (Obj_is_a(dummy, QUERY)) {
loaded = Query_Load((Query*)dummy, dump);
}
else {
DECREF(dummy);
THROW(ERR, "Don't know how to load '%o'", Class_Get_Name(klass));
}
DECREF(dummy);
return loaded;
}
OutStream*
OutStream_do_open(OutStream *self, Obj *file) {
OutStreamIVARS *const ivars = OutStream_IVARS(self);
// Init.
ivars->buf = (char*)MALLOCATE(IO_STREAM_BUF_SIZE);
ivars->buf_start = 0;
ivars->buf_pos = 0;
// Obtain a FileHandle.
if (Obj_is_a(file, FILEHANDLE)) {
ivars->file_handle = (FileHandle*)INCREF(file);
}
else if (Obj_is_a(file, RAMFILE)) {
ivars->file_handle
= (FileHandle*)RAMFH_open(NULL, FH_WRITE_ONLY, (RAMFile*)file);
}
else if (Obj_is_a(file, STRING)) {
ivars->file_handle = (FileHandle*)FSFH_open((String*)file,
FH_WRITE_ONLY | FH_CREATE | FH_EXCLUSIVE);
}
else {
Err_set_error(Err_new(Str_newf("Invalid type for param 'file': '%o'",
Obj_get_class_name(file))));
DECREF(self);
return NULL;
}
if (!ivars->file_handle) {
ERR_ADD_FRAME(Err_get_error());
DECREF(self);
return NULL;
}
// Derive filepath from FileHandle.
ivars->path = Str_Clone(FH_Get_Path(ivars->file_handle));
return self;
}
bool
LeafQuery_Equals_IMP(LeafQuery *self, Obj *other) {
if ((LeafQuery*)other == self) { return true; }
if (!Obj_is_a(other, LEAFQUERY)) { return false; }
LeafQueryIVARS *const ivars = LeafQuery_IVARS(self);
LeafQueryIVARS *const ovars = LeafQuery_IVARS((LeafQuery*)other);
if (ivars->boost != ovars->boost) { return false; }
if (!!ivars->field ^ !!ovars->field) { return false; }
if (ivars->field) {
if (!Str_Equals(ivars->field, (Obj*)ovars->field)) { return false; }
}
if (!Str_Equals(ivars->text, (Obj*)ovars->text)) { return false; }
return true;
}
Matcher*
PhraseCompiler_Make_Matcher_IMP(PhraseCompiler *self, SegReader *reader,
bool need_score) {
UNUSED_VAR(need_score);
PhraseCompilerIVARS *const ivars = PhraseCompiler_IVARS(self);
PhraseQueryIVARS *const parent_ivars
= PhraseQuery_IVARS((PhraseQuery*)ivars->parent);
Vector *const terms = parent_ivars->terms;
uint32_t num_terms = Vec_Get_Size(terms);
// Bail if there are no terms.
if (!num_terms) { return NULL; }
// Bail unless field is valid and posting type supports positions.
Similarity *sim = PhraseCompiler_Get_Similarity(self);
Posting *posting = Sim_Make_Posting(sim);
if (posting == NULL || !Obj_is_a((Obj*)posting, SCOREPOSTING)) {
DECREF(posting);
return NULL;
}
DECREF(posting);
// Bail if there's no PostingListReader for this segment.
PostingListReader *const plist_reader
= (PostingListReader*)SegReader_Fetch(
reader, Class_Get_Name(POSTINGLISTREADER));
if (!plist_reader) { return NULL; }
// Look up each term.
Vector *plists = Vec_new(num_terms);
for (uint32_t i = 0; i < num_terms; i++) {
Obj *term = Vec_Fetch(terms, i);
PostingList *plist
= PListReader_Posting_List(plist_reader, parent_ivars->field, term);
// Bail if any one of the terms isn't in the index.
if (!plist || !PList_Get_Doc_Freq(plist)) {
DECREF(plist);
DECREF(plists);
return NULL;
}
Vec_Push(plists, (Obj*)plist);
}
Matcher *retval
= (Matcher*)PhraseMatcher_new(sim, plists, (Compiler*)self);
DECREF(plists);
return retval;
}
bool
TermCompiler_Equals_IMP(TermCompiler *self, Obj *other) {
TermCompiler_Equals_t super_equals
= (TermCompiler_Equals_t)SUPER_METHOD_PTR(TERMCOMPILER,
LUCY_TermCompiler_Equals);
if (!super_equals(self, other)) { return false; }
if (!Obj_is_a(other, TERMCOMPILER)) { return false; }
TermCompilerIVARS *const ivars = TermCompiler_IVARS(self);
TermCompilerIVARS *const ovars = TermCompiler_IVARS((TermCompiler*)other);
if (ivars->idf != ovars->idf) { return false; }
if (ivars->raw_weight != ovars->raw_weight) { return false; }
if (ivars->query_norm_factor != ovars->query_norm_factor) { return false; }
if (ivars->normalized_weight != ovars->normalized_weight) { return false; }
return true;
}
bool
PhraseQuery_Equals_IMP(PhraseQuery *self, Obj *other) {
if ((PhraseQuery*)other == self) { return true; }
if (!Obj_is_a(other, PHRASEQUERY)) { return false; }
PhraseQueryIVARS *const ivars = PhraseQuery_IVARS(self);
PhraseQueryIVARS *const ovars = PhraseQuery_IVARS((PhraseQuery*)other);
if (ivars->boost != ovars->boost) { return false; }
if (ivars->field && !ovars->field) { return false; }
if (!ivars->field && ovars->field) { return false; }
if (ivars->field && !Str_Equals(ivars->field, (Obj*)ovars->field)) {
return false;
}
if (!Vec_Equals(ovars->terms, (Obj*)ivars->terms)) { return false; }
return true;
}
bool
PhraseCompiler_Equals_IMP(PhraseCompiler *self, Obj *other) {
if (!Obj_is_a(other, PHRASECOMPILER)) { return false; }
PhraseCompiler_Equals_t super_equals
= (PhraseCompiler_Equals_t)SUPER_METHOD_PTR(PHRASECOMPILER,
LUCY_PhraseCompiler_Equals);
if (!super_equals(self, other)) { return false; }
PhraseCompilerIVARS *const ivars = PhraseCompiler_IVARS(self);
PhraseCompilerIVARS *const ovars
= PhraseCompiler_IVARS((PhraseCompiler*)other);
if (ivars->idf != ovars->idf) { return false; }
if (ivars->raw_weight != ovars->raw_weight) { return false; }
if (ivars->query_norm_factor != ovars->query_norm_factor) { return false; }
if (ivars->normalized_weight != ovars->normalized_weight) { return false; }
return true;
}
bool
FullTextType_Equals_IMP(FullTextType *self, Obj *other) {
if ((FullTextType*)other == self) { return true; }
if (!Obj_is_a(other, FULLTEXTTYPE)) { return false; }
FullTextTypeIVARS *const ivars = FullTextType_IVARS(self);
FullTextTypeIVARS *const ovars = FullTextType_IVARS((FullTextType*)other);
FullTextType_Equals_t super_equals
= (FullTextType_Equals_t)SUPER_METHOD_PTR(FULLTEXTTYPE,
LUCY_FullTextType_Equals);
if (!super_equals(self, other)) { return false; }
if (!!ivars->sortable != !!ovars->sortable) { return false; }
if (!!ivars->highlightable != !!ovars->highlightable) { return false; }
if (!Analyzer_Equals(ivars->analyzer, (Obj*)ovars->analyzer)) {
return false;
}
return true;
}
bool
ProximityCompiler_Equals_IMP(ProximityCompiler *self, Obj *other) {
if ((ProximityCompiler*)other == self) { return true; }
if (!Obj_is_a(other, PROXIMITYCOMPILER)) { return false; }
ProximityCompiler_Equals_t super_equals
= (ProximityCompiler_Equals_t)SUPER_METHOD_PTR(PROXIMITYCOMPILER,
LUCY_ProximityCompiler_Equals);
if (!super_equals(self, other)) { return false; }
ProximityCompilerIVARS *const ivars = ProximityCompiler_IVARS(self);
ProximityCompilerIVARS *const ovars
= ProximityCompiler_IVARS((ProximityCompiler*)other);
if (ivars->idf != ovars->idf) { return false; }
if (ivars->raw_weight != ovars->raw_weight) { return false; }
if (ivars->query_norm_factor != ovars->query_norm_factor) { return false; }
if (ivars->normalized_weight != ovars->normalized_weight) { return false; }
if (ivars->within != ovars->within) { return false; }
return true;
}
