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;
}
NumericSortCache*
NumSortCache_init(NumericSortCache *self, const CharBuf *field,
FieldType *type, int32_t cardinality, int32_t doc_max,
int32_t null_ord, int32_t ord_width, InStream *ord_in,
InStream *dat_in) {
// Validate.
if (!type || !FType_Sortable(type) || !FType_Is_A(type, NUMERICTYPE)) {
DECREF(self);
THROW(ERR, "'%o' isn't a sortable NumericType field", field);
}
// Mmap ords and super-init.
int64_t ord_len = InStream_Length(ord_in);
void *ords = InStream_Buf(ord_in, (size_t)ord_len);
SortCache_init((SortCache*)self, field, type, ords, cardinality, doc_max,
null_ord, ord_width);
// Assign.
self->ord_in = (InStream*)INCREF(ord_in);
self->dat_in = (InStream*)INCREF(dat_in);
// Validate ord file length.
double BITS_PER_BYTE = 8.0;
double docs_per_byte = BITS_PER_BYTE / self->ord_width;
double max_ords = ord_len * docs_per_byte;
if (max_ords < self->doc_max + 1) {
DECREF(self);
THROW(ERR, "Conflict between ord count max %f64 and doc_max %i32 for "
"field %o", max_ords, self->doc_max, field);
}
ABSTRACT_CLASS_CHECK(self, NUMERICSORTCACHE);
return self;
}
DeletionsWriter*
DelWriter_init(DeletionsWriter *self, Schema *schema, Snapshot *snapshot,
Segment *segment, PolyReader *polyreader) {
DataWriter_init((DataWriter*)self, schema, snapshot, segment, polyreader);
ABSTRACT_CLASS_CHECK(self, DELETIONSWRITER);
return self;
}
void
Compiler_serialize(Compiler *self, OutStream *outstream) {
ABSTRACT_CLASS_CHECK(self, COMPILER);
OutStream_Write_F32(outstream, self->boost);
FREEZE(self->parent, outstream);
FREEZE(self->sim, outstream);
}
HighlightReader*
HLReader_init(HighlightReader *self, Schema *schema, Folder *folder,
Snapshot *snapshot, VArray *segments, int32_t seg_tick) {
DataReader_init((DataReader*)self, schema, folder, snapshot, segments,
seg_tick);
ABSTRACT_CLASS_CHECK(self, HIGHLIGHTREADER);
return self;
}
DirHandle*
DH_init(DirHandle *self, const CharBuf *dir) {
DirHandleIVARS *const ivars = DH_IVARS(self);
ivars->dir = CB_Clone(dir);
ivars->entry = CB_new(32);
ABSTRACT_CLASS_CHECK(self, DIRHANDLE);
return self;
}
LexiconReader*
LexReader_init(LexiconReader *self, Schema *schema, Folder *folder,
Snapshot *snapshot, VArray *segments, int32_t seg_tick) {
DataReader_init((DataReader*)self, schema, folder, snapshot, segments,
seg_tick);
ABSTRACT_CLASS_CHECK(self, LEXICONREADER);
return self;
}
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;
}
FieldType*
FType_init2(FieldType *self, float boost, bool indexed, bool stored,
bool sortable) {
FieldTypeIVARS *const ivars = FType_IVARS(self);
ivars->boost = boost;
ivars->indexed = indexed;
ivars->stored = stored;
ivars->sortable = sortable;
ABSTRACT_CLASS_CHECK(self, FIELDTYPE);
return self;
}
FileHandle*
FH_do_open(FileHandle *self, const CharBuf *path, uint32_t flags) {
self->path = path ? CB_Clone(path) : CB_new(0);
self->flags = flags;
// Track number of live FileHandles released into the wild.
FH_object_count++;
ABSTRACT_CLASS_CHECK(self, FILEHANDLE);
return self;
}
DataWriter*
DataWriter_init(DataWriter *self, Schema *schema, Snapshot *snapshot,
Segment *segment, PolyReader *polyreader) {
DataWriterIVARS *const ivars = DataWriter_IVARS(self);
ivars->snapshot = (Snapshot*)INCREF(snapshot);
ivars->segment = (Segment*)INCREF(segment);
ivars->polyreader = (PolyReader*)INCREF(polyreader);
ivars->schema = (Schema*)INCREF(schema);
ivars->folder = (Folder*)INCREF(PolyReader_Get_Folder(polyreader));
ABSTRACT_CLASS_CHECK(self, DATAWRITER);
return self;
}
Compiler*
Compiler_init(Compiler *self, Query *parent, Searcher *searcher,
Similarity *sim, float boost) {
Query_init((Query*)self, boost);
if (!sim) {
Schema *schema = Searcher_Get_Schema(searcher);
sim = Schema_Get_Similarity(schema);
}
self->parent = (Query*)INCREF(parent);
self->sim = (Similarity*)INCREF(sim);
ABSTRACT_CLASS_CHECK(self, COMPILER);
return self;
}
PriorityQueue*
PriQ_init(PriorityQueue *self, uint32_t max_size) {
PriorityQueueIVARS *const ivars = PriQ_IVARS(self);
if (max_size == UINT32_MAX) {
THROW(ERR, "max_size too large: %u32", max_size);
}
uint32_t heap_size = max_size + 1;
// Init.
ivars->size = 0;
// Assign.
ivars->max_size = max_size;
// Allocate space for the heap, assign all slots to NULL.
ivars->heap = (Obj**)CALLOCATE(heap_size, sizeof(Obj*));
ABSTRACT_CLASS_CHECK(self, PRIORITYQUEUE);
return self;
}
SortExternal*
SortEx_init(SortExternal *self) {
SortExternalIVARS *const ivars = SortEx_IVARS(self);
ivars->mem_thresh = UINT32_MAX;
ivars->buffer = NULL;
ivars->buf_cap = 0;
ivars->buf_max = 0;
ivars->buf_tick = 0;
ivars->scratch = NULL;
ivars->scratch_cap = 0;
ivars->runs = Vec_new(0);
ivars->slice_sizes = NULL;
ivars->slice_starts = NULL;
ivars->num_slices = 0;
ivars->flipped = false;
ABSTRACT_CLASS_CHECK(self, SORTEXTERNAL);
return self;
}
Folder*
Folder_init(Folder *self, const CharBuf *path) {
// Init.
self->entries = Hash_new(16);
// Copy.
if (path == NULL) {
self->path = CB_new_from_trusted_utf8("", 0);
}
else {
// Copy path, strip trailing slash or equivalent.
self->path = CB_Clone(path);
if (CB_Ends_With_Str(self->path, DIR_SEP, strlen(DIR_SEP))) {
CB_Chop(self->path, 1);
}
}
ABSTRACT_CLASS_CHECK(self, FOLDER);
return self;
}
SortExternal*
SortEx_init(SortExternal *self, size_t width) {
SortExternalIVARS *const ivars = SortEx_IVARS(self);
// Assign.
ivars->width = width;
// Init.
ivars->mem_thresh = UINT32_MAX;
ivars->cache = NULL;
ivars->cache_cap = 0;
ivars->cache_max = 0;
ivars->cache_tick = 0;
ivars->scratch = NULL;
ivars->scratch_cap = 0;
ivars->runs = VA_new(0);
ivars->slice_sizes = NULL;
ivars->slice_starts = NULL;
ivars->num_slices = 0;
ivars->flipped = false;
ABSTRACT_CLASS_CHECK(self, SORTEXTERNAL);
return self;
}
SortCache*
SortCache_init(SortCache *self, String *field, FieldType *type,
const void *ords, int32_t cardinality, int32_t doc_max,
int32_t null_ord, int32_t ord_width) {
SortCacheIVARS *const ivars = SortCache_IVARS(self);
// Init.
ivars->native_ords = false;
// Assign.
if (!FType_Sortable(type)) {
THROW(ERR, "Non-sortable FieldType for %o", field);
}
ivars->field = Str_Clone(field);
ivars->type = (FieldType*)INCREF(type);
ivars->ords = ords;
ivars->cardinality = cardinality;
ivars->doc_max = doc_max;
ivars->null_ord = null_ord;
ivars->ord_width = ord_width;
ABSTRACT_CLASS_CHECK(self, SORTCACHE);
return self;
}
Obj*
Obj_init(Obj *self) {
ABSTRACT_CLASS_CHECK(self, OBJ);
return self;
}
Query*
Query_init(Query *self, float boost) {
Query_IVARS(self)->boost = boost;
ABSTRACT_CLASS_CHECK(self, QUERY);
return self;
}
Num*
Num_init(Num *self) {
ABSTRACT_CLASS_CHECK(self, NUM);
return self;
}
Matcher*
Matcher_init(Matcher *self) {
ABSTRACT_CLASS_CHECK(self, MATCHER);
return self;
}
IntNum*
IntNum_init(IntNum *self) {
ABSTRACT_CLASS_CHECK(self, INTNUM);
return (IntNum*)Num_init((Num*)self);
}
FloatNum*
FloatNum_init(FloatNum *self) {
ABSTRACT_CLASS_CHECK(self, FLOATNUM);
return (FloatNum*)Num_init((Num*)self);
}
