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