void TestObjectSerialization() { ObjectFactory<Serializable> factory; factory.Register("ObjectA", new ObjectCreator<ObjectA, Serializable>()); factory.Register("ObjectB", new ObjectCreator<ObjectB, Serializable>()); factory.Register("ObjectC", new ObjectCreator<ObjectC, Serializable>()); factory.Register("STLVectorObjectIO", new ObjectCreator<STLVectorObjectIO<ObjectA>, Serializable>()); ObjectA a = ObjectA(); a.Set(1, 2, 3, "ObjectA baby"); ObjectB b = ObjectB(); b.Set(6, 7, 8, "ObjectB baby"); ObjectC c = ObjectC(); c.Set(3, 4, 5, "ObjectC baby"); b.data4 = &c; c.data4 = &b; BinaryFileStream stream; stream.StartWrite("test.txt"); a.Save(stream); b.Save(stream); //c.Save(stream, true); stream.SerializeQueue(); stream.Close(); std::vector<Serializable *> load; stream.StartRead("test.txt", factory); //stream.LoadObjects(factory); ObjectA * loaded_a = stream.GetNext<ObjectA*>(); ObjectB * loaded_b = stream.GetNext<ObjectB*>(); ObjectC * loaded_c = stream.GetNext<ObjectC*>(); stream.Close(); loaded_a->Print(); loaded_b->Print(); loaded_c->Print(); delete loaded_a; delete loaded_b; delete loaded_c; }
void TestObjectSerialization3() { ObjectFactory<Serializable> factory; //factory.Register("ObjectA", new ObjectCreator<ObjectA, Serializable>()); factory.Register("ObjectD", new ObjectCreator<ObjectD, Serializable>()); ObjectD d = ObjectD(); d.Set(6, 7, 8, "ObjectD baby"); d.AccessA().Set(1, 2, 3, "ObjectA baby"); BinaryFileStream stream; stream.StartWrite("test3.txt"); d.Save(stream); stream.SerializeQueue(); stream.Close(); std::vector<Serializable *> load; stream.StartRead("test3.txt", factory); ObjectD * loaded = stream.GetNext<ObjectD*>(); stream.Close(); loaded->Print(); delete loaded; }
void TEST_Serialization::LeafJoins() { ObjectFactory<Serializable> factory; factory.Register("ObjectA", new ObjectCreator<ObjectA, Serializable>()); factory.Register("ObjectC", new ObjectCreator<ObjectC, Serializable>()); Stream * file = new BinaryFileStream(); file->StartWrite("test9.txt"); ObjectA * a = new ObjectA(1, 2, 3); ObjectC * c = new ObjectC(4, 5, 6, a); ObjectC * c2 = new ObjectC(7, 8, 9, a); *file << c; *file << c2; *file << a; file->Close(); file->StartRead("test9.txt", factory); ObjectC * load_c; ObjectC * load_c2; ObjectA * load_a; file->Load(load_c); file->Load(load_c2); file->Load(load_a); load_c->a->Print(); load_c2->a->Print(); load_a->Set(12, 12, 12); load_c->a->Print(); load_c2->a->Print(); file->Close(); delete file; delete c; delete c2; delete a; delete load_c; delete load_c2; delete load_a; }
void TEST_Serialization::Inheritance() { ObjectFactory<Serializable> factory; factory.Register("ObjectB", new ObjectCreator<ObjectB, Serializable>()); Stream * file = new BinaryFileStream(); file->StartWrite("test8.txt"); ObjectB * b = new ObjectB(1, 2, 3, 1337); *file << b; file->Close(); file->StartRead("test8.txt", factory); ObjectB * load_b; file->Load(load_b); file->Close(); delete file; delete b; delete load_b; }
void TEST_Serialization::SimpleSaveLoad() { ObjectFactory<Serializable> factory; factory.Register("ObjectA", new ObjectCreator<ObjectA, Serializable>()); ObjectA * save_pointer = new ObjectA(3, 4, 5); int save_int = 5; float save_float = 3.5f; double save_double = 3.5; char save_char = '5'; bool save_bool = true; short save_short = 7; long save_long = 67; long double save_longdouble = 254.344; const char * save_string = "wee"; unsigned int save_uint = 34; unsigned char save_uchar = '3'; unsigned short save_ushort = 232; unsigned long save_ulong = 34 ; ObjectA save_object = ObjectA(6, 7, 8); ObjectA * load_pointer; int load_int = 0; float load_float = 0; double load_double = 0; char load_char = 0; bool load_bool = 0; short load_short = 0; long load_long = 0; long double load_longdouble = 0; char * load_string = 0; unsigned int load_uint = 0; unsigned char load_uchar = 0; unsigned short load_ushort = 0; unsigned long load_ulong = 0; ObjectA load_object; Stream * file = new BinaryFileStream(); file->StartWrite("test6.txt"); file->Save(save_pointer); file->Save(save_int); file->Save(save_float); file->Save(save_double); file->Save(save_char); file->Save(save_bool); file->Save(save_short); file->Save(save_long); file->Save(save_longdouble); file->Save(save_string); file->Save(save_uint); file->Save(save_uchar); file->Save(save_ushort); file->Save(save_ulong); file->Save(save_object); file->Close(); file->StartRead("test6.txt", factory); file->Load(load_pointer); file->Load(load_int); file->Load(load_float); file->Load(load_double); file->Load(load_char); file->Load(load_bool); file->Load(load_short); file->Load(load_long); file->Load(load_longdouble); file->Load(load_string); file->Load(load_uint); file->Load(load_uchar); file->Load(load_ushort); file->Load(load_ulong); file->Load(load_object); file->Close(); delete file; Assert(save_int == load_int, "int equal"); Assert(save_float == load_float, "float not equal"); Assert(save_double == load_double, "double not equal"); Assert(save_char == load_char, "char not equal"); Assert(save_bool == load_bool, "bool not equal"); Assert(save_short == load_short, "short not equal"); Assert(save_long == load_long, "long not equal"); Assert(save_longdouble == load_longdouble, "long not equal"); Assert(strcmp(save_string, load_string) == 0, "strings not equal"); Assert(save_uint == load_uint, "uint not equal"); Assert(save_uchar == load_uchar, "uchar not equal"); Assert(save_ushort == load_ushort, "ushort not equal"); Assert(save_ulong == load_ulong, "ulong not equal"); delete save_pointer; delete load_pointer; delete load_string; }
void TEST_Serialization::SimpleSaveLoad1D() { ObjectFactory<Serializable> factory; factory.Register("ObjectA", new ObjectCreator<ObjectA, Serializable>()); ObjectA * save_pointer = new ObjectA(); save_pointer->Set(1, 2, 3); int * save_int = new int[3]; float * save_float = new float[3]; double * save_double = new double[3]; char * save_char = new char[3]; bool * save_bool = new bool[3]; short * save_short = new short[3]; long * save_long = new long[3]; long double * save_longdouble = new long double[3]; unsigned int * save_uint = new unsigned int[3]; unsigned char * save_uchar = new unsigned char[3]; unsigned short * save_ushort = new unsigned short[3]; unsigned long * save_ulong = new unsigned long[3]; ObjectA * load_pointer = 0; int * load_int = 0; float * load_float = 0; double * load_double = 0; char * load_char = 0; bool * load_bool = 0; short * load_short = 0; long * load_long = 0; long double * load_longdouble = 0; unsigned int * load_uint = 0; unsigned char * load_uchar = 0; unsigned short * load_ushort = 0; unsigned long * load_ulong = 0; Stream * file = new BinaryFileStream(); file->StartWrite("test7.txt"); file->Save(save_pointer); file->Save(save_int, 3); file->Save(save_float, 3); file->Save(save_double, 3); file->Save(save_char, 3); file->Save(save_bool, 3); file->Save(save_short, 3); file->Save(save_long, 3); file->Save(save_longdouble, 3); file->Save(save_uint, 3); file->Save(save_uchar, 3); file->Save(save_ushort, 3); file->Save(save_ulong, 3); file->Close(); file->StartRead("test7.txt", factory); file->Load(load_pointer); file->Load(load_int); file->Load(load_float); file->Load(load_double); file->Load(load_char); file->Load(load_bool); file->Load(load_short); file->Load(load_long); file->Load(load_longdouble); file->Load(load_uint); file->Load(load_uchar); file->Load(load_ushort); file->Load(load_ulong); file->Close(); delete file; delete save_pointer; delete [] save_int; delete [] save_float; delete [] save_double; delete [] save_char; delete [] save_bool; delete [] save_short; delete [] save_long; delete [] save_longdouble; delete [] save_uint; delete [] save_uchar; delete [] save_ushort; delete [] save_ulong; delete load_pointer; delete [] load_int; delete [] load_float; delete [] load_double; delete [] load_char; delete [] load_bool; delete [] load_short; delete [] load_long; delete [] load_longdouble; delete [] load_uint; delete [] load_uchar; delete [] load_ushort; delete [] load_ulong; }
void TestObjectSerialization2() { ObjectFactory<Serializable> factory; factory.Register("ObjectA", new ObjectCreator<ObjectA, Serializable>()); factory.Register("ObjectB", new ObjectCreator<ObjectB, Serializable>()); factory.Register("ObjectC", new ObjectCreator<ObjectC, Serializable>()); factory.Register("STLVectorObjectIO_ObjectA", new ObjectCreator<STLVectorObjectIO<ObjectA>, Serializable>()); factory.Register("STLVectorObjectIO_ObjectB", new ObjectCreator<STLVectorObjectIO<ObjectB>, Serializable>()); factory.Register("STLVectorObjectIO_ObjectC", new ObjectCreator<STLVectorObjectIO<ObjectC>, Serializable>()); factory.Register("STLVectorObjectIO_Serializable", new ObjectCreator<STLVectorObjectIO<Serializable>, Serializable>()); ObjectC a = ObjectC(); a.Set(1, 2, 3, "ObjectA baby"); ObjectC b = ObjectC(); b.Set(4, 5, 6, "ObjectB baby"); ObjectC c = ObjectC(); c.Set(7, 8, 9, "ObjectC baby"); ObjectB d = ObjectB(); d.Set(10, 11, 12, "ObjectD baby"); ObjectB e = ObjectB(); e.Set(13, 14, 15, "ObjectE baby"); ObjectB f = ObjectB(); f.Set(16, 17, 18, "ObjectF baby"); a.data4 = &d; b.data4 = &e; c.data4 = &f; d.data4 = &a; e.data4 = &b; f.data4 = &c; BinaryFileStream stream; std::vector<ObjectC const *> to_serialize_C; to_serialize_C.push_back(&a); to_serialize_C.push_back(&b); to_serialize_C.push_back(&c); STLVectorObjectIO<ObjectC> * proxy_C = new STLVectorObjectIO<ObjectC>(&to_serialize_C, "ObjectC"); std::vector<ObjectB const *> to_serialize_B; to_serialize_B.push_back(&d); to_serialize_B.push_back(&e); to_serialize_B.push_back(&f); STLVectorObjectIO<ObjectB> * proxy_B = new STLVectorObjectIO<ObjectB>(&to_serialize_B, "ObjectB"); std::vector<Serializable *> to_serialize_master; to_serialize_master.push_back(proxy_C); to_serialize_master.push_back(proxy_B); STLVectorObjectIO<Serializable> * proxy_master = new STLVectorObjectIO<Serializable>(&to_serialize_master, "Serializable"); stream.StartWrite("test2.txt"); proxy_master->Save(stream); stream.SerializeQueue(); stream.Close(); std::vector<Serializable *> load; stream.StartRead("test2.txt", factory); STLVectorObjectIO<Serializable> * loaded_vector_proxy_M = stream.GetNext<STLVectorObjectIO<Serializable> *>(); stream.SetEOF(); STLVectorObjectIO<ObjectC> * loaded_vector_proxy_C = loaded_vector_proxy_M->GetAs<STLVectorObjectIO<ObjectC>*>(0); STLVectorObjectIO<ObjectB> * loaded_vector_proxy_B = loaded_vector_proxy_M->GetAs<STLVectorObjectIO<ObjectB>*>(1); for(unsigned int i = 0; i < loaded_vector_proxy_C->Size(); ++i) { (*loaded_vector_proxy_C)[i]->Print(); } for(unsigned int i = 0; i < loaded_vector_proxy_B->Size(); ++i) { (*loaded_vector_proxy_B)[i]->Print(); } loaded_vector_proxy_C->DeleteObjects(); loaded_vector_proxy_B->DeleteObjects(); loaded_vector_proxy_M->DeleteObjects(); delete loaded_vector_proxy_M; }