bool Package::PackDepend(const Package& p) const { bool depends(false); Depend(p); for(std::set<Package>::const_iterator it = m_Package->second.package.begin(); it != m_Package->second.package.end(); ++it) { p.PackDepend(*it); } for(std::set<Object>::const_iterator it = m_Package->second.object.begin(); it != m_Package->second.object.end(); ++it) { if(it->Depend(p)) { //direct dependency depends = true; } } if(depends && Name() != p.Name()) { std::clog << '"' << fs::basename(fs::path(Name()).leaf()) << "\" -> \"" << fs::basename(fs::path(p.Name()).leaf()) << "\";" << std::endl; } return depends; }
int TcpProtocol::mysend(char *data, int len, int peer) { Package *message = new Package(2, peer, data); int m = send(msocket, message->getbuf(), PACKAGE_SIZE, 0); delete message; return m; }
void PackageService::onFinish() { FinishSqliteVFS(); // Turn off all sticky flags - NO MERCY! for (PackageNameMap::iterator itr = _linkedPackages.begin(), end = _linkedPackages.end(); itr != end; ++itr) { itr->second->_stayResident = false; itr->second->_stayForCurrent = false; itr->second->_stayForNext = false; } // And compact so that all packages get disposed compact(); // If Something's remaining, we're in danger! for (PackageNameMap::iterator itr = _linkedPackages.begin(), end = _linkedPackages.end(); itr != end; ++itr) { Package* pack = itr->second; LOG(0, "*** Package '%s': still alive: %d usage, requires:\n", pack->getName().c_str(), pack->getUseCount()); if (pack->getRequiredList().empty()) LOG(0, " <none>\n"); else pack->printDependancy(1); } // Terminate AsyncLoader if (_asyncLoader) { _asyncLoader->Terminate(); } safeDelete(_asyncLoader); }
int general_replica(Package package, struct HostEntity &destination) { package.set_replicano(3); string str = package.SerializeAsString(); // cout << "socket_replica--------1" << endl; // cout << "socket_replica--------before makeConnForReplica sock = "<< destination.sock << endl; int sock = makeConnForReplica(destination); //reusable sockets creation // cout << "socket_replica--------after makeConnForReplica sock = "<< destination.sock << endl; // int sock = makeClientSocket("localhost", 50009, true); // cout << "socket_replica--------2, sock = " << sock << endl; // generalSend(destination.host, destination.port, sock, str.c_str(), 1); // cout << "socket_replica--------2, sock = " << sock << endl; // generalSendTCP(sock, str.c_str()); generalSendTo(destination.host.c_str(), destination.port, sock, str.c_str(), str.size(), TCP); // cout << "socket_replica--------3" << endl; void *buff_return = (void*) malloc(sizeof(int32_t)); // int r = d3_svr_recv(sock, buff_return, sizeof(int32_t), 0, &recv_addr); // int r = generalReveiveTCP(sock, buff_return, sizeof buff_return, 0); struct sockaddr_in recvAddr; // int r =generalReceive(sock, buff_return, sizeof(int32_t), recvAddr, 0, TCP); int r = 0; // cout << "socket_replica--------4" << endl; //connect (int socket, struct sockaddr *addr, size_t length) if (r < 0) { cerr << "general_replica: got bad news from relica: " << r << endl; } }
void SharedMemory::create(const char* name, Package& pkg) { shared_mem_name_ = name; // Create a shared memory object shm = ipc::shared_memory_object(ipc::open_or_create, shared_mem_name_.c_str(), ipc::read_write); // Serialize the package specification (first to a buffer, because we do not know how big it is) io::GrowingBuffer spec; pkg.SerializeSpecification(spec); // Set size: specification size + package size shm.truncate(spec.size() + pkg.size()); // Map the specification region mem_spec_ = ipc::mapped_region(shm, ipc::read_write, 0, spec.size()); // Map the data (pkg) region mem_pkg_ = ipc::mapped_region(shm, ipc::read_write, spec.size(), pkg.size()); // Copy the package specification to the shared memory spec.copyTo(mem_spec_.get_address()); // Map the package to the data address pkg.mapTo(mem_pkg_.get_address()); }
Controller::Controller(int serverSocket, bool displayStati) : AbstractHost(serverSocket), stdinWatcher(NULL), commands(NULL), lastSendPackageID(0), waitingForAck(false), maxCommandNameLength(0) { this->displayStati = displayStati; std::cout<<std::endl; std::cout<<" _ ._ _| _ ._ |_ _ "<<std::endl; std::cout<<" \\/(_)| |(_|(/_| |_)(_)\\/"<<std::endl; std::cout<<" / / "<<std::endl; std::cout<<std::endl; commands = new std::map<std::string, CommandParser*>(); parseSpecFile(configuration->retrieveAsPath("general","net-spec")); if(maxCommandNameLength<4) { maxCommandNameLength = 4; } // for the case where the "help" command is the longest commands->insert(std::make_pair("help", new HelpCommandParser(commands, maxCommandNameLength))); // setup stdin read watcher and readline library rl_attempted_completion_function = &Controller::completionCallback; using_history(); stdinWatcher = new ev::io(); stdinWatcher->set<Controller, &Controller::stdinCallback>(this); Package *initPackage; if(displayStati) { initPackage = constructPackage("connection-management", "id", getNextPackageID().c_str(), "command", "initialize", "client-name", PROJECT_NAME, "client-version", PROJECT_VERSION, "can-display-stati", "", "interactive", "", "can-handle-requests", "", NULL); } else { initPackage = constructPackage("connection-management", "id", getNextPackageID().c_str(), "command", "initialize", "client-name", PROJECT_NAME, "client-version", PROJECT_VERSION, "interactive", "", "can-handle-requests", "", NULL); } lastSendPackageID = initPackage->getID(); waitingForAck = true; sendPackageAndDelete(initPackage); }
int32_t HB_insert(NoVoHT *map, Package &package) { //int opt = package.operation();//opt not be used? string value = package.SerializeAsString(); //int ret = db.set(package.virtualpath(), package_str); //virtualpath as key // cout << "Insert to pmap...value = " << value << endl; string key = package.virtualpath(); // cout<<"key:"<<key<<endl; // cout<<"value:"<<value<<endl; // cout<<"Insert: k-v ready. put..."<<endl; int ret = map->put(key, value); // cout << "end inserting, ret = " << ret << endl; if (ret != 0) { cerr << "insert error: ret = " << ret << endl; return -3; } /* cout << "String insted: " << package_str << endl; */ else return 0; }
void Server::in_ping_ACK(Packet* p) { sf::Uint8 sortingId; *p >> sortingId; Package* pack = connection.getPacketNR(sortingId); if (pack == 0) { cout << "Recieved ACK on a non-used package slot?" << endl; return; } //ping doesnt use event ID so it should be empty if (pack->getEventID() != NET_EVENT_ID::EMPTY) { cout << "Recieved ACK on WRONG package slot?" << endl; return; } unsigned int oldStamp = pack->getTimeStamp(); unsigned int temp = clock(); oldStamp = temp - oldStamp; cout << "Ping Confirmed. RTT: " << oldStamp << endl; connection.successfulPing = true; connection.clearPacketNR(sortingId); }
void RepositoryProfile::addPackage ( const Package &package ) { packages.insert ( package.packageName(), package ); // set the architecture for this package packages[package.packageName() ].setArchitectures ( PackageMetaData::archStringList ( architecures() ) ); updatePackageStatus ( package.packageName() ); }
void MeshGame::initialize() { // Display the gameplay splash screen for at least 2.4 seconds. displaySplash(this, &MeshGame::drawSplash, NULL, 2400L); // Load font _font = Font::create("res/arial40.gpb"); // Load mesh/scene from file Package* pkg = Package::create("res/duck.gpb"); _scene = pkg->loadScene(); SAFE_RELEASE(pkg); // Get the duck node _modelNode = _scene->findNode("duck"); // Bind the material to the model _modelNode->getModel()->setMaterial("res/duck.material"); // Find the light node Node* lightNode = _scene->findNode("directionalLight1"); // Bind the light node's direction into duck's material. _modelNode->getModel()->getMaterial()->getParameter("u_lightDirection")->bindValue(lightNode, &Node::getForwardVectorView); }
const FilePath *Helium::Asset::GetAssetFileSystemPath() { HELIUM_ASSERT( !m_path.IsEmpty() ); FilePath filePath; Asset *pSourceAsset = GetSourceAsset(); if (pSourceAsset) { Package *pPackage = Reflect::SafeCast<Package>( pSourceAsset->GetOwner() ); if ( pPackage ) { PackageLoader *pLoader = pPackage->GetLoader(); HELIUM_ASSERT( pLoader->HasAssetFileState() ); if ( pLoader ) { return &pLoader->GetAssetFileSystemPath( pSourceAsset->GetPath() ); } } } return NULL; }
void* notQueue(void* args) { Worker *worker = (Worker*) args; string *st; Package package; while (ON) { while (notifyq.size() > 0) { pthread_mutex_lock(¬q_lock); if (notifyq.size() > 0) { try { st = notifyq.front(); notifyq.pop(); } catch (exception& e) { cout << "void* notifyq: " << e.what() << endl; exit(1); } } else { pthread_mutex_unlock(¬q_lock); continue; } pthread_mutex_unlock(¬q_lock); package.ParseFromString(*st); delete st; worker->update(package); } } }
int Worker::zht_remove(string key) { /*Package package; package.set_virtualpath(key); package.set_operation(2); string str = package.SerializeAsString(); int index; svrclient.str2Host(str, index);*/ int index = myhash(key.c_str(), svrclient.memberList.size()); if (index != selfIndex) { Package package; package.set_virtualpath(key); package.set_operation(2); string str = package.SerializeAsString(); pthread_mutex_lock(&msg_lock); int ret = svrclient.remove(str); pthread_mutex_unlock(&msg_lock); return ret; } else { int ret = pmap->remove(key); if (ret != 0) { cerr << "DB Error: fail to remove :ret= " << ret << endl; return -2; } else return 0; //succeed. } }
int Worker::zht_insert(string str) { Package package; package.ParseFromString(str); package.set_operation(3); str = package.SerializeAsString(); int index; svrclient.str2Host(str, index); if (index != selfIndex) { //cout << "NOOOOO..index = " << index << endl; pthread_mutex_lock(&msg_lock); int ret = svrclient.insert(str); pthread_mutex_unlock(&msg_lock); return ret; } else { string key = package.virtualpath(); //cout << "key = " << key << endl; //pthread_mutex_lock(&zht_lock); int ret = pmap->put(key, str); //pthread_mutex_unlock(&zht_lock); if (ret != 0) { cerr << "insert error: key = " << key << " ret = " << ret << endl; return -3; } else return 0; } }
OutcomePackage::OutcomePackage(const Package &xPackage) : OutcomPackage() { mHeaderSended = false; mBodySended = false; mFileSended = false; mBody.open(QIODevice::WriteOnly); QDataStream xBodyStream(&mBody); xBodyStream.setVersion(QDataStream::Qt_4_7); xBodyStream<<xPackage.getBodyFields(); mBody.close(); mFile.setFileName(xPackage.getAttachedFile()); QFileInfo xAttachedFileInfo(mFile); mHeader.open(QIODevice::WriteOnly); QDataStream xHeaderStream(&mHeader); xHeaderStream.setVersion(QDataStream::Qt_4_7); xHeaderStream<<qint64(0);//оставляем место для размера заголовка xHeaderStream<<mBody.size(); xHeaderStream<<xAttachedFileInfo.fileName(); xHeaderStream<<mFile.size(); xHeaderStream.device()->seek(0); xHeaderStream<<mHeader.size(); mHeader.close(); mBytesTottal = mHeader.size() + mBody.size() + mFile.size(); mBytesCurrent = 0; }
Package * ReflectorPass::getOrCreateSubPackage(const StringRef & pkgName, Module * module) { PackageMap::iterator it = packages_.find(pkgName); if (it != packages_.end()) { return it->second; } // Try to find a parent package std::string parentPkgName(pkgName); std::string::size_type dot = parentPkgName.rfind('.'); if (dot != parentPkgName.npos) { parentPkgName.erase(dot, parentPkgName.npos); Package * parent = getOrCreateSubPackage(parentPkgName, module); if (parent != NULL) { assert(parent->global() != NULL); GlobalVariable * global = new GlobalVariable(*module, parent->global()->getType()->getContainedType(0), true, GlobalValue::ExternalLinkage, NULL, ".package." + pkgName); Package * p = createPackage(pkgName, global); parent->subpackages().push_back(p); return p; } } return NULL; }
int CSysInfo::GetKernelBitness(void) { static int kernelBitness = -1; if (kernelBitness == -1) { #ifdef TARGET_WINDOWS_STORE Package package = Package::Current(); auto arch = package.Id().Architecture(); switch (arch) { case ProcessorArchitecture::X86: kernelBitness = 32; break; case ProcessorArchitecture::X64: kernelBitness = 64; break; case ProcessorArchitecture::Arm: kernelBitness = 32; break; case ProcessorArchitecture::Unknown: // not sure what to do here. guess 32 for now case ProcessorArchitecture::Neutral: kernelBitness = 32; break; } #elif defined(TARGET_WINDOWS_DESKTOP) SYSTEM_INFO si; GetNativeSystemInfo(&si); if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL || si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM) kernelBitness = 32; else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) kernelBitness = 64; else { BOOL isWow64 = FALSE; if (IsWow64Process(GetCurrentProcess(), &isWow64) && isWow64) // fallback kernelBitness = 64; } #elif defined(TARGET_DARWIN_IOS) // Note: OS X return x86 CPU type without CPU_ARCH_ABI64 flag const NXArchInfo* archInfo = NXGetLocalArchInfo(); if (archInfo) kernelBitness = ((archInfo->cputype & CPU_ARCH_ABI64) != 0) ? 64 : 32; #elif defined(TARGET_POSIX) struct utsname un; if (uname(&un) == 0) { std::string machine(un.machine); if (machine == "x86_64" || machine == "amd64" || machine == "arm64" || machine == "aarch64" || machine == "ppc64" || machine == "ia64" || machine == "mips64" || machine == "s390x") kernelBitness = 64; else kernelBitness = 32; } #endif if (kernelBitness == -1) kernelBitness = 0; // can't detect } return kernelBitness; }
void LoadPackageV1(TiXmlElement *packNode, Category *cat) { const char *type = packNode->Attribute("type"); if(!type) type = ""; const char *name = packNode->Attribute("name"); if(!name) name = ""; const char *desc = packNode->Attribute("desc"); if(!desc) desc = ""; Package *pack = new Package(Package::getType(type), name, cat); unique_ptr<Package> ptr(pack); pack->setDescription(desc); TiXmlElement *node = packNode->FirstChildElement("version"); while(node) { LoadVersionV1(node, pack); node = node->NextSiblingElement("version"); } node = packNode->FirstChildElement("metadata"); if(node) LoadMetadataV1(node, pack->metadata()); if(cat->addPackage(pack)) ptr.release(); }
void NPCPackage::leavePackage () { const b2Vec2& pos = getPos(); Package* package = new Package(_map, pos.x, pos.y); package->createBody(); returnToInitialPosition(); }
void CharacterGame::initialize() { // Load the font. _font = Font::create("res/arial40.gpb"); // Load mesh from file. Package* pkg = Package::create("res/seymour.gpb"); _scene = pkg->loadScene(); SAFE_RELEASE(pkg); _modelNode = _scene->findNode("boyShape"); // Get directional light node. Node* lightNode = _scene->findNode("directionalLight1"); // Load character's material from a .material file. Material* meshMaterial = _modelNode->getModel()->setMaterial("res/seymour.material"); meshMaterial->getParameter("u_lightDirection")->bindValue(lightNode, &Node::getForwardVectorView); // Load character animations clips. loadAnimationClips(); // Get plane. Node* planeNode = _scene->findNode("floor"); // Load planes material from a .material file. Material* planeMaterial = planeNode->getModel()->setMaterial("res/floor.material"); planeMaterial->getParameter("u_lightDirection")->bindValue(lightNode, &Node::getForwardVectorView); }
int32_t HB_insert_cstr_(map<char*, char*> &chmap, Package &package) { string package_str = package.SerializeAsString(); char* value = (char*) malloc(package_str.length() * sizeof(char)); strcpy(value, package_str.c_str()); char* key = (char*) malloc(package.virtualpath().length() * sizeof(char)); // cout << "package.virtualpath().c_str()="<<package.virtualpath().c_str()<<endl; strcpy(key, package.virtualpath().c_str()); // cout <<"after scrcpy, key = "<<key<<", key length = "<< strlen(key) <<endl; // pair<map<char*, char*>::iterator, bool> ret; // ret = chmap.insert(pair<char*, char*>(key, value)); // free(key); // free(value); if (chmap.insert(pair<char*, char*>(key, value)).second == false) { cout << "HB_insert_cstr: insert failed, return -3, element exists, key = " << key << ", value = " << value << endl; free(key); free(value); return -3; } else { cout << " HB_insert_cstr: insert succeeded. key = " << key << ", value = " << chmap.find(key)->second << endl; free(key); free(value); return 0; } }
void Block_manager_parent::init(Ssd* new_ssd, FtlParent* new_ftl, IOScheduler* new_sched, Garbage_Collector* new_gc, Wear_Leveling_Strategy* new_wl, Migrator* new_migrator) { ssd = new_ssd; ftl = new_ftl; scheduler = new_sched; for (uint i = 0; i < SSD_SIZE; i++) { Package* package = ssd->get_package(i); for (uint j = 0; j < PACKAGE_SIZE; j++) { Die* die = package->get_die(j); for (uint t = 0; t < DIE_SIZE; t++) { Plane* plane = die->get_plane(t); for (uint b = 0; b < PLANE_SIZE; b++) { Block* block = plane->get_block(b); free_blocks[i][j][0].push_back(Address(block->get_physical_address(), PAGE)); all_blocks.push_back(block); } } Address pointer = free_blocks[i][j][0].back(); free_block_pointers[i][j] = pointer; Free_Space_Per_LUN_Meter::mark_new_space(pointer, 0); free_blocks[i][j][0].pop_back(); } } wl = new_wl; gc = new_gc; migrator = new_migrator; }
void AbstractHost::processPackage() { Package *constructedPackage = new Package(parseBuffer); if(!constructedPackage->isValid()) { sendPackage(constructAcknowledgementPackage(constructedPackage, "invalid")); delete constructedPackage; } else if(!server->packageRouterInstance()->isAllowed(type, constructedPackage)) { sendPackageAndDelete(constructAcknowledgementPackage(constructedPackage, "forbidden")); delete constructedPackage; } else if(constructedPackage->getType() == ConnectionManagement) { updateNextPackageID(constructedPackage->getID()); handlePackage(constructedPackage); } else if(state == Established) { updateNextPackageID(constructedPackage->getID()); server->packageRouterInstance()->processPackage(this, constructedPackage); } else { sendPackage(constructAcknowledgementPackage(constructedPackage, "invalid")); delete constructedPackage; } parseBuffer.clear(); }
int benchmarkInsert() { double start = 0; double end = 0; start = TimeUtil::getTime_msec(); int errCount = 0; int c = 0; vector<string>::iterator it; for (it = pkgList.begin(); it != pkgList.end(); it++) { c++; string pkg_str = *it; Package pkg; pkg.ParseFromString(pkg_str); int ret = zc.insert(pkg.virtualpath(), pkg_str); if (ret < 0) { errCount++; } } end = TimeUtil::getTime_msec(); char buf[200]; sprintf(buf, "Inserted packages, %d, %d, cost(ms), %f", numOfOps - errCount, numOfOps, end - start); cout << buf << endl; return 0; }
/// Initialize the static type information for the "GameObject" class. /// /// @return Static "GameObject" type. const GameObjectType* GameObject::InitStaticType() { HELIUM_ASSERT( s_Class ); if ( !s_Class->m_Tag ) { // To resolve interdependencies between the GameObject type information and other objects (i.e. the owner // package, its type, etc.), we will create and register all the dependencies here manually as well. Name nameObject( TXT( "GameObject" ) ); Name namePackage( TXT( "Package" ) ); RenameParameters nameParamsObject, nameParamsPackage, nameParamsEngine, nameParamsTypes; nameParamsEngine.name.Set( TXT( "Engine" ) ); nameParamsTypes.name.Set( TXT( "Types" ) ); Package* pTypesPackage = new Package(); HELIUM_ASSERT( pTypesPackage ); HELIUM_VERIFY( RegisterObject( pTypesPackage ) ); HELIUM_VERIFY( pTypesPackage->Rename( nameParamsTypes ) ); GameObjectType::SetTypePackage( pTypesPackage ); nameParamsEngine.spOwner = pTypesPackage; Package* pEnginePackage = new Package(); HELIUM_ASSERT( pEnginePackage ); HELIUM_VERIFY( RegisterObject( pEnginePackage ) ); HELIUM_VERIFY( pEnginePackage->Rename( nameParamsEngine ) ); // Don't set up templates here; they're initialized during type registration. GameObjectPtr spObjectTemplate = Helium::Reflect::AssertCast< GameObject >( s_Class->m_Default ); HELIUM_ASSERT( spObjectTemplate ); PackagePtr spPackageTemplate = new Package(); HELIUM_ASSERT( spPackageTemplate ); // Package flag is set automatically by the Package constructor, but it shouldn't be set for the Package // type template. spPackageTemplate->ClearFlags( FLAG_PACKAGE ); // Initialize and register all types. GameObjectType::Create( Reflect::GetClass< GameObject >(), pEnginePackage, NULL, spObjectTemplate, GameObjectType::FLAG_ABSTRACT ); HELIUM_VERIFY( GameObjectType::Create( Reflect::GetClass< Package >(), pEnginePackage, static_cast< const GameObjectType* >( s_Class->m_Tag ), spPackageTemplate, 0 ) ); // Force initialization of Package so it can report its static type information. HELIUM_VERIFY( Package::InitStaticType() ); } return static_cast< const GameObjectType* >( s_Class->m_Tag ); }
unsigned char* PackageManager::getFileData(const char* fileName, unsigned long* dataSize) { if (m_currentPackage && m_currentPackage->fileExist(fileName)) { unsigned char* buffer = m_currentPackage->getFileData(fileName, dataSize); if (buffer) { return buffer; } } for (std::vector<Package*>::iterator itr = m_allPackages.begin(); itr != m_allPackages.end(); ++itr) { Package* package = *itr; if (!package) { continue; } if (!package->fileExist(fileName)) { continue; } unsigned char* buffer = package->getFileData(fileName, dataSize); if (buffer) { return buffer; } } return NULL; }
void get_map_1(vector<string> &mqueue, uint32_t num_nodes) { //map<uint32_t, NodeList> update_map; //uint32_t num_nodes = svrclient.memberList.size(); for(vector<string>::iterator it = mqueue.begin(); it != mqueue.end(); ++it) { Package package; package.ParseFromString(*it); //cout << "key = " << package.virtualpath() << endl; uint32_t serverid = myhash(package.virtualpath().c_str(), num_nodes); string str(*it); str.append("#"); if(update_map_zht.find(serverid) == update_map_zht.end()) { str.append("$"); NodeList new_list; new_list.push_back(str); update_map_zht.insert(make_pair(serverid, new_list)); } else { NodeList &exist_list = update_map_zht[serverid]; string last_str(exist_list.back()); if((last_str.size() + str.size()) > STRING_THRESHOLD) { str.append("$"); exist_list.push_back(str); } else { exist_list.pop_back(); str.append(last_str); exist_list.push_back(str); } } } //return update_map; }
int ZHTClient::removeMeta(string path) { Package package; package.set_operation(2); // 3 for insert, 1 for look up, 2 for remove package.set_replicano(3); //5: original, 3 not original package.set_virtualpath(path); string str = package.SerializeAsString(); int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data() ,dest.port, sock, str.c_str(), TCP); // cout<<"remove sentSize "<< sentSize <<endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret_buf, sizeof(int32_t), 0); generalReceive(sock, (void*)ret_buf, sizeof(int32_t),recvAddr,0, TCP); // generalSendTCP(sock, str.c_str()); // int32_t* ret = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret, sizeof(int32_t), 0); int ret_1 = *(int32_t*) ret_buf; // cout<<"remove got: "<< ret_1 <<endl; // cout <<"Returned status: "<< *(int32_t*) ret<<endl; // d3_closeConnection(sock); free(ret_buf); return ret_1; }
void UmlDeploymentView::scan_it(int & n) { // compute artifact list const Q3PtrVector<UmlItem> & ch = UmlItem::children(); UmlItem ** v = ch.data(); UmlItem ** const vsup = v + ch.size(); n = 0; for (; v != vsup; v += 1) { if (((*v)->kind() == anArtifact) && ((UmlArtifact *) *v)->is_roundtrip_expected()) { Artifacts.append((UmlArtifact *) *v); n += 1; } } if (n != 0) { Package::set_step(1, n); Package * pk = ((UmlPackage *) Artifacts.first()->parent()->parent())->get_package(); foreach (UmlArtifact *artifact, Artifacts) { pk->reverse(artifact); Progress::tic_it(); }
void WorkerThread::run() { // If you wish to add post-extraction code, do it here. connect( this, SIGNAL( requestDiskspaceError() ), this, SLOT( showDiskspaceError() ) ); // FIXME: Remove Test code for dialog over splash screen. //QThread::currentThread()->sleep( 1 ); //emit requestDiskspaceError(); //return; QDir d( _hiddenDir ); if ( ! QFile::exists( QDir::cleanPath( _hiddenDir + "/version.nfo" ) ) ) { Package* pkg = Package::openEdit( _archFile ); if ( ! checkAvailoableDiskSpace( pkg->requiredDiskSpace() ) ) { delete pkg; return; } connect( pkg, SIGNAL( checkingFile( QString ) ), this, SLOT( checkingFile( QString ) ) ); connect( pkg, SIGNAL( extractingFile( QString ) ), this, SLOT( extractingFile( QString ) ) ); connect( pkg, SIGNAL( skippingFile( QString ) ), this, SLOT( skippingFile( QString ) ) ); connect( pkg, SIGNAL( finishExtracting() ), this, SLOT( finishExtracting() ) ); connect( pkg, SIGNAL( startExtracting( int ) ), this, SLOT( startExtracting( int ) ) ); connect( pkg, SIGNAL( destroyed( QObject* ) ), this, SLOT( packageDeleted() ) ); pkg->extractAll( _hiddenDir ); delete pkg; } else {