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