TermVector*
DocVec_Term_Vector_IMP(DocVector *self, String *field,
String *term_text) {
DocVectorIVARS *const ivars = DocVec_IVARS(self);
Hash *field_vector = (Hash*)Hash_Fetch(ivars->field_vectors, (Obj*)field);
// If no cache hit, try to fill cache.
if (field_vector == NULL) {
ByteBuf *field_buf
= (ByteBuf*)Hash_Fetch(ivars->field_bufs, (Obj*)field);
// Bail if there's no content or the field isn't highlightable.
if (field_buf == NULL) { return NULL; }
field_vector = S_extract_tv_cache(field_buf);
Hash_Store(ivars->field_vectors, (Obj*)field, (Obj*)field_vector);
}
// Get a buf for the term text or bail.
ByteBuf *tv_buf = (ByteBuf*)Hash_Fetch(field_vector, (Obj*)term_text);
if (tv_buf == NULL) {
return NULL;
}
return S_extract_tv_from_tv_buf(field, term_text, tv_buf);
}
TermVector*
DocVec_term_vector(DocVector *self, const CharBuf *field,
const CharBuf *term_text) {
Hash *field_vector = (Hash*)Hash_Fetch(self->field_vectors, (Obj*)field);
// If no cache hit, try to fill cache.
if (field_vector == NULL) {
ByteBuf *field_buf
= (ByteBuf*)Hash_Fetch(self->field_bufs, (Obj*)field);
// Bail if there's no content or the field isn't highlightable.
if (field_buf == NULL) { return NULL; }
field_vector = S_extract_tv_cache(field_buf);
Hash_Store(self->field_vectors, (Obj*)field, (Obj*)field_vector);
}
// Get a buf for the term text or bail.
ByteBuf *tv_buf = (ByteBuf*)Hash_Fetch(field_vector, (Obj*)term_text);
if (tv_buf == NULL) {
return NULL;
}
return S_extract_tv_from_tv_buf(field, term_text, tv_buf);
}
static void
S_init_sub_readers(PolyReader *self, VArray *sub_readers) {
PolyReaderIVARS *const ivars = PolyReader_IVARS(self);
uint32_t num_sub_readers = VA_Get_Size(sub_readers);
int32_t *starts = (int32_t*)MALLOCATE(num_sub_readers * sizeof(int32_t));
Hash *data_readers = Hash_new(0);
DECREF(ivars->sub_readers);
DECREF(ivars->offsets);
ivars->sub_readers = (VArray*)INCREF(sub_readers);
// Accumulate doc_max, subreader start offsets, and DataReaders.
ivars->doc_max = 0;
for (uint32_t i = 0; i < num_sub_readers; i++) {
SegReader *seg_reader = (SegReader*)VA_Fetch(sub_readers, i);
Hash *components = SegReader_Get_Components(seg_reader);
CharBuf *api;
DataReader *component;
starts[i] = ivars->doc_max;
ivars->doc_max += SegReader_Doc_Max(seg_reader);
Hash_Iterate(components);
while (Hash_Next(components, (Obj**)&api, (Obj**)&component)) {
VArray *readers = (VArray*)Hash_Fetch(data_readers, (Obj*)api);
if (!readers) {
readers = VA_new(num_sub_readers);
Hash_Store(data_readers, (Obj*)api, (Obj*)readers);
}
VA_Store(readers, i, INCREF(component));
}
}
ivars->offsets = I32Arr_new_steal(starts, num_sub_readers);
CharBuf *api;
VArray *readers;
Hash_Iterate(data_readers);
while (Hash_Next(data_readers, (Obj**)&api, (Obj**)&readers)) {
DataReader *datareader
= (DataReader*)CERTIFY(S_first_non_null(readers), DATAREADER);
DataReader *aggregator
= DataReader_Aggregator(datareader, readers, ivars->offsets);
if (aggregator) {
CERTIFY(aggregator, DATAREADER);
Hash_Store(ivars->components, (Obj*)api, (Obj*)aggregator);
}
}
DECREF(data_readers);
DeletionsReader *del_reader
= (DeletionsReader*)Hash_Fetch(
ivars->components, (Obj*)VTable_Get_Name(DELETIONSREADER));
ivars->del_count = del_reader ? DelReader_Del_Count(del_reader) : 0;
}
void
Seg_store_metadata(Segment *self, const CharBuf *key, Obj *value) {
if (Hash_Fetch(self->metadata, (Obj*)key)) {
THROW(ERR, "Metadata key '%o' already registered", key);
}
Hash_Store(self->metadata, (Obj*)key, value);
}
SegReader*
SegReader_init(SegReader *self, Schema *schema, Folder *folder,
Snapshot *snapshot, Vector *segments, int32_t seg_tick) {
Segment *segment;
IxReader_init((IndexReader*)self, schema, folder, snapshot, segments,
seg_tick, NULL);
SegReaderIVARS *const ivars = SegReader_IVARS(self);
segment = SegReader_Get_Segment(self);
ivars->doc_max = (int32_t)Seg_Get_Count(segment);
ivars->seg_name = (String*)INCREF(Seg_Get_Name(segment));
ivars->seg_num = Seg_Get_Number(segment);
Err *error = Err_trap(S_try_init_components, self);
if (error) {
// An error occurred, so clean up self and rethrow the exception.
DECREF(self);
RETHROW(error);
}
DeletionsReader *del_reader
= (DeletionsReader*)Hash_Fetch(
ivars->components, Class_Get_Name(DELETIONSREADER));
ivars->del_count = del_reader ? DelReader_Del_Count(del_reader) : 0;
return self;
}
bool_t
RAMFolder_local_is_directory(RAMFolder *self, const CharBuf *name)
{
Obj *entry = Hash_Fetch(self->entries, (Obj*)name);
if (entry && Obj_Is_A(entry, FOLDER)) { return true; }
return false;
}
FileDes*
RAMFolder_open_filedes(RAMFolder *self, const CharBuf *filepath)
{
RAMFileDes *file_des
= (RAMFileDes*)Hash_Fetch(self->elems, filepath);
return file_des ? (FileDes*)INCREF(file_des) : NULL;
}
Folder*
CFReader_Local_Find_Folder_IMP(CompoundFileReader *self,
String *name) {
CompoundFileReaderIVARS *const ivars = CFReader_IVARS(self);
if (Hash_Fetch(ivars->records, name)) { return false; }
return Folder_Local_Find_Folder(ivars->real_folder, name);
}
bool
CFReader_Local_Exists_IMP(CompoundFileReader *self, String *name) {
CompoundFileReaderIVARS *const ivars = CFReader_IVARS(self);
if (Hash_Fetch(ivars->records, name)) { return true; }
if (Folder_Local_Exists(ivars->real_folder, name)) { return true; }
return false;
}
InStream*
CFReader_Local_Open_In_IMP(CompoundFileReader *self, String *name) {
CompoundFileReaderIVARS *const ivars = CFReader_IVARS(self);
Hash *entry = (Hash*)Hash_Fetch(ivars->records, name);
if (!entry) {
InStream *instream = Folder_Local_Open_In(ivars->real_folder, name);
if (!instream) {
ERR_ADD_FRAME(Err_get_error());
}
return instream;
}
else {
Obj *len = Hash_Fetch_Utf8(entry, "length", 6);
Obj *offset = Hash_Fetch_Utf8(entry, "offset", 6);
if (!len || !offset) {
Err_set_error(Err_new(Str_newf("Malformed entry for '%o' in '%o'",
name, Folder_Get_Path(ivars->real_folder))));
return NULL;
}
else if (Str_Get_Size(ivars->path)) {
String *fullpath = Str_newf("%o/%o", ivars->path, name);
InStream *instream = InStream_Reopen(ivars->instream, fullpath,
Obj_To_I64(offset), Obj_To_I64(len));
DECREF(fullpath);
return instream;
}
else {
return InStream_Reopen(ivars->instream, name, Obj_To_I64(offset),
Obj_To_I64(len));
}
}
}
bool_t
RAMFolder_local_delete(RAMFolder *self, const CharBuf *name)
{
Obj *entry = Hash_Fetch(self->entries, (Obj*)name);
if (entry) {
if (Obj_Is_A(entry, RAMFILE)) {
;
}
else if (Obj_Is_A(entry, FOLDER)) {
RAMFolder *inner_folder;
if (Obj_Is_A(entry, COMPOUNDFILEREADER)) {
inner_folder = (RAMFolder*)CERTIFY(
CFReader_Get_Real_Folder((CompoundFileReader*)entry),
RAMFOLDER);
}
else {
inner_folder = (RAMFolder*)CERTIFY(entry, RAMFOLDER);
}
if (Hash_Get_Size(inner_folder->entries)) {
// Can't delete non-empty dir.
return false;
}
}
else {
return false;
}
DECREF(Hash_Delete(self->entries, (Obj*)name));
return true;
}
else {
return false;
}
}
bool_t
Hash_equals(Hash *self, Obj *other) {
Hash *twin = (Hash*)other;
Obj *key;
Obj *val;
if (twin == self) {
return true;
}
if (!Obj_Is_A(other, HASH)) {
return false;
}
if (self->size != twin->size) {
return false;
}
Hash_Iterate(self);
while (Hash_Next(self, &key, &val)) {
Obj *other_val = Hash_Fetch(twin, key);
if (!other_val || !Obj_Equals(other_val, val)) {
return false;
}
}
return true;
}
InStream*
CFReader_local_open_in(CompoundFileReader *self, const CharBuf *name) {
Hash *entry = (Hash*)Hash_Fetch(self->records, (Obj*)name);
if (!entry) {
InStream *instream = Folder_Local_Open_In(self->real_folder, name);
if (!instream) {
ERR_ADD_FRAME(Err_get_error());
}
return instream;
}
else {
Obj *len = Hash_Fetch_Str(entry, "length", 6);
Obj *offset = Hash_Fetch_Str(entry, "offset", 6);
if (!len || !offset) {
Err_set_error(Err_new(CB_newf("Malformed entry for '%o' in '%o'",
name, Folder_Get_Path(self->real_folder))));
return NULL;
}
else if (CB_Get_Size(self->path)) {
CharBuf *fullpath = CB_newf("%o/%o", self->path, name);
InStream *instream = InStream_Reopen(self->instream, fullpath,
Obj_To_I64(offset), Obj_To_I64(len));
DECREF(fullpath);
return instream;
}
else {
return InStream_Reopen(self->instream, name, Obj_To_I64(offset),
Obj_To_I64(len));
}
}
}
Analyzer*
Schema_Fetch_Analyzer_IMP(Schema *self, String *field) {
SchemaIVARS *const ivars = Schema_IVARS(self);
return field
? (Analyzer*)Hash_Fetch(ivars->analyzers, field)
: NULL;
}
Matcher*
DefDelWriter_Seg_Deletions_IMP(DefaultDeletionsWriter *self,
SegReader *seg_reader) {
DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
Matcher *deletions = NULL;
Segment *segment = SegReader_Get_Segment(seg_reader);
String *seg_name = Seg_Get_Name(segment);
Integer32 *tick_obj = (Integer32*)Hash_Fetch(ivars->name_to_tick,
(Obj*)seg_name);
int32_t tick = tick_obj ? Int32_Get_Value(tick_obj) : 0;
SegReader *candidate = tick_obj
? (SegReader*)VA_Fetch(ivars->seg_readers, tick)
: NULL;
if (tick_obj) {
DeletionsReader *del_reader
= (DeletionsReader*)SegReader_Obtain(
candidate, Class_Get_Name(DELETIONSREADER));
if (ivars->updated[tick] || DelReader_Del_Count(del_reader)) {
BitVector *deldocs = (BitVector*)VA_Fetch(ivars->bit_vecs, tick);
deletions = (Matcher*)BitVecMatcher_new(deldocs);
}
}
else { // Sanity check.
THROW(ERR, "Couldn't find SegReader %o", seg_reader);
}
return deletions;
}
RAMFileDes*
RAMFolder_ram_file(RAMFolder *self, const CharBuf *filepath)
{
RAMFileDes *ram_file = (RAMFileDes*)Hash_Fetch(self->elems, filepath);
if (ram_file == NULL)
THROW( "File '%o' not loaded into RAM", filepath);
return ram_file;
}
void
Seg_Store_Metadata_IMP(Segment *self, String *key, Obj *value) {
SegmentIVARS *const ivars = Seg_IVARS(self);
if (Hash_Fetch(ivars->metadata, key)) {
THROW(ERR, "Metadata key '%o' already registered", key);
}
Hash_Store(ivars->metadata, key, value);
}
Folder*
RAMFolder_local_find_folder(RAMFolder *self, const CharBuf *path)
{
Folder *local_folder = (Folder*)Hash_Fetch(self->entries, (Obj*)path);
if (local_folder && Folder_Is_A(local_folder, FOLDER)) {
return local_folder;
}
return NULL;
}
Similarity*
Schema_Fetch_Sim_IMP(Schema *self, String *field) {
SchemaIVARS *const ivars = Schema_IVARS(self);
Similarity *sim = NULL;
if (field != NULL) {
sim = (Similarity*)Hash_Fetch(ivars->sims, field);
}
return sim;
}
void
SegReader_register(SegReader *self, const CharBuf *api, DataReader *component)
{
if (Hash_Fetch(self->components, api)) {
THROW("Interface '%o' already registered");
}
ASSERT_IS_A(component, DATAREADER);
Hash_Store(self->components, api, (Obj*)component);
}
int32_t
DefDelWriter_Seg_Del_Count_IMP(DefaultDeletionsWriter *self,
String *seg_name) {
DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
Integer *tick = (Integer*)Hash_Fetch(ivars->name_to_tick, seg_name);
BitVector *deldocs = tick
? (BitVector*)Vec_Fetch(ivars->bit_vecs, (size_t)Int_Get_Value(tick))
: NULL;
return deldocs ? (int32_t)BitVec_Count(deldocs) : 0;
}
bool_t
RAMFolder_exists(RAMFolder *self, const CharBuf *filepath)
{
if (Hash_Fetch(self->elems, filepath) != NULL) {
return true;
}
else {
return false;
}
}
void
SegReader_Register_IMP(SegReader *self, String *api,
DataReader *component) {
SegReaderIVARS *const ivars = SegReader_IVARS(self);
if (Hash_Fetch(ivars->components, api)) {
THROW(ERR, "Interface '%o' already registered");
}
CERTIFY(component, DATAREADER);
Hash_Store(ivars->components, api, (Obj*)component);
}
void
SegWriter_Register_IMP(SegWriter *self, String *api,
DataWriter *component) {
SegWriterIVARS *const ivars = SegWriter_IVARS(self);
CERTIFY(component, DATAWRITER);
if (Hash_Fetch(ivars->by_api, api)) {
THROW(ERR, "API %o already registered", api);
}
Hash_Store(ivars->by_api, api, (Obj*)component);
}
int32_t
Seg_field_num(Segment *self, const CharBuf *field) {
if (field == NULL) {
return 0;
}
else {
Integer32 *num = (Integer32*)Hash_Fetch(self->by_name, (Obj*)field);
return num ? Int32_Get_Value(num) : 0;
}
}
int32_t
DefDelWriter_seg_del_count(DefaultDeletionsWriter *self,
const CharBuf *seg_name) {
DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
Integer32 *tick
= (Integer32*)Hash_Fetch(ivars->name_to_tick, (Obj*)seg_name);
BitVector *deldocs = tick
? (BitVector*)VA_Fetch(ivars->bit_vecs, Int32_Get_Value(tick))
: NULL;
return deldocs ? BitVec_Count(deldocs) : 0;
}
int32_t
Seg_Field_Num_IMP(Segment *self, String *field) {
if (field == NULL) {
return 0;
}
else {
SegmentIVARS *const ivars = Seg_IVARS(self);
Integer *num = (Integer*)Hash_Fetch(ivars->by_name, field);
return num ? (int32_t)Int_Get_Value(num) : 0;
}
}
bool_t
CFReader_local_mkdir(CompoundFileReader *self, const CharBuf *name) {
if (Hash_Fetch(self->records, (Obj*)name)) {
Err_set_error(Err_new(CB_newf("Can't MkDir: '%o' exists", name)));
return false;
}
else {
bool_t result = Folder_Local_MkDir(self->real_folder, name);
if (!result) { ERR_ADD_FRAME(Err_get_error()); }
return result;
}
}
OutStream*
RAMFolder_open_out(RAMFolder *self, const CharBuf *filepath)
{
if (Hash_Fetch(self->elems, filepath)) {
return NULL;
}
else {
RAMFileDes *file_des = RAMFileDes_new(filepath);
Hash_Store(self->elems, filepath, (Obj*)file_des);
return OutStream_new((FileDes*)file_des);
}
}
int32_t
Seg_add_field(Segment *self, const CharBuf *field) {
Integer32 *num = (Integer32*)Hash_Fetch(self->by_name, (Obj*)field);
if (num) {
return Int32_Get_Value(num);
}
else {
int32_t field_num = VA_Get_Size(self->by_num);
Hash_Store(self->by_name, (Obj*)field, (Obj*)Int32_new(field_num));
VA_Push(self->by_num, (Obj*)CB_Clone(field));
return field_num;
}
}