EnergySourceContainer EnergySourceHelper::Install (NodeContainer c) const { EnergySourceContainer container; for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i) { Ptr<EnergySource> src = DoInstall (*i); container.Add (src); /* * Check if EnergySourceContainer is already aggregated to target node. If * not, create a new EnergySourceContainer and aggregate it to node. */ Ptr<EnergySourceContainer> EnergySourceContrainerOnNode = (*i)->GetObject<EnergySourceContainer> (); if (EnergySourceContrainerOnNode == NULL) { ObjectFactory fac; fac.SetTypeId ("ns3::EnergySourceContainer"); EnergySourceContrainerOnNode = fac.Create<EnergySourceContainer> (); EnergySourceContrainerOnNode->Add (src); (*i)->AggregateObject (EnergySourceContrainerOnNode); } else { EnergySourceContrainerOnNode->Add (src); // append new EnergySource } } return container; }
void SuifEnv::init() { ObjectFactory* of = new SuifEnvObjectFactory; set_object_factory( of ); of -> init( this ); AggregateMetaClass* suifObjectMC = of->create_object_meta_class( SuifObject::get_class_name(), sizeof( SuifObject ), SuifObject::constructorFunction, (AggregateMetaClass*)of->lookupMetaClass( Object::get_class_name() ) ); PointerMetaClass* pointerToSuifObjectR = of->get_pointer_meta_class( suifObjectMC, false ); suifObjectMC -> add_field_description( "parent", pointerToSuifObjectR, OFFSETOF( SuifObject, parent ) ); // Brick::init_meta_class(this); input_sub_system = new InputSubSystemDefaultImplementation( this ); output_subsystem = new OutputSubSystemDefaultImplementation( this ); cloneSubSystem = new CloneSubSystemDefaultImplementation( this ); _dll_subsystem = new DLLSubSystem( this ); _module_subsystem = new ModuleSubSystem( this ); _error_subsystem = new ErrorSubSystem( this ); _print_subsystem = new PrintSubSystem( this ); }
Object* ObjectManager::createInstance(lua_State* L, const String& className, const String& name) { int luaReference = ScriptManager::getSingleton().getLuaClass(className); if (luaReference == 0) { throw new Ogre::Exception(0, "Lua class '" + className + "' not found", __FILE__); } // põe a classe da pilha lua_getref(L, luaReference); int idx = lua_gettop(L); const String type(LuaHelper::getTableStringField(L, idx, "type")); ObjectFactory* factory = this->getObjectFactory(type); if (factory == NULL) { throw new Ogre::Exception(0, "no factory registered for type '" + type + "'", __FILE__); } Object* obj = factory->createInstance(L, luaReference, name); obj->setClassName(className); // register the object objects[name] = obj; return obj; }
void Display::displayRequirements(CmdParser c) { try { Verbose v(true); Verbose::show("******** REQUIREMENT 4 ********"); Verbose::show("Refer to files Message.h and Message.cpp\n"); Verbose::show("******** REQUIREMENT 6 ********"); Verbose::show("Refer to files Communiation.h and Communication.cpp\n"); Verbose::show("******** REQUIREMENT 8 ********"); Verbose::show("Refer to files Executive.h, Display.h, Display.cpp and Executive.cpp\n"); Verbose::show("******** DEMONSTRATING REQUIREMENT 3, 5 & 7 ********\n"); ObjectFactory of; IRecvr *recv = of.createRecvr(stoi(c.getSelfPortNo())); ISendr *sender = of.createSendr(); IMessage *msg = of.createMessage(); Peer *peer_ = new Peer(sender,recv,msg); peer_->start(); std::cout.flush(); Verbose::show("\n\n Press Enter to Exit."); std::cin.get(); peer_->stop(); } catch (exception ex) { string s = ex.what(); Verbose::show("Exception thrown: "+s); } }
GeometryShader::GeometryShader(const CompiledShaderByteCode& compiledShader, const StreamOutputInitializers& soInitializers) { if (compiledShader.GetStage() != ShaderStage::Null) { assert(compiledShader.GetStage() == ShaderStage::Geometry); auto byteCode = compiledShader.GetByteCode(); intrusive_ptr<ID3D::GeometryShader> underlying; if (soInitializers._outputBufferCount == 0) { underlying = ObjectFactory().CreateGeometryShader(byteCode.first, byteCode.second); } else { assert(soInitializers._outputBufferCount <= D3D11_SO_BUFFER_SLOT_COUNT); D3D11_SO_DECLARATION_ENTRY nativeDeclaration[D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT]; auto delcCount = BuildNativeDeclaration(nativeDeclaration, dimof(nativeDeclaration), soInitializers); ObjectFactory objFactory; auto featureLevel = objFactory.GetUnderlying()->GetFeatureLevel(); underlying = objFactory.CreateGeometryShaderWithStreamOutput( byteCode.first, byteCode.second, nativeDeclaration, delcCount, soInitializers._outputBufferStrides, soInitializers._outputBufferCount, // Note -- "NO_RASTERIZED_STREAM" is only supported on feature level 11. For other feature levels // we must disable the rasterization step some other way (featureLevel>=D3D_FEATURE_LEVEL_11_0)?D3D11_SO_NO_RASTERIZED_STREAM:0); } _underlying = std::move(underlying); } }
bool ObjectManager::frameEnded(const Ogre::FrameEvent& evt) { // Step the world and then synchronise the scene nodes with it, // we could get this to do this automatically, but we // can't be sure of what order the frame listeners will fire in if (mStepper->step(evt.timeSinceLastFrame)) { std::vector<Object*>::iterator eraseIter = eraseQueue.begin(); while (eraseIter != eraseQueue.end()) { ObjectFactory* factory = this->getObjectFactory((*eraseIter)->getTypeName()); assert(factory != NULL); factory->destroyInstance(*eraseIter); eraseIter++; } eraseQueue.clear(); mWorld->synchronise(); std::map<std::string, Object*>::iterator iter = objects.begin(); while (iter != objects.end()) { if (iter->second != NULL) { iter->second->update(evt.timeSinceLastFrame); } iter++; } } return true; }
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 freePlugIn(ExecutableAgent* pPlugin) { ObjectFactory* pFact = Service<ApplicationServices>()->getObjectFactory(); if (pFact != NULL) { pFact->destroyObject(pPlugin, TypeConverter::toString<ExecutableAgent>()); } }
void freeWizard(WizardObject* pWizard) { ObjectFactory* pFact = Service<ApplicationServices>()->getObjectFactory(); if (pFact != NULL) { pFact->destroyObject(pWizard, TypeConverter::toString<WizardObject>()); } }
//----------------------------------------------------------------------------- int ctkAbstractLibraryFactoryTest1(int argc, char * argv [] ) { QApplication app(argc, argv); ObjectFactory factory; factory.registerItems(); return EXIT_SUCCESS; }
ObjectFactory * CreateObjectFactory() { ObjectFactory * factory = new ObjectFactory(); factory->RegisterObject(new WallObject()); factory->RegisterObject(new HeatObject()); factory->RegisterObject(new WindowObject()); factory->RegisterObject(new Probe()); factory->RegisterObject(new StoneWallObject()); return factory; }
void Uninitialize() { ObjectFactory *instance = ObjectFactory::getInstance(); if (instance == NULL) { VMF_EXCEPTION(InternalErrorException, "Can't get Object factory instance"); } std::shared_ptr<IDataSourceFactory> emptyDataSourceFactoryPtr; instance->setDataSourceFactory(emptyDataSourceFactoryPtr); }
PixelShader::PixelShader(const CompiledShaderByteCode& compiledShader) { ObjectFactory objFactory; if (compiledShader.DynamicLinkingEnabled()) _classLinkage = objFactory.CreateClassLinkage(); if (compiledShader.GetStage() != ShaderStage::Null) { assert(compiledShader.GetStage() == ShaderStage::Pixel); auto byteCode = compiledShader.GetByteCode(); _underlying = objFactory.CreatePixelShader(byteCode.first, byteCode.second, _classLinkage.get()); } }
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 Initialize(std::shared_ptr<IDataSourceFactory> &dataSourceFactory) { if (!dataSourceFactory) { VMF_EXCEPTION(IncorrectParamException, "Unable to initialize by empty DataSourceFactory instance"); } ObjectFactory *instance = ObjectFactory::getInstance(); if (instance == NULL) { VMF_EXCEPTION(InternalErrorException, "Can't get Object factory instance"); } instance->setDataSourceFactory(dataSourceFactory); }
WPFCppCliDemo::WPFCppCliDemo() { // set up channel ObjectFactory* pObjFact = new ObjectFactory; pSendr_ = pObjFact->createSendr(); pRecvr_ = pObjFact->createRecvr(); pChann_ = pObjFact->createMockChannel(pSendr_, pRecvr_); pChann_->start(); delete pObjFact; // client's receive thread recvThread = gcnew Thread(gcnew ThreadStart(this, &WPFCppCliDemo::getMessage)); recvThread->Start(); // set event handlers this->Loaded += gcnew System::Windows::RoutedEventHandler(this, &WPFCppCliDemo::OnLoaded); this->Closing += gcnew CancelEventHandler(this, &WPFCppCliDemo::Unloading); hSendButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::sendMessage); hClearButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::clear); hFolderBrowseButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::browseForFolder); hConnectButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::connect); hUploadBrowseButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::uploadBrowseFolder); hUploadFileButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::uploadFile); hDownloadBrowseButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::downloadBrowseFolder); hDownloadFileButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::downloadFile); hTextSearchButton->Click += gcnew RoutedEventHandler(this, &WPFCppCliDemo::textSearch); // set Window properties this->Title = "WPF C++/CLI Demo"; this->Width = 800; this->Height = 600; // attach dock panel to Window this->Content = hDockPanel; hDockPanel->Children->Add(hStatusBar); hDockPanel->SetDock(hStatusBar, Dock::Bottom); hDockPanel->Children->Add(hGrid); // setup Window controls and views setUpTabControl(); setUpStatusBar(); setUpSendMessageView(); setUpConnectionView(); setUpFileUploadView(); setUpFileDownloadView(); setUpTextSearchView(); setUpFileSearchView(); }
GeometryShader::GeometryShader( const ResChar initializer[], const StreamOutputInitializers& soInitializers) { // // We have to append the shader model to the resource name // (if it's not already there) // ResChar temp[MaxPath]; if (!XlFindStringI(initializer, "gs_")) { StringMeldInPlace(temp) << initializer << ":" GS_DefShaderModel; initializer = temp; } intrusive_ptr<ID3D::GeometryShader> underlying; if (soInitializers._outputBufferCount == 0) { const auto& compiledShader = ::Assets::GetAssetComp<CompiledShaderByteCode>(initializer); assert(compiledShader.GetStage() == ShaderStage::Geometry); auto byteCode = compiledShader.GetByteCode(); underlying = ObjectFactory().CreateGeometryShader(byteCode.first, byteCode.second); } else { assert(soInitializers._outputBufferCount < D3D11_SO_BUFFER_SLOT_COUNT); D3D11_SO_DECLARATION_ENTRY nativeDeclaration[D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT]; auto delcCount = BuildNativeDeclaration(nativeDeclaration, dimof(nativeDeclaration), soInitializers); ObjectFactory objFactory; auto featureLevel = objFactory.GetUnderlying()->GetFeatureLevel(); const auto& compiledShader = ::Assets::GetAssetComp<CompiledShaderByteCode>(initializer); assert(compiledShader.GetStage() == ShaderStage::Geometry); auto byteCode = compiledShader.GetByteCode(); underlying = objFactory.CreateGeometryShaderWithStreamOutput( byteCode.first, byteCode.second, nativeDeclaration, delcCount, soInitializers._outputBufferStrides, soInitializers._outputBufferCount, // Note -- "NO_RASTERIZED_STREAM" is only supported on feature level 11. For other feature levels // we must disable the rasterization step some other way (featureLevel>=D3D_FEATURE_LEVEL_11_0)?D3D11_SO_NO_RASTERIZED_STREAM:0); } // (creation successful; we can commit to member now) _underlying = std::move(underlying); }
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 CustomGUIReader::init(std::string &className, int createFunc, int setPropsFunc) { _className = className; _createFunc = createFunc; _setPropsFunc = setPropsFunc; ObjectFactory* factoryCreate = ObjectFactory::getInstance(); ObjectFactory::TInfo t; t._class = className; t._func = CC_CALLBACK_0(CustomGUIReader::createInstance, this); factoryCreate->registerType(t); auto guiReader = GUIReader::getInstance(); auto objMap = guiReader->getParseObjectMap(); (*objMap)[className] = this; auto callbackMap = guiReader->getParseCallBackMap(); (*callbackMap)[className] = parseselector(CustomGUIReader::setCustomProps); }
int main(int argc, const char *argv[]) { using namespace std; using namespace otita::cg; WindowFactory *wFactory = WindowFactory::getInstance(); Window *window = wFactory->createWindowOrDie(640, 480, "Test"); WindowFactory::deleteInstance(); window->setKeyboardDelegate(new MyKeyDelegate); World *world = new World(); ObjectFactory *oFactory = ObjectFactory::getInstance(); // world->addObject( // oFactory->createTriangle( // { // -0.6, -0.4, // 0.6, -0.4, // 0., 0.6, // } // ) // ); world->addObject( oFactory->createCircle( { 0., 0., }, 1. ) ); ObjectFactory::deleteInstance(); window->setWorld(world); while (!window->shouldClose()) { window->clear(); window->draw(); window->swapBuffers(); } delete world; delete window; return 0; }
int main() { ObjectFactory objFact; ISendr* pSendr = objFact.createSendr(); IRecvr* pRecvr = objFact.createRecvr(); IMockChannel* pMockChannel = objFact.createMockChannel(pSendr, pRecvr); pMockChannel->start(); pSendr->postMessage("Hello World"); pSendr->postMessage("CSE687 - Object Oriented Design"); Message msg = pRecvr->getMessage(); std::cout << "\n received message = \"" << msg << "\""; msg = pRecvr->getMessage(); std::cout << "\n received message = \"" << msg << "\""; pSendr->postMessage("stopping"); msg = pRecvr->getMessage(); std::cout << "\n received message = \"" << msg << "\""; pMockChannel->stop(); pSendr->postMessage("quit"); std::cin.get(); }
ExecutableAgent* createPlugIn(const char* pName, int batch) { std::string name(pName == NULL ? "" : pName); ObjectFactory* pFact = Service<ApplicationServices>()->getObjectFactory(); ExecutableAgent* pPlugin = reinterpret_cast<ExecutableAgent*>(pFact->createObject(TypeConverter::toString<ExecutableAgent>())); if (pPlugin == NULL) { setLastError(SIMPLE_WRONG_TYPE); return NULL; } pPlugin->instantiate(name, std::string(), NULL, (batch != 0)); if (pPlugin->getPlugIn() == NULL) { freePlugIn(pPlugin); setLastError(SIMPLE_NOT_FOUND); return NULL; } pPlugin->createProgressDialog(true); pPlugin->setAutoArg(false); setLastError(SIMPLE_NO_ERROR); return pPlugin; }
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 TestObjectFactory::init( SuifEnv* suif ) { _object_factory = suif->get_object_factory(); ObjectFactory *of = _object_factory; MetaClass* intMetaClass = of->lookupMetaClass("int"); assert( intMetaClass ); AggregateMetaClass* meta_SuifObject = of->find_aggregate_meta_class(SuifObject::get_class_name()); AggregateMetaClass* testX = 0; testX = of->create_object_meta_class( TestX::get_class_name(), sizeof( TestX ), TestX::constructorFunction, meta_SuifObject ); PointerMetaClass* owningPointerToTestX = of->get_pointer_meta_class( testX, true ); testX-> add_field_description( "i", intMetaClass, OFFSETOF(TestX,i) ); testX-> add_field_description( "x1", owningPointerToTestX, OFFSETOF(TestX,x1) ); testX-> add_field_description( "x2", owningPointerToTestX, OFFSETOF(TestX,x2) ); STLMetaClass* meta_TestX_vector =of-> get_stl_meta_class("LIST:suif_vector<TestX*>", new STLDescriptor< suif_vector<TestX*> >( owningPointerToTestX ) ); PointerMetaClass* meta_TestX_owner = of->get_pointer_meta_class(meta_TestX_vector,true,true); testX-> add_field_description( "_vector", meta_TestX_owner, OFFSETOF(TestX,_vector) ); testX->add_virtual_field( "int", "i" ); testX->add_virtual_field( "pointers", "x1;x2" ); testX->add_virtual_field( "TestX", "x1/*;x2/*" ); testX->add_virtual_field( "int-indirect", "i;x1/i;x2/i" ); testX->add_virtual_field( "vectorPtr", "_vector" ); testX->add_virtual_field( "vector", "_vector/*" ); testX->add_virtual_field( "vectorContents", "_vector/*/*" ); // ------------ make meta class for TestY ------------- AggregateMetaClass* testY = 0; testY = of->create_object_meta_class( TestY::get_class_name(), sizeof( TestY ), TestY::constructorFunction, testX ); testY-> add_field_description( "x3", owningPointerToTestX, OFFSETOF(TestY,x3) ); testY->add_virtual_field( "int", "i" ); testY->add_virtual_field( "pointers", "^;x3" ); testY->add_virtual_field( "TestX", "^;x3/*" ); }
IndexBuffer::IndexBuffer(const ObjectFactory& factory, const void* data, size_t byteCount) { if (byteCount!=0) { D3D11_BUFFER_DESC desc; desc.ByteWidth = (UINT)byteCount; desc.Usage = D3D11_USAGE_IMMUTABLE; desc.BindFlags = D3D11_BIND_INDEX_BUFFER; desc.CPUAccessFlags = 0; desc.MiscFlags = 0; desc.StructureByteStride = 0; D3D11_SUBRESOURCE_DATA subresData; subresData.pSysMem = data; subresData.SysMemPitch = subresData.SysMemSlicePitch = 0; _underlying = factory.CreateBuffer(&desc, &subresData); } }
ConstantBuffer::ConstantBuffer( const ObjectFactory& factory, const void* data, size_t byteCount, bool immutable) { if (byteCount!=0) { D3D11_BUFFER_DESC desc; desc.ByteWidth = (UINT)byteCount; if (data && immutable) { desc.Usage = D3D11_USAGE_IMMUTABLE; desc.CPUAccessFlags = 0; } else { desc.Usage = D3D11_USAGE_DYNAMIC; desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; } desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; desc.MiscFlags = 0; desc.StructureByteStride = 0; D3D11_SUBRESOURCE_DATA subresData; subresData.pSysMem = data; subresData.SysMemPitch = subresData.SysMemSlicePitch = 0; _underlying = factory.CreateBuffer(&desc, data?(&subresData):nullptr); } }
int main(int argc, char *argv[]) { QCoreApplication app(argc, argv); app.setAttribute(Qt::AA_Use96Dpi, true); // Setup our tests factory object. ObjectFactory testFactory; testFactory.registerClass<TestAwsAbstractClient>(); testFactory.registerClass<TestAwsAbstractCredentials>(); testFactory.registerClass<TestAwsAbstractRequest>(); testFactory.registerClass<TestAwsAbstractResponse>(); testFactory.registerClass<TestAwsAbstractSignature>(); testFactory.registerClass<TestAwsAnonymousCredentials>(); testFactory.registerClass<TestAwsBasicCredentials>(); testFactory.registerClass<TestAwsEndpoint>(); testFactory.registerClass<TestAwsRegion>(); testFactory.registerClass<TestAwsSignatureV0>(); testFactory.registerClass<TestAwsSignatureV1>(); testFactory.registerClass<TestAwsSignatureV2>(); testFactory.registerClass<TestAwsSignatureV3>(); testFactory.registerClass<TestAwsSignatureV4>(); testFactory.registerClass<TestSqsAddPermissionRequest>(); testFactory.registerClass<TestSqsAddPermissionResponse>(); testFactory.registerClass<TestSqsChangeMessageVisibilityBatchRequest>(); testFactory.registerClass<TestSqsChangeMessageVisibilityBatchResponse>(); testFactory.registerClass<TestSqsChangeMessageVisibilityRequest>(); testFactory.registerClass<TestSqsChangeMessageVisibilityResponse>(); testFactory.registerClass<TestSqsClient>(); testFactory.registerClass<TestSqsCreateQueueRequest>(); testFactory.registerClass<TestSqsCreateQueueResponse>(); testFactory.registerClass<TestSqsDeleteMessageBatchRequest>(); testFactory.registerClass<TestSqsDeleteMessageBatchResponse>(); testFactory.registerClass<TestSqsDeleteMessageRequest>(); testFactory.registerClass<TestSqsDeleteMessageResponse>(); testFactory.registerClass<TestSqsDeleteQueueRequest>(); testFactory.registerClass<TestSqsDeleteQueueResponse>(); testFactory.registerClass<TestSqsError>(); testFactory.registerClass<TestSqsGetQueueAttributesRequest>(); testFactory.registerClass<TestSqsGetQueueAttributesResponse>(); testFactory.registerClass<TestSqsGetQueueUrlRequest>(); testFactory.registerClass<TestSqsGetQueueUrlResponse>(); testFactory.registerClass<TestSqsListDeadLetterSourceQueuesRequest>(); testFactory.registerClass<TestSqsListDeadLetterSourceQueuesResponse>(); testFactory.registerClass<TestSqsListQueuesRequest>(); testFactory.registerClass<TestSqsListQueuesResponse>(); testFactory.registerClass<TestSqsPurgeQueueRequest>(); testFactory.registerClass<TestSqsPurgeQueueResponse>(); testFactory.registerClass<TestSqsReceiveMessageRequest>(); testFactory.registerClass<TestSqsReceiveMessageResponse>(); testFactory.registerClass<TestSqsRemovePermissionRequest>(); testFactory.registerClass<TestSqsRemovePermissionResponse>(); testFactory.registerClass<TestSqsRequest>(); testFactory.registerClass<TestSqsResponse>(); testFactory.registerClass<TestSqsSendMessageBatchRequest>(); testFactory.registerClass<TestSqsSendMessageBatchResponse>(); testFactory.registerClass<TestSqsSendMessageRequest>(); testFactory.registerClass<TestSqsSendMessageResponse>(); testFactory.registerClass<TestSqsSetQueueAttributesRequest>(); testFactory.registerClass<TestSqsSetQueueAttributesResponse>(); // If the user has specified a Test* class name, execute that test class only. for (int index = 1; index < argc; ++index) { if (qstrcmp(argv[index], "-classes") == 0) { foreach (const QByteArray &className, testFactory.uniqueKeys()) { fprintf(stdout, "%s\n", className.data()); } return EXIT_SUCCESS; } else if (qstrncmp(argv[index], "Test", 4) == 0) {
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; }
int main(int argc, char** argv) { try { std::map<std::string, std::string> engines; ObjectFactory<std::string, Engine> engineFactory; ENGINE("groovie", "Groovie", Groovie::GroovieEngine); ENGINE("kyra2", "Legend of Kyrandia: Hand of Fate", Kyra::Kyra2Engine); ENGINE("scummv6", "SCUMM v6", Scumm::v6::Scummv6Engine); po::options_description visible("Options"); visible.add_options() ("help,h", "Produce this help message.") ("engine,e", po::value<std::string>(), "Engine the script originates from.") ("list,l", "List the supported engines.") ("dump-disassembly,d", po::value<std::string>()->implicit_value(""), "Dump the disassembly to a file. Leave out filename to output to stdout.") ("dump-graph,g", po::value<std::string>()->implicit_value(""), "Output the control flow graph in dot format to a file. Leave out filename to output to stdout.") ("only-disassembly,D", "Stops after disassembly. Implies -d.") ("only-graph,G", "Stops after control flow graph has been generated. Implies -g.") ("show-unreachable,u", "Show the address and contents of unreachable groups in the script.") ("variant,v", po::value<std::string>()->default_value(""), "Tell the engine that the script is from a specific variant. To see a list of variants supported by a specific engine, use the -h option and the -e option together.") ("no-stack-effect,s", "Leave out the stack effect when printing raw instructions."); po::options_description args(""); args.add(visible).add_options() ("input-file", po::value<std::string>(), "Input file"); po::positional_options_description fileArg; fileArg.add("input-file", -1); po::variables_map vm; try { // FIXME: If specified as the last parameter before the input file name, -d currently requires a filename to specified. -d must be specified earlier than that if outputting to stdout. po::store(po::command_line_parser(argc, argv).options(args).positional(fileArg).run(), vm); po::notify(vm); } catch (std::exception& e) { std::cout << e.what() << std::endl; } if (vm.count("list")) { std::cout << "Available engines:" << "\n"; std::map<std::string, std::string>::iterator it; for (it = engines.begin(); it != engines.end(); it++) std::cout << (*it).first << " " << (*it).second << "\n"; return 0; } if (vm.count("help") || !vm.count("input-file")) { std::cout << "Usage: " << argv[0] << " [option...] file" << "\n"; std::cout << visible << "\n"; if (vm.count("engine") && engines.find(vm["engine"].as<std::string>()) != engines.end()) { Engine *engine = engineFactory.create(vm["engine"].as<std::string>()); std::vector<std::string> variants; engine->getVariants(variants); if (variants.empty()) { std::cout << engines[vm["engine"].as<std::string>()] << " does not use variants.\n"; } else { std::cout << "Supported variants for " << engines[vm["engine"].as<std::string>()] << ":\n"; for (std::vector<std::string>::iterator i = variants.begin(); i != variants.end(); ++i) { std::cout << " " << *i << "\n"; } } delete engine; std::cout << "\n"; } std::cout << "Note: If outputting to stdout, -d or -g must NOT be specified immediately before the input file.\n"; return 1; } if (!vm.count("engine")) { std::cout << "Engine must be specified.\n"; return 2; } else if (engines.find(vm["engine"].as<std::string>()) == engines.end()) { std::cout << "Unknown engine.\n"; return 2; } if (vm.count("no-stack-effect")) { setOutputStackEffect(false); } Engine *engine = engineFactory.create(vm["engine"].as<std::string>()); engine->_variant = vm["variant"].as<std::string>(); std::string inputFile = vm["input-file"].as<std::string>(); // Disassembly InstVec insts; Disassembler *disassembler = engine->getDisassembler(insts); disassembler->open(inputFile.c_str()); disassembler->disassemble(); if (vm.count("dump-disassembly")) { std::streambuf *buf; std::ofstream of; if (vm["dump-disassembly"].as<std::string>() != "") { of.open(vm["dump-disassembly"].as<std::string>().c_str()); buf = of.rdbuf(); } else { buf = std::cout.rdbuf(); } std::ostream out(buf); disassembler->dumpDisassembly(out); } if (!engine->supportsCodeFlow() || vm.count("only-disassembly") || insts.empty()) { if (!vm.count("dump-disassembly")) { disassembler->dumpDisassembly(std::cout); } delete disassembler; delete engine; return 0; } delete disassembler; // Control flow analysis ControlFlow *cf = new ControlFlow(insts, engine); cf->createGroups(); Graph g = cf->analyze(); if (vm.count("dump-graph")) { std::streambuf *buf; std::ofstream of; if (vm["dump-graph"].as<std::string>() != "") { of.open(vm["dump-graph"].as<std::string>().c_str()); buf = of.rdbuf(); } else { buf = std::cout.rdbuf(); } std::ostream out(buf); boost::write_graphviz(out, g, boost::make_label_writer(get(boost::vertex_name, g)), boost::makeArrowheadWriter(get(boost::edge_attribute, g)), GraphProperties(engine, g)); } if (!engine->supportsCodeGen() || vm.count("only-graph")) { if (!vm.count("dump-graph")) { boost::write_graphviz(std::cout, g, boost::make_label_writer(get(boost::vertex_name, g)), boost::makeArrowheadWriter(get(boost::edge_attribute, g)), GraphProperties(engine, g)); } delete cf; delete engine; return 0; } // Post-processing of CFG engine->postCFG(insts, g); // Code generation CodeGenerator *cg = engine->getCodeGenerator(std::cout); cg->generate(g); if (vm.count("show-unreachable")) { std::vector<GroupPtr> unreachable; VertexRange vr = boost::vertices(g); for (VertexIterator v = vr.first; v != vr.second; ++v) { GroupPtr gr = boost::get(boost::vertex_name, g, *v); if (gr->_stackLevel == -1) unreachable.push_back(gr); } if (!unreachable.empty()) { for (size_t i = 0; i < unreachable.size(); i++) { if (i == 0) { if (unreachable.size() == 1) std::cout << boost::format("\n%d unreachable group detected.\n") % unreachable.size(); else std::cout << boost::format("\n%d unreachable groups detected.\n") % unreachable.size(); } std::cout << "Group " << (i + 1) << ":\n"; ConstInstIterator inst = unreachable[i]->_start; do { std::cout << *inst; } while (inst++ != unreachable[i]->_end); std::cout << "----------\n"; } } } // Free memory delete cf; delete cg; delete engine; } catch (UnknownOpcodeException &e) { std::cerr << "ERROR: " << e.what() << "\n"; return 3; } catch (std::exception &e) { std::cerr << "ERROR: " << e.what() << "\n"; return 4; } return 0; }
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; }