CharBuf*
Obj_to_string(Obj *self)
{
#if (SIZEOF_PTR == 4)
return CB_newf("%o@0x%x32", Obj_Get_Class_Name(self), self);
#elif (SIZEOF_PTR == 8)
size_t address = self;
u32_t address_hi = address >> 32;
u32_t address_lo = address & 0xFFFFFFFF;
return CB_newf("%o@0x%x32%x32", Obj_Get_Class_Name(self), address_hi,
address_lo);
#endif
}
CharBuf*
Obj_to_string(Obj *self) {
#if (SIZEOF_PTR == 4)
return CB_newf("%o@0x%x32", Obj_Get_Class_Name(self), self);
#elif (SIZEOF_PTR == 8)
int64_t iaddress = PTR_TO_I64(self);
uint64_t address = (uint64_t)iaddress;
uint32_t address_hi = address >> 32;
uint32_t address_lo = address & 0xFFFFFFFF;
return CB_newf("%o@0x%x32%x32", Obj_Get_Class_Name(self), address_hi,
address_lo);
#else
#error "Unexpected pointer size."
#endif
}
CharBuf*
Json_to_json(Obj *dump) {
// Validate object type, only allowing hashes and arrays per JSON spec.
if (!dump || !(Obj_Is_A(dump, HASH) || Obj_Is_A(dump, VARRAY))) {
if (!tolerant) {
CharBuf *class_name = dump ? Obj_Get_Class_Name(dump) : NULL;
CharBuf *mess = MAKE_MESS("Illegal top-level object type: %o",
class_name);
Err_set_error(Err_new(mess));
return NULL;
}
}
// Encode.
CharBuf *json = CB_new(31);
if (!S_to_json(dump, json, 0)) {
DECREF(json);
ERR_ADD_FRAME(Err_get_error());
json = NULL;
}
else {
// Append newline.
CB_Cat_Trusted_Str(json, "\n", 1);
}
return json;
}
static Folder*
S_init_folder(Obj *index, bool_t create)
{
Folder *folder = NULL;
// Validate or acquire a Folder.
if (Obj_Is_A(index, FOLDER)) {
folder = (Folder*)INCREF(index);
}
else if (Obj_Is_A(index, CHARBUF)) {
folder = (Folder*)FSFolder_new((CharBuf*)index);
}
else {
THROW(ERR, "Invalid type for 'index': %o", Obj_Get_Class_Name(index));
}
// Validate or create the index directory.
if (create) {
Folder_Initialize(folder);
}
else {
if (!Folder_Check(folder)) {
THROW(ERR, "Folder '%o' failed check", Folder_Get_Path(folder));
}
}
return folder;
}
void
Indexer_add_index(Indexer *self, Obj *index)
{
Folder *other_folder = NULL;
IndexReader *reader = NULL;
if (Obj_Is_A(index, FOLDER)) {
other_folder = (Folder*)INCREF(index);
}
else if (Obj_Is_A(index, CHARBUF)) {
other_folder = (Folder*)FSFolder_new((CharBuf*)index);
}
else {
THROW(ERR, "Invalid type for 'index': %o", Obj_Get_Class_Name(index));
}
reader = IxReader_open((Obj*)other_folder, NULL, NULL);
if (reader == NULL) {
THROW(ERR, "Index doesn't seem to contain any data");
}
else {
Schema *schema = self->schema;
Schema *other_schema = IxReader_Get_Schema(reader);
VArray *other_fields = Schema_All_Fields(other_schema);
VArray *seg_readers = IxReader_Seg_Readers(reader);
uint32_t i, max;
// Validate schema compatibility and add fields.
Schema_Eat(schema, other_schema);
// Add fields to Segment.
for (i = 0, max = VA_Get_Size(other_fields); i < max; i++) {
CharBuf *other_field = (CharBuf*)VA_Fetch(other_fields, i);
Seg_Add_Field(self->segment, other_field);
}
DECREF(other_fields);
// Add all segments.
for (i = 0, max = VA_Get_Size(seg_readers); i < max; i++) {
SegReader *seg_reader = (SegReader*)VA_Fetch(seg_readers, i);
DeletionsReader *del_reader = (DeletionsReader*)SegReader_Fetch(
seg_reader, VTable_Get_Name(DELETIONSREADER));
Matcher *deletions = del_reader
? DelReader_Iterator(del_reader)
: NULL;
I32Array *doc_map = DelWriter_Generate_Doc_Map(self->del_writer,
deletions, SegReader_Doc_Max(seg_reader),
(int32_t)Seg_Get_Count(self->segment)
);
SegWriter_Add_Segment(self->seg_writer, seg_reader, doc_map);
DECREF(deletions);
DECREF(doc_map);
}
DECREF(seg_readers);
}
DECREF(reader);
DECREF(other_folder);
}
Obj*
Err_downcast(Obj *obj, VTable *vtable, const char *file, int line,
const char *func) {
if (obj && !SI_obj_is_a(obj, vtable)) {
Err_throw_at(ERR, file, line, func, "Can't downcast from %o to %o",
Obj_Get_Class_Name(obj), VTable_Get_Name(vtable));
}
return obj;
}
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;
}
void
LexIndex_seek(LexIndex *self, Obj *target)
{
FieldType *type = self->field_type;
i32_t lo = 0;
i32_t hi = self->size - 1;
i32_t result = -100;
if (target == NULL || self->size == 0) {
self->tick = 0;
return;
}
else {
if ( !OBJ_IS_A(target, CHARBUF)) {
THROW("Target is a %o, and not comparable to a %o",
Obj_Get_Class_Name(target), CHARBUF.name);
}
/* TODO:
Obj *first_obj = VA_Fetch(terms, 0);
if ( !Obj_Is_A(target, Obj_Get_VTable(first_obj)) ) {
THROW("Target is a %o, and not comparable to a %o",
Obj_Get_Class_Name(target), Obj_Get_Class_Name(first_obj));
}
*/
}
/* Divide and conquer. */
while (hi >= lo) {
const i32_t mid = lo + ((hi - lo) / 2);
const i64_t offset
= (i64_t)Math_decode_bigend_u64(self->offsets + mid);
char *data = self->data + offset;
size_t size = Math_decode_c32(&data);
i64_t comparison;
ViewCB_Assign_Str(self->term, data, size);
comparison = FType_Compare_Values(type, target, (Obj*)self->term);
if (comparison < 0) {
hi = mid - 1;
}
else if (comparison > 0) {
lo = mid + 1;
}
else {
result = mid;
break;
}
}
/* Record the index of the entry we've seeked to, then read entry. */
self->tick = hi == -1 ? 0 /* indicating that target lt first entry */
: result == -100 ? hi /* if result is still -100, it wasn't set */
: result;
S_read_entry(self);
}
Obj*
Err_certify(Obj *obj, VTable *vtable, const char *file, int line,
const char *func) {
if (!obj) {
Err_throw_at(ERR, file, line, func, "Object isn't a %o, it's NULL",
VTable_Get_Name(vtable));
}
else if (!SI_obj_is_a(obj, vtable)) {
Err_throw_at(ERR, file, line, func, "Can't downcast from %o to %o",
Obj_Get_Class_Name(obj), VTable_Get_Name(vtable));
}
return obj;
}
static Folder*
S_derive_folder(Obj *index) {
Folder *folder = NULL;
if (Obj_Is_A(index, FOLDER)) {
folder = (Folder*)INCREF(index);
}
else if (Obj_Is_A(index, CHARBUF)) {
folder = (Folder*)FSFolder_new((CharBuf*)index);
}
else {
THROW(ERR, "Invalid type for 'index': %o", Obj_Get_Class_Name(index));
}
return folder;
}
Obj*
kino_Err_assert_is_a(Obj *obj, VTable *vtable, const char *file, int line,
const char *func)
{
if (!obj) {
Err_throw_at(file, line, func, "Object isn't a %o, it's NULL",
VTable_Get_Name(vtable));
}
else if ( !Obj_Is_A(obj, vtable) ) {
Err_throw_at(file, line, func, "Object isn't a %o, it's a %o",
VTable_Get_Name(vtable), Obj_Get_Class_Name(obj));
}
return obj;
}
InStream*
InStream_do_open(InStream *self, Obj *file) {
InStreamIVARS *const ivars = InStream_IVARS(self);
// Init.
ivars->buf = NULL;
ivars->limit = NULL;
ivars->offset = 0;
ivars->window = FileWindow_new();
// Obtain a FileHandle.
if (Obj_Is_A(file, FILEHANDLE)) {
ivars->file_handle = (FileHandle*)INCREF(file);
}
else if (Obj_Is_A(file, RAMFILE)) {
ivars->file_handle
= (FileHandle*)RAMFH_open(NULL, FH_READ_ONLY, (RAMFile*)file);
}
else if (Obj_Is_A(file, CHARBUF)) {
ivars->file_handle
= (FileHandle*)FSFH_open((CharBuf*)file, FH_READ_ONLY);
}
else {
Err_set_error(Err_new(CB_newf("Invalid type for param 'file': '%o'",
Obj_Get_Class_Name(file))));
DECREF(self);
return NULL;
}
if (!ivars->file_handle) {
ERR_ADD_FRAME(Err_get_error());
DECREF(self);
return NULL;
}
// Get length and filename from the FileHandle.
ivars->filename = CB_Clone(FH_Get_Path(ivars->file_handle));
ivars->len = FH_Length(ivars->file_handle);
if (ivars->len == -1) {
ERR_ADD_FRAME(Err_get_error());
DECREF(self);
return NULL;
}
return self;
}
i32_t
SortCache_find(SortCache *self, Obj *term)
{
FieldType *const type = self->type;
i32_t lo = 0;
i32_t hi = self->num_uniq - 1;
i32_t result = -100;
ZombieCharBuf value = ZCB_BLANK;
if ( term != NULL && !OBJ_IS_A(term, CHARBUF)) {
THROW("term is a %o, and not comparable to a %o",
Obj_Get_Class_Name(term), CHARBUF.name);
}
/* Binary search. */
while (hi >= lo) {
const i32_t mid = lo + ((hi - lo) / 2);
ViewCharBuf *val = SortCache_Value(self, mid, (ViewCharBuf*)&value);
i64_t comparison = FType_Compare_Values(type, term, (Obj*)val);
if (comparison < 0) {
hi = mid - 1;
}
else if (comparison > 0) {
lo = mid + 1;
}
else {
result = mid;
break;
}
}
if (hi < 0) {
/* Target is "less than" the first cache entry. */
return -1;
}
else if (result == -100) {
/* If result is still -100, it wasn't set. */
return hi;
}
else {
return result;
}
}
static bool_t
S_rename_or_hard_link(RAMFolder *self, const CharBuf* from, const CharBuf *to,
Folder *from_folder, Folder *to_folder,
ZombieCharBuf *from_name, ZombieCharBuf *to_name,
int op)
{
Obj *elem = NULL;
RAMFolder *inner_from_folder = NULL;
RAMFolder *inner_to_folder = NULL;
UNUSED_VAR(self);
// Make sure the source and destination folders exist.
if (!from_folder) {
Err_set_error(Err_new(CB_newf("File not found: '%o'", from)));
return false;
}
if (!to_folder) {
Err_set_error(Err_new(CB_newf(
"Invalid file path (can't find dir): '%o'", to)));
return false;
}
// Extract RAMFolders from compound reader wrappers, if necessary.
if (Folder_Is_A(from_folder, COMPOUNDFILEREADER)) {
inner_from_folder = (RAMFolder*)CFReader_Get_Real_Folder(
(CompoundFileReader*)from_folder);
}
else {
inner_from_folder = (RAMFolder*)from_folder;
}
if (Folder_Is_A(to_folder, COMPOUNDFILEREADER)) {
inner_to_folder = (RAMFolder*)CFReader_Get_Real_Folder(
(CompoundFileReader*)to_folder);
}
else {
inner_to_folder = (RAMFolder*)to_folder;
}
if (!RAMFolder_Is_A(inner_from_folder, RAMFOLDER)) {
Err_set_error(Err_new(CB_newf("Not a RAMFolder, but a '%o'",
Obj_Get_Class_Name((Obj*)inner_from_folder))));
return false;
}
if (!RAMFolder_Is_A(inner_to_folder, RAMFOLDER)) {
Err_set_error(Err_new(CB_newf("Not a RAMFolder, but a '%o'",
Obj_Get_Class_Name((Obj*)inner_to_folder))));
return false;
}
// Find the original element.
elem = Hash_Fetch(inner_from_folder->entries, (Obj*)from_name);
if (!elem) {
if ( Folder_Is_A(from_folder, COMPOUNDFILEREADER)
&& Folder_Local_Exists(from_folder, (CharBuf*)from_name)
) {
Err_set_error(Err_new(CB_newf("Source file '%o' is virtual",
from)));
}
else {
Err_set_error(Err_new(CB_newf("File not found: '%o'", from)));
}
return false;
}
// Execute the rename/hard-link.
if (op == OP_RENAME) {
Obj *existing = Hash_Fetch(inner_to_folder->entries, (Obj*)to_name);
if (existing) {
bool_t conflict = false;
// Return success fast if file is copied on top of itself.
if ( inner_from_folder == inner_to_folder
&& ZCB_Equals(from_name, (Obj*)to_name)
) {
return true;
}
// Don't allow clobbering of different entry type.
if (Obj_Is_A(elem, RAMFILE)) {
if (!Obj_Is_A(existing, RAMFILE)) {
conflict = true;
}
}
else if (Obj_Is_A(elem, FOLDER)) {
if (!Obj_Is_A(existing, FOLDER)) {
conflict = true;
}
}
if (conflict) {
Err_set_error(Err_new(CB_newf("Can't clobber a %o with a %o",
Obj_Get_Class_Name(existing), Obj_Get_Class_Name(elem))));
return false;
}
}
// Perform the store first, then the delete. Inform Folder objects
// about the relocation.
Hash_Store(inner_to_folder->entries, (Obj*)to_name, INCREF(elem));
DECREF(Hash_Delete(inner_from_folder->entries, (Obj*)from_name));
if (Obj_Is_A(elem, FOLDER)) {
CharBuf *newpath = S_fullpath(inner_to_folder, (CharBuf*)to_name);
Folder_Set_Path((Folder*)elem, newpath);
DECREF(newpath);
}
}
else if (op == OP_HARD_LINK) {
if (!Obj_Is_A(elem, RAMFILE)) {
Err_set_error(Err_new(CB_newf("'%o' isn't a file, it's a %o",
from, Obj_Get_Class_Name(elem))));
return false;
}
else {
Obj *existing
= Hash_Fetch(inner_to_folder->entries, (Obj*)to_name);
if (existing) {
Err_set_error(Err_new(CB_newf("'%o' already exists", to)));
return false;
}
else {
Hash_Store(inner_to_folder->entries, (Obj*)to_name,
INCREF(elem));
}
}
}
else {
THROW(ERR, "Unexpected op: %i32", (int32_t)op);
}
return true;
}
static bool_t
S_to_json(Obj *dump, CharBuf *json, int32_t depth) {
// Guard against infinite recursion in self-referencing data structures.
if (depth > MAX_DEPTH) {
CharBuf *mess = MAKE_MESS("Exceeded max depth of %i32", MAX_DEPTH);
Err_set_error(Err_new(mess));
return false;
}
if (!dump) {
CB_Cat_Trusted_Str(json, "null", 4);
}
else if (dump == (Obj*)CFISH_TRUE) {
CB_Cat_Trusted_Str(json, "true", 4);
}
else if (dump == (Obj*)CFISH_FALSE) {
CB_Cat_Trusted_Str(json, "false", 5);
}
else if (Obj_Is_A(dump, CHARBUF)) {
S_append_json_string(dump, json);
}
else if (Obj_Is_A(dump, INTNUM)) {
CB_catf(json, "%i64", Obj_To_I64(dump));
}
else if (Obj_Is_A(dump, FLOATNUM)) {
CB_catf(json, "%f64", Obj_To_F64(dump));
}
else if (Obj_Is_A(dump, VARRAY)) {
VArray *array = (VArray*)dump;
size_t size = VA_Get_Size(array);
if (size == 0) {
// Put empty array on single line.
CB_Cat_Trusted_Str(json, "[]", 2);
return true;
}
else if (size == 1) {
Obj *elem = VA_Fetch(array, 0);
if (!(Obj_Is_A(elem, HASH) || Obj_Is_A(elem, VARRAY))) {
// Put array containing single scalar element on one line.
CB_Cat_Trusted_Str(json, "[", 1);
if (!S_to_json(elem, json, depth + 1)) {
return false;
}
CB_Cat_Trusted_Str(json, "]", 1);
return true;
}
}
// Fall back to spreading elements across multiple lines.
CB_Cat_Trusted_Str(json, "[", 1);
for (size_t i = 0; i < size; i++) {
CB_Cat_Trusted_Str(json, "\n", 1);
S_cat_whitespace(json, depth + 1);
if (!S_to_json(VA_Fetch(array, i), json, depth + 1)) {
return false;
}
if (i + 1 < size) {
CB_Cat_Trusted_Str(json, ",", 1);
}
}
CB_Cat_Trusted_Str(json, "\n", 1);
S_cat_whitespace(json, depth);
CB_Cat_Trusted_Str(json, "]", 1);
}
else if (Obj_Is_A(dump, HASH)) {
Hash *hash = (Hash*)dump;
size_t size = Hash_Get_Size(hash);
// Put empty hash on single line.
if (size == 0) {
CB_Cat_Trusted_Str(json, "{}", 2);
return true;
}
// Validate that all keys are strings, then sort.
VArray *keys = Hash_Keys(hash);
for (size_t i = 0; i < size; i++) {
Obj *key = VA_Fetch(keys, i);
if (!key || !Obj_Is_A(key, CHARBUF)) {
DECREF(keys);
CharBuf *key_class = key ? Obj_Get_Class_Name(key) : NULL;
CharBuf *mess = MAKE_MESS("Illegal key type: %o", key_class);
Err_set_error(Err_new(mess));
return false;
}
}
VA_Sort(keys, NULL, NULL);
// Spread pairs across multiple lines.
CB_Cat_Trusted_Str(json, "{", 1);
for (size_t i = 0; i < size; i++) {
Obj *key = VA_Fetch(keys, i);
CB_Cat_Trusted_Str(json, "\n", 1);
S_cat_whitespace(json, depth + 1);
S_append_json_string(key, json);
CB_Cat_Trusted_Str(json, ": ", 2);
if (!S_to_json(Hash_Fetch(hash, key), json, depth + 1)) {
DECREF(keys);
return false;
}
if (i + 1 < size) {
CB_Cat_Trusted_Str(json, ",", 1);
}
}
CB_Cat_Trusted_Str(json, "\n", 1);
S_cat_whitespace(json, depth);
CB_Cat_Trusted_Str(json, "}", 1);
DECREF(keys);
}
return true;
}
void
Obj_serialize(Obj *self, OutStream *outstream)
{
CharBuf *class_name = Obj_Get_Class_Name(self);
CB_Serialize(class_name, outstream);
}
void
Freezer_freeze(Obj *obj, OutStream *outstream) {
CB_Serialize(Obj_Get_Class_Name(obj), outstream);
Obj_Serialize(obj, outstream);
}
