HighlightWriter* HLWriter_new(Schema *schema, Snapshot *snapshot, Segment *segment, PolyReader *polyreader) { HighlightWriter *self = (HighlightWriter*)Class_Make_Obj(HIGHLIGHTWRITER); return HLWriter_init(self, schema, snapshot, segment, polyreader); }
static FieldType* S_load_type(Class *klass, Obj *type_dump) { FieldType *dummy = (FieldType*)Class_Make_Obj(klass); FieldType *loaded = (FieldType*)FType_Load(dummy, type_dump); DECREF(dummy); return loaded; }
InStream* InStream_Reopen_IMP(InStream *self, String *filename, int64_t offset, int64_t len) { InStreamIVARS *const ivars = InStream_IVARS(self); if (!ivars->file_handle) { THROW(ERR, "Can't Reopen() closed InStream %o", ivars->filename); } if (offset + len > FH_Length(ivars->file_handle)) { THROW(ERR, "Offset + length too large (%i64 + %i64 > %i64)", offset, len, FH_Length(ivars->file_handle)); } Class *klass = InStream_get_class(self); InStream *other = (InStream*)Class_Make_Obj(klass); InStreamIVARS *const ovars = InStream_IVARS(other); InStream_do_open(other, (Obj*)ivars->file_handle); if (filename != NULL) { String *temp = ovars->filename; ovars->filename = Str_Clone(filename); DECREF(temp); } ovars->offset = offset; ovars->len = len; InStream_Seek(other, 0); return other; }
ProximityCompiler* ProximityCompiler_new(ProximityQuery *parent, Searcher *searcher, float boost, uint32_t within) { ProximityCompiler *self = (ProximityCompiler*)Class_Make_Obj(PROXIMITYCOMPILER); return ProximityCompiler_init(self, parent, searcher, boost, within); }
void Bool_init_class() { Boolean *true_obj = (Boolean*)Class_Make_Obj(BOOLEAN); true_obj->value = true; true_obj->string = Str_newf("true"); if (!Atomic_cas_ptr((void**)&Bool_true_singleton, NULL, true_obj)) { Bool_Destroy(true_obj); } Boolean *false_obj = (Boolean*)Class_Make_Obj(BOOLEAN); false_obj->value = false; false_obj->string = Str_newf("false"); if (!Atomic_cas_ptr((void**)&Bool_false_singleton, NULL, false_obj)) { Bool_Destroy(false_obj); } }
RangeQuery* RangeQuery_new(String *field, Obj *lower_term, Obj *upper_term, bool include_lower, bool include_upper) { RangeQuery *self = (RangeQuery*)Class_Make_Obj(RANGEQUERY); return RangeQuery_init(self, field, lower_term, upper_term, include_lower, include_upper); }
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; }
DefaultDeletionsWriter* DefDelWriter_new(Schema *schema, Snapshot *snapshot, Segment *segment, PolyReader *polyreader) { DefaultDeletionsWriter *self = (DefaultDeletionsWriter*)Class_Make_Obj(DEFAULTDELETIONSWRITER); return DefDelWriter_init(self, schema, snapshot, segment, polyreader); }
static FieldType* S_alt_field_type() { StackString *name = SSTR_WRAP_UTF8("DummyFieldType2", 15); Class *klass = Class_singleton((String*)name, DUMMYFIELDTYPE); FieldType *self = (FieldType*)Class_Make_Obj(klass); return FType_init(self); }
StringIterator* StrIter_new(String *string, size_t byte_offset) { StringIterator *self = (StringIterator*)Class_Make_Obj(STRINGITERATOR); self->string = (String*)INCREF(string); self->byte_offset = byte_offset; return self; }
Obj* Freezer_thaw(InStream *instream) { String *class_name = Freezer_read_string(instream); Class *klass = Class_singleton(class_name, NULL); Obj *blank = Class_Make_Obj(klass); DECREF(class_name); return Freezer_deserialize(blank, instream); }
DefaultDocReader* DefDocReader_new(Schema *schema, Folder *folder, Snapshot *snapshot, Vector *segments, int32_t seg_tick) { DefaultDocReader *self = (DefaultDocReader*)Class_Make_Obj(DEFAULTDOCREADER); return DefDocReader_init(self, schema, folder, snapshot, segments, seg_tick); }
static SFWriterElem* S_SFWriterElem_create(Obj *value, int32_t doc_id) { SFWriterElem *self = (SFWriterElem*)Class_Make_Obj(SFWRITERELEM); SFWriterElemIVARS *ivars = SFWriterElem_IVARS(self); ivars->value = value; ivars->doc_id = doc_id; return self; }
RequiredOptionalMatcher* ReqOptMatcher_new(Similarity *similarity, Matcher *required_matcher, Matcher *optional_matcher) { RequiredOptionalMatcher *self = (RequiredOptionalMatcher*)Class_Make_Obj(REQUIREDOPTIONALMATCHER); return ReqOptMatcher_init(self, similarity, required_matcher, optional_matcher); }
String* Str_new_steal_utf8(char *utf8, size_t size) { if (!StrHelp_utf8_valid(utf8, size)) { DIE_INVALID_UTF8(utf8, size); } String *self = (String*)Class_Make_Obj(STRING); return Str_init_steal_trusted_utf8(self, utf8, size); }
TextSortCache* TextSortCache_new(String *field, FieldType *type, int32_t cardinality, int32_t doc_max, int32_t null_ord, int32_t ord_width, InStream *ord_in, InStream *ix_in, InStream *dat_in) { TextSortCache *self = (TextSortCache*)Class_Make_Obj(TEXTSORTCACHE); return TextSortCache_init(self, field, type, cardinality, doc_max, null_ord, ord_width, ord_in, ix_in, dat_in); }
InStream* InStream_Clone_IMP(InStream *self) { InStreamIVARS *const ivars = InStream_IVARS(self); Class *klass = InStream_get_class(self); InStream *twin = (InStream*)Class_Make_Obj(klass); InStream_do_open(twin, (Obj*)ivars->file_handle); InStream_Seek(twin, SI_tell(self)); return twin; }
String* Str_Cat_Trusted_Utf8_IMP(String *self, const char* ptr, size_t size) { size_t result_size = self->size + size; char *result_ptr = (char*)MALLOCATE(result_size + 1); memcpy(result_ptr, self->ptr, self->size); memcpy(result_ptr + self->size, ptr, size); result_ptr[result_size] = '\0'; String *result = (String*)Class_Make_Obj(STRING); return Str_init_steal_trusted_utf8(result, result_ptr, result_size); }
ScorePostingMatcher* ScorePost_Make_Matcher_IMP(ScorePosting *self, Similarity *sim, PostingList *plist, Compiler *compiler, bool need_score) { ScorePostingMatcher *matcher = (ScorePostingMatcher*)Class_Make_Obj(SCOREPOSTINGMATCHER); UNUSED_VAR(self); UNUSED_VAR(need_score); return ScorePostMatcher_init(matcher, sim, plist, compiler); }
static Obj* S_new_testobj() { StackString *class_name = SSTR_WRAP_UTF8("TestObj", 7); Obj *obj; Class *klass = Class_fetch_class((String*)class_name); if (!klass) { klass = Class_singleton((String*)class_name, OBJ); } obj = Class_Make_Obj(klass); return Obj_init(obj); }
PostingPool* PostPool_new(Schema *schema, Snapshot *snapshot, Segment *segment, PolyReader *polyreader, String *field, LexiconWriter *lex_writer, MemoryPool *mem_pool, OutStream *lex_temp_out, OutStream *post_temp_out, OutStream *skip_out) { PostingPool *self = (PostingPool*)Class_Make_Obj(POSTINGPOOL); return PostPool_init(self, schema, snapshot, segment, polyreader, field, lex_writer, mem_pool, lex_temp_out, post_temp_out, skip_out); }
SortFieldWriter* SortFieldWriter_new(Schema *schema, Snapshot *snapshot, Segment *segment, PolyReader *polyreader, String *field, Counter *counter, size_t mem_thresh, OutStream *temp_ord_out, OutStream *temp_ix_out, OutStream *temp_dat_out) { SortFieldWriter *self = (SortFieldWriter*)Class_Make_Obj(SORTFIELDWRITER); return SortFieldWriter_init(self, schema, snapshot, segment, polyreader, field, counter, mem_thresh, temp_ord_out, temp_ix_out, temp_dat_out); }
static FileHandle* S_new_filehandle() { String *class_name = SSTR_WRAP_UTF8("TestFileHandle", 14); FileHandle *fh; Class *klass = Class_fetch_class(class_name); if (!klass) { klass = Class_singleton(class_name, FILEHANDLE); } Class_Override(klass, S_no_op_method, LUCY_FH_Close_OFFSET); fh = (FileHandle*)Class_Make_Obj(klass); return FH_do_open(fh, NULL, 0); }
void THROW(Class *klass, char *pattern, ...) { va_list args; va_start(args, pattern); String *message = S_str_vnewf(pattern, args); va_end(args); Err *err = (Err*)Class_Make_Obj(klass); err = Err_init(err, message); Err_do_throw(err); }
void Err_throw_at(Class *klass, const char *file, int line, const char *func, const char *pattern, ...) { va_list args; va_start(args, pattern); String *message = S_vmake_mess(file, line, func, pattern, args); va_end(args); Err *err = (Err*)Class_Make_Obj(klass); err = Err_init(err, message); Err_do_throw(err); }
static void test_abstract_routines(TestBatchRunner *runner) { Obj *blank = Class_Make_Obj(OBJ); S_verify_abstract_error(runner, S_attempt_init, blank, "init"); Obj *obj = S_new_testobj(); S_verify_abstract_error(runner, S_attempt_Clone, obj, "Clone"); S_verify_abstract_error(runner, S_attempt_Compare_To, obj, "Compare_To"); S_verify_abstract_error(runner, S_attempt_To_I64, obj, "To_I64"); S_verify_abstract_error(runner, S_attempt_To_F64, obj, "To_F64"); S_verify_abstract_error(runner, S_attempt_Mimic, obj, "Mimic"); DECREF(obj); }
String* Str_new_from_char(int32_t code_point) { const size_t MAX_UTF8_BYTES = 4; char *ptr = (char*)MALLOCATE(MAX_UTF8_BYTES + 1); size_t size = StrHelp_encode_utf8_char(code_point, (uint8_t*)ptr); ptr[size] = '\0'; String *self = (String*)Class_Make_Obj(STRING); self->ptr = ptr; self->size = size; self->origin = self; return self; }
static String* S_new_substring(String *string, size_t byte_offset, size_t size) { String *self = (String*)Class_Make_Obj(STRING); if (string->origin == NULL) { // Copy substring of wrapped strings. Str_init_from_trusted_utf8(self, string->ptr + byte_offset, size); } else { self->ptr = string->ptr + byte_offset; self->size = size; self->origin = (String*)INCREF(string->origin); } return self; }
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); }
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; }