LeafQuery*
LeafQuery_init(LeafQuery *self, String *field, String *text) {
LeafQueryIVARS *const ivars = LeafQuery_IVARS(self);
Query_init((Query*)self, 1.0f);
ivars->field = field ? Str_Clone(field) : NULL;
ivars->text = Str_Clone(text);
return self;
}
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;
}
void
FH_Set_Path_IMP(FileHandle *self, String *path) {
FileHandleIVARS *const ivars = FH_IVARS(self);
String *temp = ivars->path;
ivars->path = Str_Clone(path);
DECREF(temp);
}
Lock*
Lock_init(Lock *self, Folder *folder, String *name, int32_t timeout,
int32_t interval) {
LockIVARS *const ivars = Lock_IVARS(self);
// Validate.
if (interval <= 0) {
DECREF(self);
THROW(ERR, "Invalid value for 'interval': %i32", interval);
}
StringIterator *iter = Str_Top(name);
int32_t code_point;
while (STR_OOB != (code_point = StrIter_Next(iter))) {
if (isalnum(code_point)
|| code_point == '.'
|| code_point == '-'
|| code_point == '_'
) {
continue;
}
DECREF(self);
THROW(ERR, "Lock name contains disallowed characters: '%o'", name);
}
DECREF(iter);
// Assign.
ivars->folder = (Folder*)INCREF(folder);
ivars->timeout = timeout;
ivars->name = Str_Clone(name);
ivars->interval = interval;
return self;
}
String*
IxFileNames_latest_snapshot(Folder *folder) {
DirHandle *dh = Folder_Open_Dir(folder, NULL);
String *retval = NULL;
uint64_t latest_gen = 0;
if (!dh) { RETHROW(INCREF(Err_get_error())); }
while (DH_Next(dh)) {
String *entry = DH_Get_Entry(dh);
if (Str_Starts_With_Utf8(entry, "snapshot_", 9)
&& Str_Ends_With_Utf8(entry, ".json", 5)
) {
uint64_t gen = IxFileNames_extract_gen(entry);
if (gen > latest_gen) {
latest_gen = gen;
DECREF(retval);
retval = Str_Clone(entry);
}
}
DECREF(entry);
}
DECREF(dh);
return retval;
}
LockFactory*
LockFact_init(LockFactory *self, Folder *folder, String *host) {
LockFactoryIVARS *const ivars = LockFact_IVARS(self);
ivars->folder = (Folder*)INCREF(folder);
ivars->host = Str_Clone(host);
return self;
}
void
Snapshot_Set_Path_IMP(Snapshot *self, String *path) {
SnapshotIVARS *const ivars = Snapshot_IVARS(self);
String *temp = ivars->path;
ivars->path = path ? Str_Clone(path) : NULL;
DECREF(temp);
}
FileHandle*
FH_do_open(FileHandle *self, String *path, uint32_t flags) {
// Track number of live FileHandles released into the wild.
FH_object_count++;
// Check flags.
uint32_t rw_flags = flags & (FH_READ_ONLY | FH_WRITE_ONLY);
if (rw_flags == 0) {
ErrMsg_set("Must specify FH_READ_ONLY or FH_WRITE_ONLY to open '%o'",
path);
DECREF(self);
return NULL;
}
else if (rw_flags == (FH_READ_ONLY | FH_WRITE_ONLY)) {
ErrMsg_set("Can't specify both FH_READ_ONLY and FH_WRITE_ONLY to"
" open '%o'", path);
DECREF(self);
return NULL;
}
if ((flags & (FH_CREATE | FH_EXCLUSIVE)) == FH_EXCLUSIVE) {
ErrMsg_set("Can't specify FH_EXCLUSIVE without FH_CREATE to"
" open '%o' ", path);
DECREF(self);
return NULL;
}
FileHandleIVARS *const ivars = FH_IVARS(self);
ivars->path = path ? Str_Clone(path) : Str_new_from_trusted_utf8("", 0);
ivars->flags = flags;
ABSTRACT_CLASS_CHECK(self, FILEHANDLE);
return self;
}
SortFieldWriter*
SortFieldWriter_init(SortFieldWriter *self, 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) {
// Init.
SortEx_init((SortExternal*)self);
SortFieldWriterIVARS *const ivars = SortFieldWriter_IVARS(self);
ivars->null_ord = -1;
ivars->count = 0;
ivars->ord_start = 0;
ivars->ord_end = 0;
ivars->ix_start = 0;
ivars->ix_end = 0;
ivars->dat_start = 0;
ivars->dat_end = 0;
ivars->run_cardinality = -1;
ivars->run_max = -1;
ivars->sort_cache = NULL;
ivars->doc_map = NULL;
ivars->sorted_ids = NULL;
ivars->run_tick = 1;
ivars->ord_width = 0;
// Assign.
ivars->field = Str_Clone(field);
ivars->schema = (Schema*)INCREF(schema);
ivars->snapshot = (Snapshot*)INCREF(snapshot);
ivars->segment = (Segment*)INCREF(segment);
ivars->polyreader = (PolyReader*)INCREF(polyreader);
ivars->counter = (Counter*)INCREF(counter);
ivars->temp_ord_out = (OutStream*)INCREF(temp_ord_out);
ivars->temp_ix_out = (OutStream*)INCREF(temp_ix_out);
ivars->temp_dat_out = (OutStream*)INCREF(temp_dat_out);
ivars->mem_thresh = mem_thresh;
// Derive.
ivars->field_num = Seg_Field_Num(segment, field);
FieldType *type = (FieldType*)CERTIFY(
Schema_Fetch_Type(ivars->schema, field), FIELDTYPE);
ivars->type = (FieldType*)INCREF(type);
ivars->prim_id = FType_Primitive_ID(type);
ivars->mem_per_entry = Class_Get_Obj_Alloc_Size(SFWRITERELEM);
if (ivars->prim_id == FType_TEXT) {
ivars->mem_per_entry += Class_Get_Obj_Alloc_Size(STRING);
ivars->var_width = true;
}
else if (ivars->prim_id == FType_BLOB) {
ivars->mem_per_entry += Class_Get_Obj_Alloc_Size(BLOB);
ivars->var_width = true;
}
else {
ivars->mem_per_entry += Class_Get_Obj_Alloc_Size(FLOAT);
ivars->var_width = false;
}
return self;
}
TermQuery*
TermQuery_init(TermQuery *self, String *field, Obj *term) {
Query_init((Query*)self, 1.0f);
TermQueryIVARS *const ivars = TermQuery_IVARS(self);
ivars->field = Str_Clone(field);
ivars->term = Obj_Clone(term);
return self;
}
Hash*
StringType_Dump_IMP(StringType *self) {
Hash *dump = StringType_Dump_For_Schema(self);
Hash_Store_Utf8(dump, "_class", 6,
(Obj*)Str_Clone(StringType_Get_Class_Name(self)));
DECREF(Hash_Delete_Utf8(dump, "type", 4));
return dump;
}
Hash*
NumType_Dump_IMP(NumericType *self) {
Hash *dump = NumType_Dump_For_Schema(self);
Hash_Store_Utf8(dump, "_class", 6,
(Obj*)Str_Clone(NumType_get_class_name(self)));
DECREF(Hash_Delete_Utf8(dump, "type", 4));
return dump;
}
static void
test_Clone(TestBatchRunner *runner) {
String *wanted = S_get_str("foo");
String *got = Str_Clone(wanted);
TEST_TRUE(runner, Str_Equals(wanted, (Obj*)got), "Clone");
DECREF(got);
DECREF(wanted);
}
DirHandle*
DH_init(DirHandle *self, String *dir) {
DirHandleIVARS *const ivars = DH_IVARS(self);
ivars->dir = Str_Clone(dir);
ivars->entry = NULL;
ABSTRACT_CLASS_CHECK(self, DIRHANDLE);
return self;
}
Hash*
SnowStemmer_Dump_IMP(SnowballStemmer *self) {
SnowballStemmerIVARS *const ivars = SnowStemmer_IVARS(self);
SnowStemmer_Dump_t super_dump
= SUPER_METHOD_PTR(SNOWBALLSTEMMER, LUCY_SnowStemmer_Dump);
Hash *dump = super_dump(self);
Hash_Store_Utf8(dump, "language", 8, (Obj*)Str_Clone(ivars->language));
return dump;
}
Hash*
EasyAnalyzer_Dump_IMP(EasyAnalyzer *self) {
EasyAnalyzerIVARS *const ivars = EasyAnalyzer_IVARS(self);
EasyAnalyzer_Dump_t super_dump
= SUPER_METHOD_PTR(EASYANALYZER, LUCY_EasyAnalyzer_Dump);
Hash *dump = super_dump(self);
Hash_Store_Utf8(dump, "language", 8, (Obj*)Str_Clone(ivars->language));
return dump;
}
Obj*
RegexTokenizer_Dump_IMP(RegexTokenizer *self) {
RegexTokenizerIVARS *const ivars = RegexTokenizer_IVARS(self);
RegexTokenizer_Dump_t super_dump
= SUPER_METHOD_PTR(REGEXTOKENIZER, LUCY_RegexTokenizer_Dump);
Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
Hash_Store_Utf8(dump, "pattern", 7, (Obj*)Str_Clone(ivars->pattern));
return (Obj*)dump;
}
EasyAnalyzer*
EasyAnalyzer_init(EasyAnalyzer *self, String *language) {
Analyzer_init((Analyzer*)self);
EasyAnalyzerIVARS *const ivars = EasyAnalyzer_IVARS(self);
ivars->language = Str_Clone(language);
ivars->tokenizer = StandardTokenizer_new();
ivars->normalizer = Normalizer_new(NULL, true, false);
ivars->stemmer = SnowStemmer_new(language);
return self;
}
Obj*
Query_Dump_IMP(Query *self) {
QueryIVARS *ivars = Query_IVARS(self);
Hash *dump = Hash_new(0);
Hash_Store_Utf8(dump, "_class", 6,
(Obj*)Str_Clone(Obj_Get_Class_Name((Obj*)self)));
Hash_Store_Utf8(dump, "boost", 5,
(Obj*)Str_newf("%f64", (double)ivars->boost));
return (Obj*)dump;
}
String*
LeafQuery_To_String_IMP(LeafQuery *self) {
LeafQueryIVARS *const ivars = LeafQuery_IVARS(self);
if (ivars->field) {
return Str_newf("%o:%o", ivars->field, ivars->text);
}
else {
return Str_Clone(ivars->text);
}
}
static String*
S_absolutify(String *path) {
if (S_is_absolute(path)) { return Str_Clone(path); }
char *cwd = getcwd(NULL, 0);
if (!cwd) { THROW(ERR, "getcwd failed"); }
String *abs_path = Str_newf("%s" DIR_SEP "%o", cwd, path);
free(cwd);
return abs_path;
}
Hash*
FullTextType_Dump_IMP(FullTextType *self) {
FullTextTypeIVARS *const ivars = FullTextType_IVARS(self);
Hash *dump = FullTextType_Dump_For_Schema(self);
Hash_Store_Utf8(dump, "_class", 6,
(Obj*)Str_Clone(FullTextType_get_class_name(self)));
Hash_Store_Utf8(dump, "analyzer", 8,
(Obj*)Analyzer_Dump(ivars->analyzer));
DECREF(Hash_Delete_Utf8(dump, "type", 4));
return dump;
}
Query*
QParser_Parse_IMP(QueryParser *self, String *query_string) {
String *qstring = query_string
? Str_Clone(query_string)
: Str_new_from_trusted_utf8("", 0);
Query *tree = QParser_Tree(self, qstring);
Query *expanded = QParser_Expand(self, tree);
Query *pruned = QParser_Prune(self, expanded);
DECREF(expanded);
DECREF(tree);
DECREF(qstring);
return pruned;
}
InverterEntry*
InvEntry_init(InverterEntry *self, Schema *schema, String *field,
int32_t field_num) {
InverterEntryIVARS *const ivars = InvEntry_IVARS(self);
ivars->field_num = field_num;
ivars->field = field ? Str_Clone(field) : NULL;
ivars->inversion = NULL;
if (schema) {
ivars->analyzer
= (Analyzer*)INCREF(Schema_Fetch_Analyzer(schema, field));
ivars->sim = (Similarity*)INCREF(Schema_Fetch_Sim(schema, field));
ivars->type = (FieldType*)INCREF(Schema_Fetch_Type(schema, field));
if (!ivars->type) { THROW(ERR, "Unknown field: '%o'", field); }
uint8_t prim_id = FType_Primitive_ID(ivars->type);
switch (prim_id & FType_PRIMITIVE_ID_MASK) {
case FType_TEXT:
ivars->value = NULL;
break;
case FType_BLOB:
ivars->value = (Obj*)ViewBB_new(NULL, 0);
break;
case FType_INT32:
ivars->value = (Obj*)Int32_new(0);
break;
case FType_INT64:
ivars->value = (Obj*)Int64_new(0);
break;
case FType_FLOAT32:
ivars->value = (Obj*)Float32_new(0);
break;
case FType_FLOAT64:
ivars->value = (Obj*)Float64_new(0);
break;
default:
THROW(ERR, "Unrecognized primitive id: %i8", prim_id);
}
ivars->indexed = FType_Indexed(ivars->type);
if (ivars->indexed && FType_Is_A(ivars->type, NUMERICTYPE)) {
THROW(ERR, "Field '%o' spec'd as indexed, but numerical types cannot "
"be indexed yet", field);
}
if (FType_Is_A(ivars->type, FULLTEXTTYPE)) {
ivars->highlightable
= FullTextType_Highlightable((FullTextType*)ivars->type);
}
}
return self;
}
QueryParser*
QParser_init(QueryParser *self, Schema *schema, Analyzer *analyzer,
String *default_boolop, Vector *fields) {
QueryParserIVARS *const ivars = QParser_IVARS(self);
// Init.
ivars->heed_colons = false;
ivars->lexer = QueryLexer_new();
// Assign.
ivars->schema = (Schema*)INCREF(schema);
ivars->analyzer = (Analyzer*)INCREF(analyzer);
ivars->default_boolop = default_boolop
? Str_Clone(default_boolop)
: Str_new_from_trusted_utf8("OR", 2);
if (fields) {
ivars->fields = Vec_Clone(fields);
for (uint32_t i = 0, max = Vec_Get_Size(fields); i < max; i++) {
CERTIFY(Vec_Fetch(fields, i), STRING);
}
Vec_Sort(ivars->fields);
}
else {
Vector *all_fields = Schema_All_Fields(schema);
uint32_t num_fields = Vec_Get_Size(all_fields);
ivars->fields = Vec_new(num_fields);
for (uint32_t i = 0; i < num_fields; i++) {
String *field = (String*)Vec_Fetch(all_fields, i);
FieldType *type = Schema_Fetch_Type(schema, field);
if (type && FType_Indexed(type)) {
Vec_Push(ivars->fields, INCREF(field));
}
}
DECREF(all_fields);
}
Vec_Sort(ivars->fields);
// Derive default "occur" from default boolean operator.
if (Str_Equals_Utf8(ivars->default_boolop, "OR", 2)) {
ivars->default_occur = SHOULD;
}
else if (Str_Equals_Utf8(ivars->default_boolop, "AND", 3)) {
ivars->default_occur = MUST;
}
else {
THROW(ERR, "Invalid value for default_boolop: %o", ivars->default_boolop);
}
return self;
}
int32_t
Seg_Add_Field_IMP(Segment *self, String *field) {
SegmentIVARS *const ivars = Seg_IVARS(self);
Integer *num = (Integer*)Hash_Fetch(ivars->by_name, field);
if (num) {
return (int32_t)Int_Get_Value(num);
}
else {
int32_t field_num = (int32_t)Vec_Get_Size(ivars->by_num);
Hash_Store(ivars->by_name, field, (Obj*)Int_new(field_num));
Vec_Push(ivars->by_num, (Obj*)Str_Clone(field));
return field_num;
}
}
IndexManager*
IxManager_init(IndexManager *self, String *host) {
IndexManagerIVARS *const ivars = IxManager_IVARS(self);
ivars->host = host
? Str_Clone(host)
: Str_new_from_trusted_utf8("", 0);
ivars->folder = NULL;
ivars->write_lock_timeout = 1000;
ivars->write_lock_interval = 100;
ivars->merge_lock_timeout = 0;
ivars->merge_lock_interval = 1000;
return self;
}
Snapshot*
Snapshot_Read_File_IMP(Snapshot *self, Folder *folder, String *path) {
SnapshotIVARS *const ivars = Snapshot_IVARS(self);
// Eliminate all prior data. Pick a snapshot file.
S_zero_out(self);
ivars->path = (path != NULL && Str_Get_Size(path) > 0)
? Str_Clone(path)
: IxFileNames_latest_snapshot(folder);
if (ivars->path) {
Hash *snap_data
= (Hash*)CERTIFY(Json_slurp_json(folder, ivars->path), HASH);
Obj *format_obj
= CERTIFY(Hash_Fetch_Utf8(snap_data, "format", 6), OBJ);
int32_t format = (int32_t)Json_obj_to_i64(format_obj);
Obj *subformat_obj = Hash_Fetch_Utf8(snap_data, "subformat", 9);
int32_t subformat = subformat_obj
? (int32_t)Json_obj_to_i64(subformat_obj)
: 0;
// Verify that we can read the index properly.
if (format > Snapshot_current_file_format) {
THROW(ERR, "Snapshot format too recent: %i32, %i32",
format, Snapshot_current_file_format);
}
// Build up list of entries.
Vector *list = (Vector*)INCREF(CERTIFY(
Hash_Fetch_Utf8(snap_data, "entries", 7),
VECTOR));
if (format == 1 || (format == 2 && subformat < 1)) {
Vector *cleaned = S_clean_segment_contents(list);
DECREF(list);
list = cleaned;
}
Hash_Clear(ivars->entries);
for (uint32_t i = 0, max = Vec_Get_Size(list); i < max; i++) {
String *entry
= (String*)CERTIFY(Vec_Fetch(list, i), STRING);
Hash_Store(ivars->entries, entry, (Obj*)CFISH_TRUE);
}
DECREF(list);
DECREF(snap_data);
}
return self;
}
TermVector*
TV_init(TermVector *self, String *field, String *text,
I32Array *positions, I32Array *start_offsets, I32Array *end_offsets) {
TermVectorIVARS *const ivars = TV_IVARS(self);
// Assign.
ivars->field = Str_Clone(field);
ivars->text = Str_Clone(text);
ivars->num_pos = I32Arr_Get_Size(positions);
ivars->positions = (I32Array*)INCREF(positions);
ivars->start_offsets = (I32Array*)INCREF(start_offsets);
ivars->end_offsets = (I32Array*)INCREF(end_offsets);
if (I32Arr_Get_Size(start_offsets) != ivars->num_pos
|| I32Arr_Get_Size(end_offsets) != ivars->num_pos
) {
THROW(ERR, "Unbalanced arrays: %u64 %u64 %u64",
(uint64_t)ivars->num_pos,
(uint64_t)I32Arr_Get_Size(start_offsets),
(uint64_t)I32Arr_Get_Size(end_offsets));
}
return self;
}
static String*
S_absolutify(String *path) {
if (S_is_absolute(path)) { return Str_Clone(path); }
DWORD cwd_len = GetCurrentDirectory(0, NULL);
char *cwd = (char*)MALLOCATE(cwd_len);
DWORD res = GetCurrentDirectory(cwd_len, cwd);
if (res == 0 || res > cwd_len) {
THROW(ERR, "GetCurrentDirectory failed");
}
String *abs_path = Str_newf("%s\\%o", cwd, path);
FREEMEM(cwd);
return abs_path;
}
