static void
test_Dump_Load_and_Equals(TestBatch *batch)
{
Query *a_leaf = (Query*)TestUtils_make_leaf_query(NULL, "a");
Query *b_leaf = (Query*)TestUtils_make_leaf_query(NULL, "b");
Query *c_leaf = (Query*)TestUtils_make_leaf_query(NULL, "c");
RequiredOptionalQuery *query = ReqOptQuery_new(a_leaf, b_leaf);
RequiredOptionalQuery *kids_differ = ReqOptQuery_new(a_leaf, c_leaf);
RequiredOptionalQuery *boost_differs = ReqOptQuery_new(a_leaf, b_leaf);
Obj *dump = (Obj*)ReqOptQuery_Dump(query);
RequiredOptionalQuery *clone
= (RequiredOptionalQuery*)Obj_Load(dump, dump);
TEST_FALSE(batch, ReqOptQuery_Equals(query, (Obj*)kids_differ),
"Different kids spoil Equals");
TEST_TRUE(batch, ReqOptQuery_Equals(query, (Obj*)boost_differs),
"Equals with identical boosts");
ReqOptQuery_Set_Boost(boost_differs, 1.5);
TEST_FALSE(batch, ReqOptQuery_Equals(query, (Obj*)boost_differs),
"Different boost spoils Equals");
TEST_TRUE(batch, ReqOptQuery_Equals(query, (Obj*)clone),
"Dump => Load round trip");
DECREF(a_leaf);
DECREF(b_leaf);
DECREF(c_leaf);
DECREF(query);
DECREF(kids_differ);
DECREF(boost_differs);
DECREF(dump);
DECREF(clone);
}
static void
test_Dump_and_Load(TestBatch *batch) {
Hash *hash = Hash_new(0);
Obj *dump;
Hash *loaded;
Hash_Store_Str(hash, "foo", 3,
(Obj*)CB_new_from_trusted_utf8("foo", 3));
dump = (Obj*)Hash_Dump(hash);
loaded = (Hash*)Obj_Load(dump, dump);
TEST_TRUE(batch, Hash_Equals(hash, (Obj*)loaded),
"Dump => Load round trip");
DECREF(dump);
DECREF(loaded);
/* TODO: Fix Hash_Load().
Hash_Store_Str(hash, "_class", 6,
(Obj*)CB_new_from_trusted_utf8("not_a_class", 11));
dump = (Obj*)Hash_Dump(hash);
loaded = (Hash*)Obj_Load(dump, dump);
TEST_TRUE(batch, Hash_Equals(hash, (Obj*)loaded),
"Load still works with _class if it's not a real class");
DECREF(dump);
DECREF(loaded);
*/
DECREF(hash);
}
static void
test_Dump_Load_and_Equals(TestBatchRunner *runner) {
Query *a_leaf = (Query*)TestUtils_make_leaf_query(NULL, "a");
Query *b_leaf = (Query*)TestUtils_make_leaf_query(NULL, "b");
NOTQuery *query = NOTQuery_new(a_leaf);
NOTQuery *kids_differ = NOTQuery_new(b_leaf);
NOTQuery *boost_differs = NOTQuery_new(a_leaf);
Obj *dump = (Obj*)NOTQuery_Dump(query);
NOTQuery *clone = (NOTQuery*)Obj_Load(dump, dump);
TEST_FALSE(runner, NOTQuery_Equals(query, (Obj*)kids_differ),
"Different kids spoil Equals");
TEST_TRUE(runner, NOTQuery_Equals(query, (Obj*)boost_differs),
"Equals with identical boosts");
NOTQuery_Set_Boost(boost_differs, 1.5);
TEST_FALSE(runner, NOTQuery_Equals(query, (Obj*)boost_differs),
"Different boost spoils Equals");
TEST_TRUE(runner, NOTQuery_Equals(query, (Obj*)clone),
"Dump => Load round trip");
DECREF(a_leaf);
DECREF(b_leaf);
DECREF(query);
DECREF(kids_differ);
DECREF(boost_differs);
DECREF(dump);
DECREF(clone);
}
static void
test_Dump_and_Load(TestBatch *batch)
{
TestSchema *schema = TestSchema_new();
Obj *dump = (Obj*)TestSchema_Dump(schema);
TestSchema *loaded = (TestSchema*)Obj_Load(dump, dump);
ASSERT_FALSE(batch, TestSchema_Equals(schema, (Obj*)loaded),
"Dump => Load round trip");
DECREF(schema);
DECREF(dump);
DECREF(loaded);
}
Obj*
Hash_load(Hash *self, Obj *dump) {
Hash *source = (Hash*)CERTIFY(dump, HASH);
CharBuf *class_name = (CharBuf*)Hash_Fetch_Str(source, "_class", 6);
UNUSED_VAR(self);
// Assume that the presence of the "_class" key paired with a valid class
// name indicates the output of a Dump rather than an ordinary Hash. */
if (class_name && CB_Is_A(class_name, CHARBUF)) {
VTable *vtable = VTable_fetch_vtable(class_name);
if (!vtable) {
CharBuf *parent_class = VTable_find_parent_class(class_name);
if (parent_class) {
VTable *parent = VTable_singleton(parent_class, NULL);
vtable = VTable_singleton(class_name, parent);
DECREF(parent_class);
}
else {
// TODO: Fix Hash_Load() so that it works with ordinary hash
// keys named "_class".
THROW(ERR, "Can't find class '%o'", class_name);
}
}
// Dispatch to an alternate Load() method.
if (vtable) {
Obj_Load_t load = METHOD_PTR(vtable, Lucy_Obj_Load);
if (load == Obj_load) {
THROW(ERR, "Abstract method Load() not defined for %o",
VTable_Get_Name(vtable));
}
else if (load != (Obj_Load_t)Hash_load) { // stop inf loop
return VTable_Load_Obj(vtable, dump);
}
}
}
// It's an ordinary Hash.
Hash *loaded = Hash_new(source->size);
Obj *key;
Obj *value;
Hash_Iterate(source);
while (Hash_Next(source, &key, &value)) {
Hash_Store(loaded, key, Obj_Load(value, value));
}
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;
}
VArray*
VA_load(VArray *self, Obj *dump)
{
VArray *source = (VArray*)ASSERT_IS_A(dump, VARRAY);
VArray *loaded = VA_new(source->size);
u32_t i, max;
UNUSED_VAR(self);
for (i = 0, max = source->size; i < max; i++) {
Obj *elem_dump = VA_Fetch(source, i);
if (elem_dump) {
VA_Store(loaded, i, Obj_Load(elem_dump, elem_dump));
}
}
return loaded;
}
static void
test_Dump_Load_and_Equals(TestBatchRunner *runner) {
BlobType *type = BlobType_new(true);
Obj *dump = (Obj*)BlobType_Dump(type);
Obj *clone = Obj_Load(dump, dump);
Obj *another_dump = (Obj*)BlobType_Dump_For_Schema(type);
BlobType *another_clone = BlobType_Load(type, another_dump);
TEST_TRUE(runner, BlobType_Equals(type, (Obj*)clone),
"Dump => Load round trip");
TEST_TRUE(runner, BlobType_Equals(type, (Obj*)another_clone),
"Dump_For_Schema => Load round trip");
DECREF(type);
DECREF(dump);
DECREF(clone);
DECREF(another_dump);
DECREF(another_clone);
}
static void
test_Dump_Load_and_Equals(TestBatch *batch)
{
BlobType *type = BlobType_new();
Obj *dump = (Obj*)BlobType_Dump(type);
Obj *clone = Obj_Load(dump, dump);
Obj *another_dump = (Obj*)BlobType_Dump_For_Schema(type);
BlobType *another_clone = BlobType_load(NULL, another_dump);
ASSERT_TRUE(batch, BlobType_Equals(type, (Obj*)clone),
"Dump => Load round trip");
ASSERT_TRUE(batch, BlobType_Equals(type, (Obj*)another_clone),
"Dump_For_Schema => Load round trip");
DECREF(type);
DECREF(dump);
DECREF(clone);
DECREF(another_dump);
DECREF(another_clone);
}
static void
test_Dump_Load_and_Equals(TestBatch *batch)
{
CaseFolder *case_folder = CaseFolder_new();
CaseFolder *other = CaseFolder_new();
Obj *dump = Obj_Dump(case_folder);
CaseFolder *clone = (CaseFolder*)Obj_Load(other, dump);
ASSERT_TRUE(batch, Obj_Equals(case_folder, (Obj*)other), "Equals");
ASSERT_TRUE(batch, CaseFolder_Dump_Equals(case_folder, (Obj*)dump),
"Dump_Equals");
ASSERT_FALSE(batch, Obj_Equals(case_folder, (Obj*)&EMPTY), "Not Equals");
ASSERT_TRUE(batch, Obj_Equals(case_folder, (Obj*)clone),
"Dump => Load round trip");
DECREF(case_folder);
DECREF(other);
DECREF(dump);
DECREF(clone);
}
static void
S_attempt_Load(void *context) {
Obj_Load((Obj*)context, (Obj*)context);
}
