StringType*
StringType_load(StringType *self, Obj *dump)
{
Hash *source = (Hash*)CERTIFY(dump, HASH);
CharBuf *class_name = (CharBuf*)Hash_Fetch_Str(source, "_class", 6);
VTable *vtable
= (class_name != NULL && Obj_Is_A((Obj*)class_name, CHARBUF))
? VTable_singleton(class_name, NULL)
: STRINGTYPE;
StringType *loaded = (StringType*)VTable_Make_Obj(vtable);
Obj *boost_dump = Hash_Fetch_Str(source, "boost", 5);
Obj *indexed_dump = Hash_Fetch_Str(source, "indexed", 7);
Obj *stored_dump = Hash_Fetch_Str(source, "stored", 6);
Obj *sortable_dump = Hash_Fetch_Str(source, "sortable", 8);
UNUSED_VAR(self);
StringType_init(loaded);
if (boost_dump)
{ loaded->boost = (float)Obj_To_F64(boost_dump); }
if (indexed_dump)
{ loaded->indexed = (bool_t)Obj_To_I64(indexed_dump); }
if (stored_dump)
{ loaded->stored = (bool_t)Obj_To_I64(stored_dump); }
if (sortable_dump)
{ loaded->sortable = (bool_t)Obj_To_I64(sortable_dump); }
return loaded;
}
BlobType*
BlobType_Load_IMP(BlobType *self, Obj *dump) {
Hash *source = (Hash*)CERTIFY(dump, HASH);
String *class_name = (String*)Hash_Fetch_Utf8(source, "_class", 6);
VTable *vtable
= (class_name != NULL && Obj_Is_A((Obj*)class_name, STRING))
? VTable_singleton(class_name, NULL)
: BLOBTYPE;
BlobType *loaded = (BlobType*)VTable_Make_Obj(vtable);
Obj *boost_dump = Hash_Fetch_Utf8(source, "boost", 5);
Obj *indexed_dump = Hash_Fetch_Utf8(source, "indexed", 7);
Obj *stored_dump = Hash_Fetch_Utf8(source, "stored", 6);
UNUSED_VAR(self);
BlobType_init(loaded, false);
BlobTypeIVARS *const loaded_ivars = BlobType_IVARS(loaded);
if (boost_dump) {
loaded_ivars->boost = (float)Obj_To_F64(boost_dump);
}
if (indexed_dump) {
loaded_ivars->indexed = Obj_To_Bool(indexed_dump);
}
if (stored_dump){
loaded_ivars->stored = Obj_To_Bool(stored_dump);
}
return loaded;
}
HitDoc*
HitDoc_Load_IMP(HitDoc *self, Obj *dump) {
Hash *source = (Hash*)CERTIFY(dump, HASH);
HitDoc_Load_t super_load
= SUPER_METHOD_PTR(HITDOC, LUCY_HitDoc_Load);
HitDoc *loaded = super_load(self, dump);
HitDocIVARS *const loaded_ivars = HitDoc_IVARS(loaded);
Obj *score = CERTIFY(Hash_Fetch_Utf8(source, "score", 5), OBJ);
loaded_ivars->score = (float)Obj_To_F64(score);
return loaded;
}
Obj*
Query_Load_IMP(Query *self, Obj *dump) {
CHY_UNUSED_VAR(self);
Hash *source = (Hash*)CERTIFY(dump, HASH);
String *class_name
= (String*)CERTIFY(Hash_Fetch_Utf8(source, "_class", 6), STRING);
VTable *vtable = VTable_singleton(class_name, NULL);
Query *loaded = (Query*)VTable_Make_Obj(vtable);
Obj *boost = CERTIFY(Hash_Fetch_Utf8(source, "boost", 5), OBJ);
Query_IVARS(loaded)->boost = (float)Obj_To_F64(boost);
return (Obj*)loaded;
}
FullTextType*
FullTextType_load(FullTextType *self, Obj *dump) {
UNUSED_VAR(self);
Hash *source = (Hash*)CERTIFY(dump, HASH);
CharBuf *class_name = (CharBuf*)Hash_Fetch_Str(source, "_class", 6);
VTable *vtable
= (class_name != NULL && Obj_Is_A((Obj*)class_name, CHARBUF))
? VTable_singleton(class_name, NULL)
: FULLTEXTTYPE;
FullTextType *loaded = (FullTextType*)VTable_Make_Obj(vtable);
// Extract boost.
Obj *boost_dump = Hash_Fetch_Str(source, "boost", 5);
float boost = boost_dump ? (float)Obj_To_F64(boost_dump) : 1.0f;
// Find boolean properties.
Obj *indexed_dump = Hash_Fetch_Str(source, "indexed", 7);
Obj *stored_dump = Hash_Fetch_Str(source, "stored", 6);
Obj *sort_dump = Hash_Fetch_Str(source, "sortable", 8);
Obj *hl_dump = Hash_Fetch_Str(source, "highlightable", 13);
bool_t indexed = indexed_dump ? Obj_To_Bool(indexed_dump) : true;
bool_t stored = stored_dump ? Obj_To_Bool(stored_dump) : true;
bool_t sortable = sort_dump ? Obj_To_Bool(sort_dump) : false;
bool_t hl = hl_dump ? Obj_To_Bool(hl_dump) : false;
// Extract an Analyzer.
Obj *analyzer_dump = Hash_Fetch_Str(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*)Obj_Load(analyzer_dump, analyzer_dump);
}
}
CERTIFY(analyzer, ANALYZER);
FullTextType_init(loaded, analyzer);
DECREF(analyzer);
if (boost_dump) { loaded->boost = boost; }
if (indexed_dump) { loaded->indexed = indexed; }
if (stored_dump) { loaded->stored = stored; }
if (sort_dump) { loaded->sortable = sortable; }
if (hl_dump) { loaded->highlightable = hl; }
return loaded;
}
NumericType*
NumType_load(NumericType *self, Obj *dump)
{
UNUSED_VAR(self);
Hash *source = (Hash*)CERTIFY(dump, HASH);
// Get a VTable
CharBuf *class_name = (CharBuf*)Hash_Fetch_Str(source, "_class", 6);
CharBuf *type_spec = (CharBuf*)Hash_Fetch_Str(source, "type", 4);
VTable *vtable = NULL;
if (class_name != NULL && Obj_Is_A((Obj*)class_name, CHARBUF)) {
vtable = VTable_singleton(class_name, NULL);
}
else if (type_spec != NULL && Obj_Is_A((Obj*)type_spec, CHARBUF)) {
if (CB_Equals_Str(type_spec, "i32_t", 5)) {
vtable = INT32TYPE;
}
else if (CB_Equals_Str(type_spec, "i64_t", 5)) {
vtable = INT64TYPE;
}
else if (CB_Equals_Str(type_spec, "f32_t", 5)) {
vtable = FLOAT32TYPE;
}
else if (CB_Equals_Str(type_spec, "f64_t", 5)) {
vtable = FLOAT64TYPE;
}
else {
THROW(ERR, "Unrecognized type string: '%o'", type_spec);
}
}
CERTIFY(vtable, VTABLE);
NumericType *loaded = (NumericType*)VTable_Make_Obj(vtable);
// Extract boost.
Obj *boost_dump = Hash_Fetch_Str(source, "boost", 5);
float boost = boost_dump ? (float)Obj_To_F64(boost_dump) : 1.0f;
// Find boolean properties.
Obj *indexed_dump = Hash_Fetch_Str(source, "indexed", 7);
Obj *stored_dump = Hash_Fetch_Str(source, "stored", 6);
Obj *sort_dump = Hash_Fetch_Str(source, "sortable", 8);
bool_t indexed = indexed_dump ? (bool_t)Obj_To_I64(indexed_dump) : true;
bool_t stored = stored_dump ? (bool_t)Obj_To_I64(stored_dump) : true;
bool_t sortable = sort_dump ? (bool_t)Obj_To_I64(sort_dump) : false;
return NumType_init2(loaded, boost, indexed, stored, sortable);
}
StringType*
StringType_Load_IMP(StringType *self, Obj *dump) {
Hash *source = (Hash*)CERTIFY(dump, HASH);
String *class_name = (String*)Hash_Fetch_Utf8(source, "_class", 6);
VTable *vtable
= (class_name != NULL && Obj_Is_A((Obj*)class_name, STRING))
? VTable_singleton(class_name, NULL)
: STRINGTYPE;
StringType *loaded = (StringType*)VTable_Make_Obj(vtable);
Obj *boost_dump = Hash_Fetch_Utf8(source, "boost", 5);
Obj *indexed_dump = Hash_Fetch_Utf8(source, "indexed", 7);
Obj *stored_dump = Hash_Fetch_Utf8(source, "stored", 6);
Obj *sortable_dump = Hash_Fetch_Utf8(source, "sortable", 8);
UNUSED_VAR(self);
float boost = boost_dump ? (float)Obj_To_F64(boost_dump) : 1.0f;
bool indexed = indexed_dump ? Obj_To_Bool(indexed_dump) : true;
bool stored = stored_dump ? Obj_To_Bool(stored_dump) : true;
bool sortable = sortable_dump ? Obj_To_Bool(sortable_dump) : false;
return StringType_init2(loaded, boost, indexed, stored, sortable);
}
void
Inverter_invert_doc(Inverter *self, Doc *doc) {
InverterIVARS *const ivars = Inverter_IVARS(self);
Hash *const fields = (Hash*)Doc_Get_Fields(doc);
uint32_t num_keys = Hash_Iterate(fields);
// Prepare for the new doc.
Inverter_Set_Doc(self, doc);
// Extract and invert the doc's fields.
while (num_keys--) {
Obj *key, *obj;
Hash_Next(fields, &key, &obj);
CharBuf *field = (CharBuf*)CERTIFY(key, CHARBUF);
InverterEntry *inventry = S_fetch_entry(ivars, field);
InverterEntryIVARS *inventry_ivars = InvEntry_IVARS(inventry);
FieldType *type = inventry_ivars->type;
// Get the field value.
switch (FType_Primitive_ID(type) & FType_PRIMITIVE_ID_MASK) {
case FType_TEXT: {
CharBuf *char_buf
= (CharBuf*)CERTIFY(obj, CHARBUF);
ViewCharBuf *value
= (ViewCharBuf*)inventry_ivars->value;
ViewCB_Assign(value, char_buf);
break;
}
case FType_BLOB: {
ByteBuf *byte_buf
= (ByteBuf*)CERTIFY(obj, BYTEBUF);
ViewByteBuf *value
= (ViewByteBuf*)inventry_ivars->value;
ViewBB_Assign(value, byte_buf);
break;
}
case FType_INT32: {
int32_t int_val = (int32_t)Obj_To_I64(obj);
Integer32* value = (Integer32*)inventry_ivars->value;
Int32_Set_Value(value, int_val);
break;
}
case FType_INT64: {
int64_t int_val = Obj_To_I64(obj);
Integer64* value = (Integer64*)inventry_ivars->value;
Int64_Set_Value(value, int_val);
break;
}
case FType_FLOAT32: {
float float_val = (float)Obj_To_F64(obj);
Float32* value = (Float32*)inventry_ivars->value;
Float32_Set_Value(value, float_val);
break;
}
case FType_FLOAT64: {
double float_val = Obj_To_F64(obj);
Float64* value = (Float64*)inventry_ivars->value;
Float64_Set_Value(value, float_val);
break;
}
default:
THROW(ERR, "Unrecognized type: %o", type);
}
Inverter_Add_Field(self, inventry);
}
}
static void
S_attempt_To_F64(void *context) {
Obj_To_F64((Obj*)context);
}
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;
}
