int main(int argc, char *argv[]) { //for random number generator srand((unsigned)time(NULL)); //preprocessing if(argc != 5){ std::cout<<"No enough arugments\n"; exit(0); } int k, n_threads; double lambda, wall_timer; std::string data_dir, meta_dir, train_dir, test_dir; std::string line; int row, col, train_size, test_size; std::cout<<"----------------------------------------------"<<std::endl; std::cout<<"exec filename: "<<argv[0]<<std::endl; wall_timer = omp_get_wtime(); k = atoi(argv[1]); lambda = atof(argv[2]); n_threads = atoi(argv[3]); data_dir = argv[4]; //set number of threads omp_set_num_threads(n_threads); std::vector<std::string> files(3,""); files.reserve(3); getdir(data_dir, files); meta_dir = data_dir+files[0]; train_dir = data_dir+files[1]; test_dir = data_dir+files[2]; //std::cout<<"Using [rank, lambda, n_threads, directory]->>: "<<"[ "<<k<<", "<<lambda<<", "<<n_threads<<", "<<data_dir<<"* ]\n"; //std::cout<<meta_dir<<" "<<train_dir<<" "<<test_dir<<" "<<"\n"; //read meta file std::ifstream meta_file(meta_dir.c_str()); //get rows and clos std::getline(meta_file, line); std::stringstream meta_ss(line); meta_ss >> row >> col; //get size of train std::getline(meta_file, line); std::stringstream train_ss(line); train_ss >> train_size; //get size of test std::getline(meta_file, line); std::stringstream test_ss(line); test_ss >> test_size; //std::cout<<"row: "<<row<<" col: "<<col<<" train size: "<<train_size<<" test size: "<<test_size<<"\n"; //read from training file, and construct matrix int *Ix = new int[train_size]; int *Jx = new int[train_size]; double *xx = new double[train_size]; int *Iy = new int[train_size]; int *Jy = new int[train_size]; double *yy = new double[train_size]; int *cc = new int[col](); //number of non zeros in each column int *rc = new int[row](); std::ifstream train_file(train_dir.c_str()); std::vector<T> train_list; train_list.reserve(train_size); for(int i=0;i<train_size;i++){ train_file >> Ix[i]; train_file >> Jx[i]; train_file >> xx[i]; Ix[i] = Ix[i] - offset; Jx[i] = Jx[i] - offset; train_list.push_back(T(Ix[i], Jx[i], xx[i])); cc[Jx[i]] = cc[Jx[i]] + 1; rc[Ix[i]]= rc[Ix[i]] + 1; } Eigen::SparseMatrix<double> R(row, col); R.setFromTriplets(train_list.begin(), train_list.end()); Eigen::SparseMatrix<double> R_tsp = R.transpose(); int i_count = 0; for(int i=0;i<R_tsp.outerSize(); i++){ for(Eigen::SparseMatrix<double>::InnerIterator it(R_tsp, i); it; ++it){ Iy[i_count] = it.row(); Jy[i_count] = it.col(); yy[i_count] = it.value(); i_count++; } } //std::cout<<"cc(1)=2->>: "<<cc[1]<<" cc(14)=1->>: "<<cc[14]<<" cc(32)=8->>: "<<cc[32]<<"\n"; //std::cout<<"xx(0)=4->>: "<<xx[0]<<" xx(7)=5->>: "<<xx[7]<<" xx(38)=3->>: "<<xx[7]<<"\n"; //std::cout<<"rc(4)=23->>: "<<rc[4]<<" rc(6)=1->>: "<<rc[6]<<" rc[12]=148->>: "<<rc[12]<<"\n"; //std::cout<<"yy(2)=5->>: "<<yy[2]<<" yy(8)=4->>: "<<yy[8]<<" yy(19)=3->>: "<<yy[19]<<"\n"; //read from testing file, and construct matrix int *Ixt = new int[test_size]; int *Jxt = new int[test_size]; double *xxt = new double[test_size]; std::ifstream test_file(test_dir.c_str()); std::vector<T> test_list; test_list.reserve(test_size); for(int i=0;i<test_size;i++){ test_file >> Ixt[i]; test_file >> Jxt[i]; test_file >> xxt[i]; Ixt[i] = Ixt[i] - offset; Jxt[i] = Jxt[i] - offset; test_list.push_back(T(Ixt[i], Jxt[i], xx[i])); } Eigen::SparseMatrix<double> Rt(row, col); Rt.setFromTriplets(test_list.begin(), test_list.end()); int maxiter = 10; Eigen::MatrixXd U(k, row); Eigen::MatrixXd M(k, col); //generate random numbers within 0 and 1 for U, and M #pragma omp parallel for for(int i=0;i<k;i++){ for(int j=0;j<row;j++){ U(i,j) = (double) rand() / (double) RAND_MAX; } for(int j=0;j<col;j++){ M(i,j) = (double) rand() / (double) RAND_MAX; } } //preprocessing for parallelization int *cci = new int[col]; int *rci = new int[row]; int pre_count; pre_count = 0; for(int i=0;i<col;i++){ cci[i] = pre_count; pre_count = cci[i] + cc[i]; } pre_count = 0; for(int i=0;i<row;i++){ rci[i] = pre_count; pre_count = rci[i] + rc[i]; } std::cout<<"walltime spent on preprocessing data: "<<omp_get_wtime() - wall_timer<<"\n"; //std::cout<<"R_tsp: "<<R_tsp.size()<<" R_tsp(4999, 1825) = 3, the output is: "<<R_tsp.coeffRef(4999,1825)<<"\n"; //for small //std::cout<<"R size: "<<R.size()<<" R(1825, 4999) = 3, the output is: "<<R.coeffRef(1825,4999)<<"\n"; //std::cout<<"Rt size: "<<Rt.size()<<" Rt(1395, 4999) = 3, the output is: "<<Rt.coeffRef(1395,4999)<<"\n"; //for medium //std::cout<<"R size: "<<R.size()<<" R(4750, 3951) is 4, the output is: "<<R.coeffRef(4750,3951)<<"\n"; //std::cout<<"Rt size: "<<Rt.size()<<" R(2128, 3951) is 3, the output is: "<<Rt.coeffRef(2128,3951)<<"\n"; //------------------------------begin processing----------------------------------------------// double accu_sum=0; double rmse_test=0; double rmse_train=0; Eigen::MatrixXd U_tps = U.transpose(); #pragma omp parallel for reduction(+:accu_sum) for(int i=0;i<train_size;i++){ accu_sum += pow(U_tps.row(Ix[i])*M.col(Jx[i]) - xx[i], 2); } rmse_train = sqrt(accu_sum/train_size); accu_sum = 0; #pragma omp parallel for reduction(+:accu_sum) for(int i=0;i<test_size;i++){ accu_sum += pow(U_tps.row(Ixt[i])*M.col(Jxt[i]) - xxt[i], 2); } rmse_test = sqrt(accu_sum/test_size); Eigen::MatrixXd iden = Eigen::MatrixXd::Identity(k,k); std::cout<<"start with rmse on train: "<< rmse_train <<" rmse on test: "<< rmse_test << " n_threads: "<<n_threads<<std::endl; double total_timer, end_timer; for(int t=0;t<maxiter;t++){ printf("iter: %d\n",t+1); printf("Minimize M while fixing U ..."); wall_timer = omp_get_wtime(); //minimize M while fixing U #pragma omp parallel for schedule(dynamic, 1) for(int i=0;i<col;i++){ if( cc[i]>0 ){ //construct subU, and subR Eigen::MatrixXd subU(k, cc[i]); Eigen::VectorXd subR(cc[i]); int j=cci[i]; for(int l=0; l<cc[i];l++){ subU.col(l) = U.col(Ix[j+l]); subR[l] = xx[j+l]; } M.col(i) = (lambda*iden+subU*subU.transpose()).llt().solve((subU*subR)); }else{ M.col(i) = Eigen::VectorXd::Zero(k); } } end_timer = omp_get_wtime(); total_timer += end_timer-wall_timer; printf("%0.2f seconds\n", end_timer - wall_timer); printf("Minimize U whilt fixing M ..."); wall_timer = omp_get_wtime(); //minimize U while fixing M #pragma omp parallel for schedule(dynamic, 1) for(int i=0;i<row;i++){ if( rc[i] > 0){ //construct subM, and subR Eigen::MatrixXd subM(k, rc[i]); Eigen::VectorXd subR(rc[i]); int j=rci[i]; for(int l=0;l<rc[i];l++){ subM.col(l) = M.col(Iy[j+l]); subR[l] = yy[j+l]; } U.col(i) = (lambda*iden+subM*subM.transpose()).llt().solve((subM*subR)); }else{ U.col(i) = Eigen::VectorXd::Zero(k); } } end_timer = omp_get_wtime(); total_timer += end_timer-wall_timer; printf("%0.2f seconds\n", end_timer - wall_timer); Eigen::MatrixXd U_tps = U.transpose(); accu_sum = 0; #pragma omp parallel for reduction(+:accu_sum) for(int i=0;i<train_size;i++){ accu_sum += pow(U_tps.row(Ix[i])*M.col(Jx[i]) - xx[i], 2); } rmse_train = sqrt(accu_sum/train_size); accu_sum = 0; #pragma omp parallel for reduction(+:accu_sum) for(int i=0;i<test_size;i++){ accu_sum += pow(U_tps.row(Ixt[i])*M.col(Jxt[i]) - xxt[i], 2); } rmse_test = sqrt(accu_sum/test_size); printf("rmse on train: %0.6f, rmse on test: %0.6f\n",rmse_train, rmse_test); } printf("total running time: %0.2f\n",total_timer); //free variables delete[] Ix; delete[] Jx; delete[] xx; delete[] Iy; delete[] Jy; delete[] yy; delete[] Ixt; delete[] Jxt; delete[] xxt; delete[] rci; delete[] cci; }
void ReadCadmould::openFiles() { retOpenFile = 0; // cout << "p_byteswap: "<<p_byteswap->getValue()<<endl; /// shut down all old if exist delete d_grid; for (int i = 0; i < d_numDataSets; i++) { delete d_data[i]; d_data[i] = NULL; } d_numDataSets = 0; // the filename parameter const char *selFile = p_filename->getValue(); // make sure we can work with the file name char basename[MAXPATHLEN + 1], filename[MAXPATHLEN + 1]; //// Open mesh file: clip off last char if old style strncpy(basename, selFile, MAXPATHLEN); basename[MAXPATHLEN] = '\0'; setCaseType(basename); if (d_type != TYPE_CAR) { basename[strlen(basename) - 1] = '\0'; } d_grid = new CadmouldGrid(basename); int gridState = -1; int gridNoVert = -1; if (d_grid) gridState = d_grid->getState(); if (gridState != 0) { if (gridState < 0) sendError("Could not read %s as Cadmould mesh", basename); else sendError("Could not read %s as Cadmould mesh: %s", basename, strerror(gridState)); delete d_grid; d_grid = NULL; } else { gridNoVert = d_grid->getNumVert(); } // from now on: base is Fuellbild file ( case+Kenner ) strncpy(basename, selFile, MAXPATHLEN); basename[MAXPATHLEN] = '\0'; if (d_type == TYPE_CAR) { char car_base[MAXPATHLEN]; strcpy(car_base, basename); *(strstr(car_base, ".cfe")) = '\0'; CarFiles files(car_base); for (int grp_nb = 0; grp_nb < files.numGroups(); grp_nb++) { MultiCarData *data = new MultiCarData(files, grp_nb, byteswap_); if (data) { if (data->getState() == 0) { d_data[d_numDataSets] = data; d_numDataSets++; } else { delete data; } } } } else if (d_type == TYPE_STD) { // check, whether we have a E0 file = Rheologie-File { sprintf(filename, "%sE0", basename); static const char *labelsE0[] = { "Fliessfront-Temperatur", "Fliessfront-Druckbedarf", "Fliessfront-Schubspannung", "Fliessfront-Geschwindigkeit" }; FuellDruckData *data = new FuellDruckData(filename, 4, labelsE0, byteswap_); if (data) { if (data->getState() == 0) { d_data[d_numDataSets] = data; d_numDataSets++; } else delete data; } } // check, whether we have E## files = Zwischenergebnisse { sprintf(filename, "%sE", basename); static const char *labelsExx[] = { "Momentan-Temperatur(t)", "Momentan-Druck(t)", "Momentan-Schubspannung(t)", "Momentan-Geschwindigkeit(t)" }; MultiFuellData *data = new MultiFuellData(filename, 4, labelsExx, byteswap_); if (data) { if (data->getState() == 0) { d_data[d_numDataSets] = data; d_numDataSets++; } else delete data; } } // check, whether we have S## files = Schichtergebnisse { sprintf(filename, "%sS", basename); static const char *labelsSxx[] = { "Randschichtddicke(t)" }; MultiFuellData *data = new MultiFuellData(filename, 1, labelsSxx, byteswap_); if (data) { if (data->getState() == 0) { d_data[d_numDataSets] = data; d_numDataSets++; } else delete data; } } //////// other data sets here ... // filling process, file: basename // data: Fuellstand, connect, fill_time { static const char *labelsFilling[] = { "Fuellstand", "Connect", "fill_time" }; static const CadmouldData::FieldType fieldType[] = { CadmouldData::SCALAR_FLOAT, CadmouldData::SCALAR_INT, CadmouldData::SCALAR_FLOAT }; FillingData *data = new FillingData(basename, 3, labelsFilling, fieldType, byteswap_); fillTimeDataSets = -1; fillChoice = 0; if (data) { if (data->getState() == 0) { fillTimeDataSets = d_numDataSets; fillField = 0; d_data[d_numDataSets] = data; d_numDataSets++; if (gridNoVert != -1 && data->numVert() != ((gridNoVert + 3) / 4) * 4) { retOpenFile = -1; sendWarning("Number of nodes from mesh and fill-data does not match. Trying with the contrary byte-swapping option"); } } else delete data; } } // check, whether we have .car files { CarFiles files(basename); for (int i = 0; i < files.numFiles(); i++) { CarData *data = new CarData(files.get(i), byteswap_); if (data) { if (data->getState() == 0) { d_data[d_numDataSets] = data; d_numDataSets++; } else delete data; } } } } if (retOpenFile == 0) { // create the labels for the choices int numLabels = 1; // the "---" label for (int i = 0; i < d_numDataSets; i++) numLabels += d_data[i]->numFields(); const char **labels = new const char *[numLabels]; labels[0] = "---"; int labelNo = 1; for (int i = 0; i < d_numDataSets; i++) { for (int j = 0; j < d_data[i]->numFields(); j++) { labels[labelNo] = d_data[i]->getName(j); if (fillChoice == 0 && strstr(labels[labelNo], "Fuellzeit") != NULL) { fillChoice = labelNo; } else if (fillChoice == 0 && strstr(labels[labelNo], "llzeit")) { fillChoice = labelNo; } // +1 because choices return 1 for 1st label ([0]) dataLoc[labelNo].datasetNo = i; dataLoc[labelNo].fieldNo = j; labelNo++; } } // attach to all choices, keep old values if valid for (int i = 0; i < NUM_PORTS; i++) { int oldVal = p_choice[i]->getValue(); //if (oldVal<d_numDataSets-2) if (oldVal < numLabels) p_choice[i]->setValue(numLabels, labels, oldVal); else p_choice[i]->setValue(numLabels, labels, 0); } labels[0] = "automatic"; p_fillField->setValue(numLabels, labels, fillChoice); } }
void ShipType::Init() { static bool isInitted = false; if (isInitted) return; isInitted = true; // load all ship definitions namespace fs = FileSystem; for (fs::FileEnumerator files(fs::gameDataFiles, "ships", fs::FileEnumerator::Recurse); !files.Finished(); files.Next()) { const fs::FileInfo &info = files.Current(); if (ends_with_ci(info.GetPath(), ".json")) { const std::string id(info.GetName().substr(0, info.GetName().size()-5)); ShipType st = ShipType(id, info.GetPath()); types.insert(std::make_pair(st.id, st)); // assign the names to the various lists switch( st.tag ) { case TAG_SHIP: player_ships.push_back(id); break; case TAG_STATIC_SHIP: static_ships.push_back(id); break; case TAG_MISSILE: missile_ships.push_back(id); break; break; case TAG_NONE: default: break; } } } #if ALLOW_LUA_SHIP_DEF lua_State *l = luaL_newstate(); LUA_DEBUG_START(l); luaL_requiref(l, "_G", &luaopen_base, 1); luaL_requiref(l, LUA_DBLIBNAME, &luaopen_debug, 1); luaL_requiref(l, LUA_MATHLIBNAME, &luaopen_math, 1); lua_pop(l, 3); LuaConstants::Register(l); LuaVector::Register(l); LUA_DEBUG_CHECK(l, 0); // provide shortcut vector constructor: v = vector.new lua_getglobal(l, LuaVector::LibName); lua_getfield(l, -1, "new"); assert(lua_iscfunction(l, -1)); lua_setglobal(l, "v"); lua_pop(l, 1); // pop the vector library table LUA_DEBUG_CHECK(l, 0); // register ship definition functions lua_register(l, "define_ship", define_ship); lua_register(l, "define_static_ship", define_static_ship); lua_register(l, "define_missile", define_missile); LUA_DEBUG_CHECK(l, 0); // load all ship definitions namespace fs = FileSystem; for (fs::FileEnumerator files(fs::gameDataFiles, "ships", fs::FileEnumerator::Recurse); !files.Finished(); files.Next()) { const fs::FileInfo &info = files.Current(); if (ends_with_ci(info.GetPath(), ".lua")) { const std::string name = info.GetName(); s_currentShipFile = name.substr(0, name.size() - 4); if (ShipType::types.find(s_currentShipFile) == ShipType::types.end()) { pi_lua_dofile(l, info.GetPath()); s_currentShipFile.clear(); } } } LUA_DEBUG_END(l, 0); lua_close(l); #endif //remove unbuyable ships from player ship list ShipType::player_ships.erase( std::remove_if(ShipType::player_ships.begin(), ShipType::player_ships.end(), ShipIsUnbuyable), ShipType::player_ships.end()); if (ShipType::player_ships.empty()) Error("No playable ships have been defined! The game cannot run."); }
int main() { if (1) { //testSequenceSummary(); //testGene(); testGenome("/Users/roxasoath1/Desktop/RibModelDevScripts/RibModelDev/data/UnitTestingData"); /* Genome genome; genome.readRFPFile("/Users/roxasoath1/Desktop/RibModelDevScripts/RibModelDev/data/rfp/rfp.counts.by.codon.and.gene.GSE63789.wt.csv"); std::vector<unsigned> geneAssignment(genome.getGenomeSize()); for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = 0u; } unsigned numMixtures = 1; std::vector<double> sphi_init(numMixtures, 2); std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; RFPParameter tmp(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, "allUnique"); std::vector<std::string> files; files.push_back("/Users/roxasoath1/Desktop/TONEWTON/RFPAlphaValues.csv"); tmp.initMutationSelectionCategories(files, 1, RFPParameter::alp); files[0] = "/Users/roxasoath1/Desktop/TONEWTON/RFPLambdaPrimeValues.csv"; tmp.initMutationSelectionCategories(files, 1, RFPParameter::lmPri); std::vector<double> phi = tmp.readPhiValues("/Users/roxasoath1/Desktop/TONEWTON/RFPPsiValues.csv"); tmp.InitializeSynthesisRate(phi); RFPModel model; model.setParameter(tmp); std::cout <<"init done\n"; model.simulateGenome(genome); std::cout <<"writing file\n"; genome.writeRFPFile("/Users/roxasoath1/Desktop/RibModelDevScripts/RibModelDev/data/rfp/simulatedRFPData.csv", true); */ exit(1); } std::string modelToRun = "RFP"; //can also be ROC or FONSE bool withPhi = false; bool fromRestart = true; unsigned numMixtures = 1; std::cout << "Initializing MCMCAlgorithm object---------------" << std::endl; int samples = 10; int thinning = 10; int useSamples = 100; std::cout << "\t# Samples: " << samples << "\n"; std::cout << "\tThinning: " << thinning << "\n"; std::cout << "\t # Samples used: " << useSamples << "\n"; MCMCAlgorithm mcmc = MCMCAlgorithm(samples, thinning, 10, true, true, true); mcmc.setRestartFileSettings("RestartFile.txt", 20, true); std::cout << "Done!-------------------------------\n\n\n"; if (modelToRun == "ROC") { std::cout << "Initializing Genome object--------------------------" << std::endl; Genome genome; genome.readFasta("/Users/roxasoath1/Desktop/RibModelDevScripts/RibModelDev/data/twoMixtures/simulatedAllUniqueR.fasta"); if (withPhi) { genome.readObservedPhiValues("/Users/roxasoath1/Desktop/RibModelFramework/ribModel/data/simulatedAllUniqueR_phi.csv", false); } std::cout << "Done!-------------------------------\n\n\n"; std::cout << "Initializing shared parameter variables---------------\n"; std::vector<unsigned> geneAssignment(genome.getGenomeSize()); std::vector<double> sphi_init(numMixtures, 1); if (numMixtures == 1) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = 0u; } } else if (numMixtures == 3) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { if (i < 961) geneAssignment[i] = 0u; else if (i < 1418) geneAssignment[i] = 1u; else geneAssignment[i] = 0u; } } std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; std::cout << "Done!------------------------\n\n\n"; std::cout << "Initializing ROCParameter object--------------------\n" << std::endl; ROCParameter parameter; if (fromRestart) { ROCParameter tmp("/Users/roxasoath1/Desktop/RibModelFramework/DevRscripts/10restartFile.rst"); parameter = tmp; } else { std::string mixDef = ROCParameter::allUnique; ROCParameter tmp(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, mixDef); for (unsigned i = 0u; i < numMixtures; i++) { unsigned selectionCategry = tmp.getSelectionCategory(i); std::cout << "Sphi_init for selection category " << selectionCategry << ": " << sphi_init[selectionCategry] << std::endl; } std::cout << "\t# mixtures: " << numMixtures << "\n"; std::cout << "\tmixture definition: " << mixDef << "\n"; std::vector<std::string> files(2); files[0] = std::string("F:/GitHub/RibModelDev/data/twoMixtures/simulated_mutation0.csv"); files[1] = std::string("F:/GitHub/RibModelDev/data/twoMixtures/simulated_mutation1.csv"); tmp.initMutationCategories(files, tmp.getNumMutationCategories()); files[0] = std::string("F:/GitHub/RibModelDev/data/twoMixtures/simulated_selection0.csv"); files[1] = std::string("F:/GitHub/RibModelDev/data/twoMixtures/simulated_selection1.csv"); tmp.initSelectionCategories(files, tmp.getNumSelectionCategories()); tmp.InitializeSynthesisRate(genome, sphi_init[0]); //std::vector<double> phiVals = parameter.readPhiValues("/home/clandere/CodonUsageBias/RibosomeModel/RibModelFramework/ribModel/data/Skluyveri_ChrA_ChrCleft_phi_est.csv"); //parameter.InitializeSynthesisRate(phiVals); } std::cout << "Done!--------------------------------\n\n\n" << std::endl; std::cout << "Initializing ROCModel object--------------------------\n"; ROCModel model; model.setParameter(parameter); std::cout << "Done!----------------------------------\n\n\n" << std::endl; std::cout << "Running MCMC.............\n" << std::endl; mcmc.run(genome, model, 1, 0); std::cout << "Done!----------------------------------\n\n\n" << std::endl; } //END OF ROC else if (modelToRun == "RFP") { std::cout << "Initializing Genome object--------------------------" << std::endl; Genome genome; genome.readRFPFile("/Users/roxasoath1/Desktop/RibModelDevScripts/RibModelDev/data/rfp/rfp.counts.by.codon.and.gene.GSE63789.wt.csv"); std::cout << "Done!-------------------------------\n\n\n"; std::cout << "Initializing shared parameter variables---------------\n"; std::vector<unsigned> geneAssignment(genome.getGenomeSize()); std::vector<double> sphi_init(numMixtures, 1); if (numMixtures == 1) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = 0u; } } else if (numMixtures == 3) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { if (i < 961) geneAssignment[i] = 0u; else if (i < 1418) geneAssignment[i] = 1u; else geneAssignment[i] = 0u; } } std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; std::cout << "Done!------------------------\n\n\n"; std::cout << "Initializing RFPParameter object--------------------\n" << std::endl; RFPParameter parameter; if (fromRestart) { RFPParameter tmp("/Users/roxasoath1/Desktop/RibModelFramework/10_restartFile.rst"); parameter = tmp; } else { std::string mixDef = Parameter::allUnique; RFPParameter tmp(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, mixDef); for (unsigned i = 0u; i < numMixtures; i++) { unsigned selectionCategry = tmp.getSelectionCategory(i); std::cout << "Sphi_init for selection category " << selectionCategry << ": " << sphi_init[selectionCategry] << std::endl; } std::cout << "\t# mixtures: " << numMixtures << "\n"; std::cout << "\tmixture definition: " << mixDef << "\n"; tmp.InitializeSynthesisRate(genome, sphi_init[0]); parameter = tmp; } std::cout << "Done!--------------------------------\n\n\n" << std::endl; std::cout << "Initializing RFPModel object--------------------------\n"; RFPModel model; model.setParameter(parameter); std::cout << "Done!----------------------------------\n\n\n" << std::endl; std::cout << "Running MCMC.............\n" << std::endl; mcmc.run(genome, model, 1, 0); std::cout << "Done!----------------------------------\n\n\n" << std::endl; } //END OF RFP else if (modelToRun == "FONSE") { std::cout << "initialize Genome object--------------------------" << std::endl; Genome genome; genome.readFasta("/Users/roxasoath1/Desktop/RibModelDevScripts/RibModelDev/data/FONSE/genome_2000.fasta"); std::cout << "Done!-------------------------------\n\n\n"; std::cout << "Initializing shared parameter variables---------------\n"; std::vector<unsigned> geneAssignment(genome.getGenomeSize()); std::vector<double> sphi_init(numMixtures, 1); if (numMixtures == 1) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = 0u; } } else if (numMixtures == 3) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { if (i < 961) geneAssignment[i] = 0u; else if (i < 1418) geneAssignment[i] = 1u; else geneAssignment[i] = 0u; } } std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; std::cout << "Done!------------------------\n\n\n"; FONSEParameter parameter; std::cout << "initialize Parameter object" << std::endl; if (fromRestart) { FONSEParameter tmp("/Users/roxasoath1/Desktop/RibModelDevScripts/RibModelDev/DevRscripts/10restartFile.rst"); parameter = tmp; } else { std::string mixDef = ROCParameter::allUnique; FONSEParameter tmp(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, mixDef); for (unsigned i = 0u; i < numMixtures; i++) { unsigned selectionCategry = tmp.getSelectionCategory(i); std::cout << "Sphi_init for selection category " << selectionCategry << ": " << sphi_init[selectionCategry] << std::endl; } std::cout << "\t# mixtures: " << numMixtures << "\n"; std::cout << "\tmixture definition: " << mixDef << "\n"; std::vector<std::string> files(1); files[0] = std::string( "/Users/roxasoath1/Desktop/RibModelDevScripts/RibModelDev/data/FONSE/genome_2000.mutation.csv"); tmp.initMutationCategories(files, tmp.getNumMutationCategories()); tmp.InitializeSynthesisRate(genome, sphi_init[0]); //std::vector<double> phiVals = parameter.readPhiValues("/home/clandere/CodonUsageBias/RibosomeModel/RibModelFramework/ribModel/data/Skluyveri_ChrA_ChrCleft_phi_est.csv"); //parameter.InitializeSynthesisRate(phiVals); parameter = tmp; std::cout << "done initialize Parameter object" << std::endl; } std::cout << "Initializing Model object\n"; FONSEModel model; model.setParameter(parameter); std::cout << "starting MCMC for ROC" << std::endl; mcmc.run(genome, model, 4, 0); std::cout << std::endl << "Finished MCMC for ROC" << std::endl; } }
int main() { std::string pathBegin = "/Users/hollisbui/"; unsigned numMixtures = 1; std::vector<double> sphi_init(numMixtures, 2); std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; // SIMULATE GENOME: RFP /* Genome genome; //genome.readFasta(pathBegin + "HollisTestingData/s288c.genome.fasta"); genome.readRFPFile(pathBegin + "HollisTestingData/rfp.counts.by.codon.and.gene.GSE63789.wt.csv"); std::vector<unsigned> geneAssignment(genome.getGenomeSize()); for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = 0u; } RFPParameter parameter(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, "allUnique"); std::vector<std::string> files; files.push_back(pathBegin + "HollisTestingData/RFPAlphaValues.csv"); parameter.initMutationSelectionCategories(files, 1, RFPParameter::alp); files[0] = pathBegin + "HollisTestingData/RFPLambdaPrimeValues.csv"; parameter.initMutationSelectionCategories(files, 1, RFPParameter::lmPri); std::vector<double> phi = parameter.readPhiValues(pathBegin + "HollisTestingData/RFPPhiValues.csv"); //std::vector<double> phi = tmp.readPhiValues("/Users/roxasoath1/Desktop/TONEWTON/RFPPsiValues.csv"); parameter.InitializeSynthesisRate(phi); RFPModel model; model.setParameter(parameter); model.simulateGenome(genome); genome.writeRFPFile(pathBegin + "HollisTestingOut/HollisSimulatedGenome2.csv", true); exit(1); */ // UNIT TESTING //testUtility(); //testSequenceSummary(); //testGene(); //testGenome(pathBegin + "RibModelFramework/tests/testthat/UnitTestingData"); //testCovarianceMatrix(); testParameter(); //testParameterWithFile(pathBegin + "HollisFile.txt"); //testTrace(); //testRFPParameter(); //testMCMCAlgorithm(); exit(0); std::string modelToRun = "RFP"; //can be RFP, ROC or FONSE bool withPhi = false; bool fromRestart = false; my_print("Initializing MCMCAlgorithm object---------------\n"); unsigned samples = 10; unsigned thinning = 10; int useSamples = 100; my_print("\t# Samples: %\n", samples); my_print("\tThinning: %\n", thinning); my_print("\t # Samples used: %\n", useSamples); MCMCAlgorithm mcmc = MCMCAlgorithm(samples, thinning, 10, true, true, true); //mcmc.setRestartFileSettings(pathBegin + "RestartFile.txt", 20, true); my_print("Done!-------------------------------\n\n\n"); if (modelToRun == "ROC") { my_print("Initializing Genome object--------------------------\n"); Genome genome; genome.readFasta(pathBegin + "RibModelDev/data/twoMixtures/simulatedAllUniqueR.fasta"); if (withPhi) { genome.readObservedPhiValues(pathBegin + "RibModelFramework/ribModel/data/simulatedAllUniqueR_phi.csv", false); } my_print("Done!-------------------------------\n\n\n"); my_print("Initializing shared parameter variables---------------\n"); std::vector<unsigned> geneAssignment(genome.getGenomeSize()); std::vector<double> sphi_init(numMixtures, 1); if (numMixtures == 1) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = 0u; } } else if (numMixtures == 3) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { if (i < 961) geneAssignment[i] = 0u; else if (i < 1418) geneAssignment[i] = 1u; else geneAssignment[i] = 0u; } } std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; my_print("Done!------------------------\n\n\n"); my_print("Initializing ROCParameter object--------------------\n\n"); ROCParameter parameter; if (fromRestart) { ROCParameter tmp(pathBegin + "RibModelFramework/DevRscripts/10restartFile.rst"); parameter = tmp; } else { std::string mixDef = ROCParameter::allUnique; ROCParameter tmp(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, mixDef); for (unsigned i = 0u; i < numMixtures; i++) { unsigned selectionCategry = tmp.getSelectionCategory(i); my_print("Sphi_init for selection category %: %\n", selectionCategry, sphi_init[selectionCategry]); } my_print("\t# mixtures: %\n", numMixtures); my_print("\tmixture definition: %\n", mixDef); std::vector<std::string> files(2); files[0] = std::string(pathBegin + "RibModelDev/data/twoMixtures/simulated_mutation0.csv"); files[1] = std::string(pathBegin + "RibModelDev/data/twoMixtures/simulated_mutation1.csv"); tmp.initMutationCategories(files, tmp.getNumMutationCategories()); files[0] = std::string(pathBegin + "RibModelDev/data/twoMixtures/simulated_selection0.csv"); files[1] = std::string(pathBegin + "RibModelDev/data/twoMixtures/simulated_selection1.csv"); tmp.initSelectionCategories(files, tmp.getNumSelectionCategories()); tmp.InitializeSynthesisRate(genome, sphi_init[0]); //std::vector<double> phiVals = // parameter.readPhiValues(pathBegin + "RibModelDev/data/realGenomes/Skluyveri_ChrA_ChrCleft_phi_est.csv"); //parameter.InitializeSynthesisRate(phiVals); parameter = tmp; } my_print("Done!--------------------------------\n\n\n"); my_print("Initializing ROCModel object--------------------------\n"); ROCModel model; model.setParameter(parameter); my_print("Done!----------------------------------\n\n\n"); my_print("Running MCMC.............\n\n"); mcmc.run(genome, model, 1, 0); my_print("Done!----------------------------------\n\n\n"); } //END OF ROC else if (modelToRun == "RFP") { my_print("Initializing Genome object--------------------------\n"); Genome genome; genome.readRFPFile(pathBegin + "RibModelDev/data/rfp/rfp.counts.by.codon.and.gene.GSE63789.wt.csv"); my_print("Done!-------------------------------\n\n\n"); my_print("Initializing shared parameter variables---------------\n"); std::vector<unsigned> geneAssignment(genome.getGenomeSize()); std::vector<double> sphi_init(numMixtures, 1); if (numMixtures == 1) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = 0u; } } else if (numMixtures == 3) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { if (i < 961) geneAssignment[i] = 0u; else if (i < 1418) geneAssignment[i] = 1u; else geneAssignment[i] = 0u; } } std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; my_print("Done!------------------------\n\n\n"); my_print("Initializing RFPParameter object--------------------\n\n"); RFPParameter parameter; //parameter.writeBasicRestartFile("/Users/hollisbui/HollisFile.txt"); if (fromRestart) { RFPParameter tmp(pathBegin + "RibModelFramework/10_restartFile.rst"); parameter = tmp; } else { std::string mixDef = Parameter::allUnique; RFPParameter tmp(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, mixDef); for (unsigned i = 0u; i < numMixtures; i++) { unsigned selectionCategry = tmp.getSelectionCategory(i); my_print("Sphi_init for selection category %: %\n", selectionCategry, sphi_init[selectionCategry]); } my_print("\t# mixtures: %\n", numMixtures); my_print("\tmixture definition: %\n", mixDef); tmp.InitializeSynthesisRate(genome, sphi_init[0]); parameter = tmp; //parameter.writeEntireRestartFile("/Users/hollisbui/HollisFile2.txt"); } my_print("Done!--------------------------------\n\n\n"); my_print("Initializing RFPModel object--------------------------\n"); RFPModel model; model.setParameter(parameter); my_print("Done!----------------------------------\n\n\n"); my_print("Running MCMC.............\n\n"); mcmc.run(genome, model, 1, 0); my_print("Done!----------------------------------\n\n\n"); } //END OF RFP else if (modelToRun == "FONSE") { my_print("initialize Genome object--------------------------\n"); Genome genome; genome.readFasta(pathBegin + "RibModelDev/data/singleMixture/genome_2000.fasta"); my_print("Done!-------------------------------\n\n\n"); my_print("Initializing shared parameter variables---------------\n"); std::vector<unsigned> geneAssignment(genome.getGenomeSize()); std::vector<double> sphi_init(numMixtures, 1); if (numMixtures == 1) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = 0u; } } else if (numMixtures == 3) { for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { if (i < 961) geneAssignment[i] = 0u; else if (i < 1418) geneAssignment[i] = 1u; else geneAssignment[i] = 0u; } } std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; my_print("Done!------------------------\n\n\n"); FONSEParameter parameter; my_print("initialize Parameter object\n"); if (fromRestart) { FONSEParameter tmp(pathBegin + "RibModelDev/DevRscripts/10restartFile.rst"); parameter = tmp; } else { std::string mixDef = ROCParameter::allUnique; FONSEParameter tmp(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, mixDef); for (unsigned i = 0u; i < numMixtures; i++) { unsigned selectionCategory = tmp.getSelectionCategory(i); my_print("Sphi_init for selection category %: %\n", selectionCategory, sphi_init[selectionCategory]); } my_print("\t# mixtures: %\n", numMixtures); my_print("\tmixture definition: %\n", mixDef); std::vector<std::string> files(1); files[0] = std::string(pathBegin + "RibModelDev/data/singleMixture/genome_2000.mutation.csv"); tmp.initMutationCategories(files, tmp.getNumMutationCategories()); tmp.InitializeSynthesisRate(genome, sphi_init[0]); //std::vector<double> phiVals = parameter.readPhiValues( // pathBegin + "RibModelDev/data/realGenomes/Skluyveri_ChrA_ChrCleft_phi_est.csv"); //parameter.InitializeSynthesisRate(phiVals); parameter = tmp; my_print("done initialize Parameter object\n"); } my_print("Initializing Model object\n"); FONSEModel model; model.setParameter(parameter); my_print("Done!------------------------\n\n\n"); my_print("starting MCMC for ROC\n"); mcmc.run(genome, model, 4, 0); my_print("\nFinished MCMC for ROC\n"); } }
int main (int argc, char *argv[]) try { if (argc < 2) return EXIT_FAILURE; if (!strcmp (argv[1], "--version")) { puts ("yaccpp v0.1"); return EXIT_SUCCESS; } if (!strcmp (argv[1], "--help")) { puts ("usage: yaccpp <file> [file]..."); return EXIT_SUCCESS; } symbol_table local_symtab; symtab = &local_symtab; std::vector<std::string> files (argv + 1, argv + argc);; #if 0 std::copy (files.begin (), files.end (), std::ostream_iterator<std::string> (std::cout, "\n")); #endif lexer lex (files); parser parse (lex); if (node_ptr doc = parse ()) { phases::run ("nop", doc); phases::run ("anon_rules", doc); phases::run ("cardinality", doc); phases::run ("insert_syms", doc); phases::run ("scobind", doc); phases::run ("resolve_refs", doc); phases::run ("call_macros", doc); return EXIT_SUCCESS; phases::run ("print", doc); phases::run ("xmlprint", doc); } else { return EXIT_FAILURE; } #if 0 BOOST_FOREACH (node *n, node::nodes) printf ("%p : %d\n", n, n ? n->index : -1); #endif assert (node::audit_hash ()); node::compress_hash (); assert (node::audit_hash ()); #if 0 BOOST_FOREACH (node *n, node::nodes) printf ("%p : %d\n", n, n ? n->index : -1); #endif return EXIT_SUCCESS; } catch (std::runtime_error const &e) { printf ("runtime error: %s\n", e.what ()); return EXIT_FAILURE; } catch (std::exception const &e) { puts (e.what ()); return EXIT_FAILURE; }
const QStringList QTinyArchive::files() const { return files(this); }
bool posix_storage::has_any_file(storage_error& error) { m_stat_cache.reserve(files().num_files()); return aux::has_any_file(files(), m_save_path, m_stat_cache, error); }
void posix_storage::delete_files(remove_flags_t const options, storage_error& error) { aux::delete_files(files(), m_save_path, m_part_file_name, options, error); }
/* * Function: ReadDirectory * * > local files, dirs = FileSystem.ReadDirectory(root, path) * * Return a list of files and dirs in the specified directory. * * Parameters: * * root - a <FileSystemRoot> constant for the root of the dir to read from * path - optional. a directory under the root * * Returns: * * files - a list of files as full paths from the root * dirs - a list of dirs as full paths from the root * * Availability: * * alpha 26 * * Status: * * experimental */ static int l_filesystem_read_dir(lua_State *l) { LuaFileSystem::Root root = static_cast<LuaFileSystem::Root>(LuaConstants::GetConstantFromArg(l, "FileSystemRoot", 1)); std::string path; if (lua_gettop(l) > 1) path = luaL_checkstring(l, 2); FileSystem::FileSource *fs = nullptr; switch (root) { case LuaFileSystem::ROOT_USER: fs = &FileSystem::userFiles; break; case LuaFileSystem::ROOT_DATA: fs = &FileSystem::gameDataFiles; break; default: assert(0); // can't happen return 0; } assert(fs); { try { const FileSystem::FileInfo &info = fs->Lookup(path); if (!info.IsDir()) { luaL_error(l, "'%s' is not a directory", path.c_str()); return 0; } } catch (std::invalid_argument) { luaL_error(l, "'%s' is not a valid path", path.c_str()); return 0; } } FileSystem::FileEnumerator files(*fs, FileSystem::FileEnumerator::IncludeDirs); files.AddSearchRoot(path); lua_newtable(l); int filesTable = lua_gettop(l); lua_newtable(l); int dirsTable = lua_gettop(l); for (; !files.Finished(); files.Next()) { const FileSystem::FileInfo &info = files.Current(); lua_newtable(l); pi_lua_settable(l, "name", info.GetName().c_str()); push_date_time(l, info.GetModificationTime()); lua_setfield(l, -2, "mtime"); if (info.IsDir()) lua_rawseti(l, dirsTable, lua_rawlen(l, dirsTable)+1); else lua_rawseti(l, filesTable, lua_rawlen(l, filesTable)+1); } return 2; }
// #include"reaction.h" int main() { ////////Input Parameters of the potential (fit parameters) ///// std::string parameters_filename="Input.inp"; NuclearParameters Nu = read_nucleus_parameters( "Input/pca40.inp" ); double Ef=Nu.Ef; int lmax=5; double z0=20.0; double zp0; double A0=40.0; double tz=0.5; int type=1; int mvolume = 4; int AsyVolume = 1; double A = 40.0; if (tz>0) { zp0=1;} else {zp0=0;} double ph_gap = Nu.ph_gap; double rStart = .05; double rmax = 12.; double ham_pts = 180; double rdelt = rmax / ham_pts; // Construct Parameters Object Parameters p = get_parameters( parameters_filename, Nu.A, Nu.Z, zp0 ); // Construct Potential Object pot pottt = get_bobs_pot2( type, mvolume, AsyVolume, tz, Nu, p ); pot * pott = &pottt; // store coulomb potential in order to compare with boundRspace initiate(rmax , ham_pts , Ef, ph_gap , lmax , Nu.Z , zp0 , Nu.A , pott); double Elower = -11.61818; double Eupper = -9.4; double jj = .5; int ll = 0; int Ifine = 1; initiate.searchNonLoc( Elower, Eupper, jj, ll, Ifine); initiate.exteriorWaveFunct(ll); initiate.normalizeWF(); double tol=.01; double estart=Ef; ///// Making rmesh/// // std::vector<double> rmesh_p= initiate.make_rmesh_point(); std::vector<double> rmesh_p= initiate.make_rmesh_point(); std::vector<double> rmesh= initiate.make_rmesh(); //////////////////////////// //// s and d wave functions//// /////////////////////////// int N = 0; int L = 1; double J = 0.5; double Emax=2*-4.7; double Emin=-200.0 + Emax; eigen_t waves0=initiate.find_boundstate(rmesh_p, estart,0,L,J,tol); eigen_t waves1=initiate.find_boundstate(rmesh_p, estart,1,L,J,tol); eigen_t waves2=initiate.find_boundstate(rmesh_p, estart,2,L,J,tol); eigen_t waves3=initiate.find_boundstate(rmesh_p, estart,3,L,J,tol); eigen_t waves4=initiate.find_boundstate(rmesh_p, estart,4,L,J,tol); eigen_t waves5=initiate.find_boundstate(rmesh_p, estart,5,L,J,tol); eigen_t waves6=initiate.find_boundstate(rmesh_p, estart,6,0,0.5,tol); std::ofstream filee("waves/wave.out"); std::cout<<Elower<<std::endl; ////////// //////////// // Plottinge Pot and wavefuntionsa and their log// // and also the derivitaves ////////////////////// double norm0=0,norm1=0,norm2=0,norm3=0,norm4=0,norm5=0,norm6=0; double normAsymp_s = 0.; double normAsymp_d = 0.; double Mproton = 931.5;// 937.27; double normbob= 0.; //double Ed = -waves_d.first; //double Es = -waves_s.first; //double bbetta_d = std::sqrt(2. * Mproton * (40./41.) * Ed /(197. * 197.)); //double bbetta_s = std::sqrt(2. * Mproton * (40./41.) * Es /(197. * 197.)); //double llambbda = 2.0 * Mproton * (40./41.) * 1.44 * 19. /(197. * 197.); for(int ii=0;ii<rmesh_p.size();++ii){ norm0 += rdelt * std::pow(rmesh_p[ii] * waves0.second[ii],2) ; norm1 += rdelt * std::pow(rmesh_p[ii] * waves1.second[ii],2) ; norm2 += rdelt * std::pow(rmesh_p[ii] * waves2.second[ii],2) ; norm3 += rdelt * std::pow(rmesh_p[ii] * waves3.second[ii],2) ; norm4 += rdelt * std::pow(rmesh_p[ii] * waves4.second[ii],2) ; norm5 += rdelt * std::pow(rmesh_p[ii] * waves5.second[ii],2) ; norm6 += rdelt * std::pow(rmesh_p[ii] * waves6.second[ii],2) ; //normAsymp_s += rdelt * std::pow((exp(-bbetta_s * rmesh_p[ii]) * std::pow(rmesh_p[ii], -llambbda /( 2.0 * bbetta_s))) ,2); //normAsymp_d += rdelt * std::pow((exp(-bbetta_d * rmesh_p[ii]) * std::pow(rmesh_p[ii], -llambbda /( 2.0 * bbetta_d))) ,2); //normbob += rdelt * std::pow(rmesh_p[ii] * initiate.WaveArray[ii],2); } /////////////////////// ADDING CODE FOR SPECTRAL FUNCTION FOLDING WITH SKYRME //////////////////////// int index=initiate.index_from_LJ(L,J); std::vector< lj_eigen_t > bound_levels = initiate.get_bound_levels( rmesh, tol ); std::vector< mesh_t > emesh_vec = initiate.get_emeshes( rmesh, Emin, Emax, bound_levels ); cout<<"emesh_vec = "<<emesh_vec.size()<<endl; std::vector< prop_t > prop_vec = initiate.get_propagators( rmesh, emesh_vec ); const prop_t &propE = prop_vec.at(index); const mesh_t &emesh = emesh_vec.at(index); std::vector< double > bspec = initiate.spectral_strength( L, J, rmesh, emesh_vec, prop_vec ); mesh_t energym = initiate.get_lj_emesh(L,J,emesh_vec ); eigen_t bound_info = initiate.find_boundstate( rmesh, estart, N, L, J, tol ); std::vector< double > &QPF = bound_info.second; double QPE = bound_info.first; double S = initiate.sfactor( rmesh, QPE, L, J, QPF ); std::vector< double > chd = initiate.charge_density(rmesh, Emax, emesh_vec, prop_vec, bound_levels); vector <double> pdist = initiate.point_distribution(rmesh_p,Emax,emesh_vec,prop_vec,bound_levels); matrix_t d_mtx( rmesh.size(), rmesh.size() ); // density matrix d_mtx.clear(); //making it so that wavefunction takes skyrme wavefunction as the input and finds the skyrme spectral function std::ifstream filein("waves/upp12.txt"); double skyrme[rmesh.size()]; std::string line; double part=0; double part2=0; for(int i=0;i<rmesh.size();i++){ part += chd[i] * rdelt * pow(rmesh[i],2) * 4 * M_PI; part2 += pdist[i] * rdelt * pow(rmesh[i],2) * 4 * M_PI; } cout<<"Particle Number = "<<part<<endl; cout<<"Particle Number2 = "<<part2<<endl; int iii; iii=0; while(getline(filein,line)){ skyrme[iii]=atof(line.c_str()); iii++; } filein.close(); int esize; esize=emesh.size(); std::vector<double> spec; std::vector<double> spec2; std::vector <double> dom0,dom1,dom2,dom3,dom4,dom5,dom6; double dwave0,dwave1,dwave2,dwave3,dwave4,dwave5,dwave6; for(int i=0;i<rmesh.size();i++){ dwave0=rmesh[i]*waves0.second[i]/norm0; dom0.push_back(dwave0); dwave1=rmesh[i]*waves1.second[i]/norm1; dom1.push_back(dwave1); dwave2=rmesh[i]*waves2.second[i]/norm2; dom2.push_back(dwave2); dwave3=rmesh[i]*waves3.second[i]/norm3; dom3.push_back(dwave3); dwave4=rmesh[i]*waves4.second[i]/norm4; dom4.push_back(dwave4); dwave5=rmesh[i]*waves5.second[i]/norm5; dom5.push_back(dwave5); dwave6=rmesh[i]*waves6.second[i]/norm6; dom6.push_back(dwave6); } //Remember that propE is actually G*r*r'*rdelt for(unsigned int n=0;n<emesh.size();++n){ double spf=0.0; double spf2=0.0; double Edelt=emesh[n].second; for( unsigned int i = 0; i < rmesh.size(); ++i ) { for( unsigned int j = 0; j < rmesh.size(); ++j ) { //d_mtx(i,j) += Edelt * imag(propE[n](i,j)) / (M_PI * rmesh[i] * rmesh[j] * rdelt); d_mtx(i,j) += Edelt * imag(propE[n](i,j)) / M_PI; spf -= rdelt * skyrme[i] * skyrme[j] *imag( propE[n]( i, j ) ) / M_PI; spf2 -= rdelt * dom0[i]*dom0[j] *imag( propE[n]( i, j ) ) / M_PI; //spf -= rmesh[i] * rmesh[j] * rdelt / M_PI // * QPF[i] * QPF[j] * imag( propE[n]( i, j ) ); } } spec.push_back(spf); spec2.push_back(spf2); } std::ofstream fmtx("waves/dmtx.txt"); for(int i=0;i<rmesh.size();i++){ for(int j=0;j<rmesh.size();j++){ fmtx<<d_mtx(i,j)<<" "; } fmtx<<endl; } fmtx.close(); std::vector <eigen_t> eig = initiate.real_eigvecs(d_mtx); double norme=0.0; double norm=0.0; double eigsum=0.0; double maxeig=0.0; norm0=0,norm1=0,norm2=0,norm3=0,norm4=0,norm5=0,norm6=0; for(int i=0;i<rmesh.size();++i){ norm0 += rdelt * pow( eig[0].second[i],2); norm1 += rdelt * pow( eig[1].second[i],2); norm2 += rdelt * pow( eig[2].second[i],2); norm3 += rdelt * pow( eig[3].second[i],2); norm4 += rdelt * pow( eig[4].second[i],2); } double occ=0.0; for (int i=0;i<rmesh.size();++i){ for (int j=0;j<rmesh.size();++j){ occ += rdelt*rdelt * d_mtx(i,j) * eig[N].second[i]/std::sqrt(norm) * eig[N].second[j]/std::sqrt(norm) * pow(rmesh[i],2) * pow(rmesh[j],2); } } //cout<<"QP OCCUPATION NUMBER = "<<initiate.occupation(rmesh,d_mtx,QPF)<<endl; //cout<<"occupation number = "<<occ<<endl; ofstream fval("waves/i13 2.txt"); fval<<eig[0].first*-1<<std::endl; fval<<eig[1].first*-1<<std::endl; fval<<eig[2].first*-1<<endl; fval<<eig[3].first*-1<<endl; fval<<eig[4].first*-1<<endl; std::ofstream feig("waves/eig.out"); //std::cout<<"Here is an eigenvector"<<std::endl; double esum=0.0; for(int i=0;i<rmesh.size();++i){ //want to give R(r), so print out u(r)/r feig<<rmesh[i]<<" "<<eig[0].second[i]/sqrt(norm0)/rmesh[i]; feig<<" "<<eig[1].second[i]/sqrt(norm1)/rmesh[i]; feig<<" "<<eig[2].second[i]/sqrt(norm2)/rmesh[i]; feig<<" "<<eig[3].second[i]/sqrt(norm3)/rmesh[i]; feig<<" "<<eig[4].second[i]/sqrt(norm4)/rmesh[i]<<endl;; // esum += rdelt*pow(rmesh[i]*eig[N].second[i]/sqrt(norme),2); } //std::cout<<"esum = "<<esum<<std::endl; //This is where I will find rhobar, ask houssein how to put in clebsch gordon and spherical harmonics double dens=0.0; int nt=50; int np=25; double dt=2*M_PI/nt; double dp=M_PI/np; for(int i=0;i<rmesh.size();i++){ for(int j=0;j<nt;j++){ for(int k=0;k<np;k++){ dens+= rdelt*rdelt * skyrme[i]*skyrme[i] * chd[i]; //* spherical harmonics and clebsch gordon * sin(theta) } } } std::vector< double > s_of_Eqh = initiate.spectral_strength_QH( L, J, rmesh, emesh_vec, prop_vec, QPF); std::ofstream fden("waves/chd.out"); ofstream fpoint("waves/p.out"); std::ofstream fileout("waves/spec.out"); std::ofstream files("waves/skyrme.out"); std::ofstream fileq("waves/quasi.out"); std::ofstream filef("waves/fold.out"); std::ofstream filed("waves/dom.out"); std::ofstream filer("waves/r.out"); //std::ofstream filep("waves/prop.out"); for(int i=0;i<rmesh.size();i++){ files<<skyrme[i]<<endl; fileq<<QPF[i]<<endl; filer<<rmesh[i]<<" "<<rmesh_p[i]<<endl; fden<<rmesh[i]<<" "<<chd[i]<<endl; fpoint<<rmesh[i]<<" "<<pdist[i]<<endl; } for(int i=0;i<bspec.size();i++){ fileout<<energym[i].first<<" "<<energym[i].second<<" "<<spec[i]<<endl; filed<<energym[i].first<<" "<<energym[i].second<<" "<<spec2[i]<<endl; filef<<energym[i].first<<" "<<energym[i].second<<" "<<s_of_Eqh[i]<<endl; } filed.close(); filer.close(); filef.close(); fileq.close(); files.close(); fileout.close(); /////////// END OF ADDED CODE /////////////////////////////////////// //////// //normalizing wavefunctions at 4.008 to s wave to compare the asymptotic behaviour and energy //the value of s at 4.008 is .023309//d is .132997 , s_asymp is .000271922 , d_asymp i s .000336918 ///////// for(int ii=0;ii<rmesh.size();++ii){ filee<<dom0[ii]/rmesh[ii]<<" "<<dom1[ii]<<" "<<dom2[ii]<<" "<<dom3[ii]<<" "<<dom4[ii]<<" "<<dom5[ii]<<std::endl; } //std::cout <<"Es =" << waves_s.first << " " << "Ed= " << waves_d.first <<std::endl; //std::cout << zp0 << " " << tz<<" "<<norm_s<<" "<< norm_d<<" "<< normAsymp_s<<" norm bob=" << normbob<< std::endl; //std::cout <<"Elower = "<< Elower <<" " << "Eupper = " << Eupper<<std::endl; filee.close(); std::cout<<"Spectral Factor = "<<S<<endl; std::cout<<"Quasi-hole Energy = "<<QPE<<endl; return 0; }
int main(int argc, char * argv[]) { try { indri::api::Parameters& parameters = indri::api::Parameters::instance(); parameters.loadCommandLine( argc, argv ); require_parameter( "corpus", parameters ); require_parameter( "index", parameters ); StatusMonitor monitor; indri::api::IndexEnvironment env; std::string repositoryPath = parameters["index"]; buildindex_start_time(); if( parameters.get( "version", 0 ) ) { std::cout << INDRI_DISTRIBUTION << std::endl; } env.setMemory( parameters.get("memory", INT64(1024*1024*1024)) ); env.setNormalization( parameters.get("normalize", true)); env.setInjectURL( parameters.get("injectURL", true)); env.setStoreDocs( parameters.get("storeDocs", true)); std::string blackList = parameters.get("blacklist", ""); if( blackList.length() ) { int count = env.setBlackList(blackList); std::cout << "Added to blacklist: "<< count << std::endl; std::cout.flush(); } std::string offsetAnnotationHint=parameters.get("offsetannotationhint", "default"); if (offsetAnnotationHint=="ordered") { env.setOffsetAnnotationIndexHint(indri::parse::OAHintOrderedAnnotations); } if (offsetAnnotationHint=="unordered") { env.setOffsetAnnotationIndexHint(indri::parse::OAHintSizeBuffers); } else { env.setOffsetAnnotationIndexHint(indri::parse::OAHintDefault); } std::string stemmerName = parameters.get("stemmer.name", ""); if( stemmerName.length() ) env.setStemmer(stemmerName); std::vector<std::string> stopwords; if( copy_parameters_to_string_vector( stopwords, parameters, "stopper.word" ) ) env.setStopwords(stopwords); // fields to include as metadata (unindexed) std::vector<std::string> metadata; // metadata fields that should have a forward lookup table. std::vector<std::string> metadataForward; // metadata fields that should have a backward lookup table. std::vector<std::string> metadataBackward; copy_parameters_to_string_vector( metadata, parameters, "metadata.field" ); downcase_string_vector(metadata); copy_parameters_to_string_vector( metadataForward, parameters, "metadata.forward" ); downcase_string_vector(metadataForward); copy_parameters_to_string_vector( metadataBackward, parameters, "metadata.backward" ); downcase_string_vector(metadataBackward); // docno is a special field, automagically add it as forward and backward. std::string docno = "docno"; if( std::find( metadataForward.begin(), metadataForward.end(), docno ) == metadataForward.end() ) metadataForward.push_back(docno); if( std::find( metadataBackward.begin(), metadataBackward.end(), docno ) == metadataBackward.end() ) metadataBackward.push_back(docno); env.setMetadataIndexedFields( metadataForward, metadataBackward ); #if 0 // "document" is a special field. // automagically add it as an indexed field. indri::api::Parameters field = parameters.append("field"); field.set( "name", "document" ); field.set( "ordinal", true ); field.set("parental", true); #endif std::vector<std::string> fields; std::string subName = "name"; if( copy_parameters_to_string_vector( fields, parameters, "field", &subName ) ) { downcase_string_vector(fields); env.setIndexedFields(fields); process_numeric_fields( parameters, env ); process_ordinal_fields( parameters, env ); process_parental_fields( parameters, env ); //pto } if( indri::collection::Repository::exists( repositoryPath ) ) { // check if the repository was corrupted by an indexing crash // if so, recover it and continue. if (_recoverRepository(repositoryPath)) { env.open( repositoryPath, &monitor ); buildindex_print_event( std::string() + "Opened repository " + repositoryPath ); } else { // failed to open it, needs to be created from scratch. // create will remove any cruft. env.create( repositoryPath, &monitor ); buildindex_print_event( std::string() + "Created repository " + repositoryPath ); } } else { env.create( repositoryPath, &monitor ); buildindex_print_event( std::string() + "Created repository " + repositoryPath ); } indri::api::Parameters corpus = parameters["corpus"]; for( unsigned int i=0; i<corpus.size(); i++ ) { indri::api::Parameters thisCorpus = corpus[i]; require_parameter( "path", thisCorpus ); std::string corpusPath = thisCorpus["path"]; std::string fileClass = thisCorpus.get("class", ""); // augment field/metadata tags in the environment if needed. if( fileClass.length() ) { indri::parse::FileClassEnvironmentFactory::Specification *spec = env.getFileClassSpec(fileClass); if( spec ) { // add fields if necessary, only update if changed. if( augmentSpec( spec, fields, metadata, metadataForward, metadataBackward ) ) env.addFileClass(*spec); delete(spec); } } bool isDirectory = indri::file::Path::isDirectory( corpusPath ); // First record the document root, and then the paths to any annotator inputs env.setDocumentRoot( corpusPath ); // Support for anchor text std::string anchorText = thisCorpus.get("inlink", ""); env.setAnchorTextPath( anchorText ); // Support for offset annotations std::string offsetAnnotationsPath = thisCorpus.get( "annotations", "" ); env.setOffsetAnnotationsPath( offsetAnnotationsPath ); // Support for offset metadata file std::string offsetMetadataPath = thisCorpus.get( "metadata", "" ); env.setOffsetMetadataPath( offsetMetadataPath ); if( isDirectory ) { indri::file::FileTreeIterator files( corpusPath ); for( ; files != indri::file::FileTreeIterator::end(); files++ ) { if( fileClass.length() ) env.addFile( *files, fileClass ); else { std::string extension = indri::file::Path::extension( *files ); indri::parse::FileClassEnvironmentFactory::Specification *spec = env.getFileClassSpec(extension); if( spec ) { // add fields if necessary, only update if changed. if( augmentSpec( spec, fields, metadata, metadataForward, metadataBackward ) ) env.addFileClass(*spec); delete(spec); } env.addFile( *files ); } } } else { if( fileClass.length() ) env.addFile( corpusPath, fileClass ); else { std::string extension = indri::file::Path::extension( corpusPath ); indri::parse::FileClassEnvironmentFactory::Specification *spec = env.getFileClassSpec(extension); if( spec ) { // add fields if necessary, only update if changed. if( augmentSpec( spec, fields, metadata, metadataForward, metadataBackward ) ) env.addFileClass(*spec); delete(spec); } env.addFile( corpusPath ); } } } buildindex_print_event( "Closing index" ); env.close(); buildindex_print_event( "Finished" ); } catch( lemur::api::Exception& e ) { LEMUR_ABORT(e); } return 0; }
unique_ptr<ArchiveMetadata> ArchiveMetadata::readArchiveMetadata(ifstream &fs) { if (!fs.is_open()) { throw "File couldn't be opened!"; } fs.seekg(ios_base::beg); // -------------------- // Read in archive file // -------------------- // Archive Header ArchiveHeader archiveHeader; fs.read(reinterpret_cast<char *>(&archiveHeader), sizeof(ArchiveHeader)); // File List FileList fileList; fs.seekg(archiveHeader.fileListOffset); uint32_t fileCount; fs.read(reinterpret_cast<char *>(&fileCount), sizeof(uint32_t)); fileList.count = fileCount; // File Entries vector<FileEntry> files(fileCount); fs.read(reinterpret_cast<char *>(&files[0]), fileCount * sizeof(FileEntry)); fileList.files = files; // Path List PathList pathList; fs.seekg(archiveHeader.pathListOffset); uint32_t pathBytes; fs.read(reinterpret_cast<char *>(&pathBytes), sizeof(uint32_t)); pathList.bytes = pathBytes; uint32_t pathCount; fs.read(reinterpret_cast<char *>(&pathCount), sizeof(uint32_t)); pathList.count = pathCount; // Path Entries vector<PathEntry> paths(pathCount); fs.read(reinterpret_cast<char *>(&paths[0]), pathCount * sizeof(PathEntry)); pathList.paths = paths; // -------------------------- // Build Archive model object // -------------------------- unique_ptr<ArchiveMetadata> metadata(new ArchiveMetadata()); map<string, File> fileMap; for (auto it = files.begin(); it < files.end(); it++) { PathEntry pathEntry = paths[it->pathListIndex]; uint32_t adjustedPathOffset = archiveHeader.pathListOffset + pathEntry.offset; uint32_t pathLength = pathEntry.length; char *bytes = new char[pathLength]; fs.seekg(adjustedPathOffset); fs.read(bytes, pathLength); string path = string(bytes, pathLength - 1); delete bytes; assert(File::calculatePathHash(path) == it->pathHash); fileMap.insert(make_pair(path, File(path, it->dataOffset, it->dataSize))); } metadata->setFiles(fileMap); return metadata; }
int main(int argc, char** argv) try { po::options_description desc("Required options"); desc.add_options() ("help,h", "produce help message") ("force,f", "overwrite existing files") ("mpq", po::value<std::string>(), "the mpq to create") ("files", po::value<std::vector<std::string> >(), "input files"); po::positional_options_description p; p.add("mpq", 1); p.add("files", -1); po::variables_map vm; po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm); po::notify(vm); if (!vm.count("files") || !vm.count("mpq") || vm.count("help")) { std::cout << "usage: <mpq> [<files> ...]" << std::endl << std::endl << desc << std::endl; return 1; } std::vector<std::string> files(vm["files"].as< std::vector<std::string> >()); std::vector<FileEntry> toAdd; fs::path mpqPath(vm["mpq"].as<std::string>()); if(fs::exists(mpqPath)) { if(vm.count("force")) fs::remove(mpqPath); else throw std::runtime_error("mpq does already exist"); } for(std::vector<std::string>::iterator path = files.begin(); path != files.end(); ++path) { if(fs::is_regular_file(*path)) toAdd.push_back(FileEntry(*path, *path)); if(!fs::is_directory(*path)) //no symlinks etc continue; for(fs::recursive_directory_iterator file(*path), end; file != end; ++file) if(fs::is_regular_file(file->path())) toAdd.push_back(FileEntry(file->path(), makeRelative(*path, file->path()))); } for(std::vector<FileEntry>::iterator it = toAdd.begin(); it != toAdd.end(); ++it) std::cout << it->realPath << " >> " << it->mpqPath << std::endl; HANDLE mpq; if(!SFileCreateArchive(mpqPath.string().c_str(), MPQ_CREATE_ARCHIVE_V2, toAdd.size(), &mpq)) throw std::runtime_error("couldn't create mpq"); SFileSetLocale(0); size_t counter(0); for(std::vector<FileEntry>::iterator it = toAdd.begin(); it != toAdd.end(); ++it) { loadbar(++counter, toAdd.size()); if(!SFileAddFileEx(mpq, it->realPath.string().c_str(), it->mpqPath.string().c_str(), MPQ_FILE_COMPRESS, MPQ_COMPRESSION_BZIP2, MPQ_COMPRESSION_BZIP2)) std::cout << "couldn't add file " << it->realPath << std::endl; } std::cout << std::endl; SFileCompactArchive(mpq, NULL, false); SFileFlushArchive(mpq); SFileCloseArchive(mpq); return 0; } catch (const std::exception& e) { std::cerr << "error: " << e.what() << "\n"; }
main() { int i; char *p; uid = getuid(); myname = (char *)getlogin(); if(myname == NULL) myname = getpwuid(uid)->pw_name; comminit(); mbuf = itom(0); files(); setup(getpass("Key: ")); mkb(); mkx(); #ifndef debug invert(x, b, x); #else invert(x, b, z); mult(x, z, z); mdiv(z, b, q, z); omout(z); invert(x, b, x); #endif for(i=0; i<fcnt; i++) { sprintf(line, "%s%s.%d", maildir, myname, fnum[i]); if(stat(line, &stbuf)<0) { perror(line); continue; } if(stbuf.st_size == 0) { printf("zero length mail file\n"); unlink(line); continue; } if((mf = fopen(line, "r"))==NULL) { perror(line); continue; } decipher(mf, stdout); cmnd: printf("? "); fgets(buf, sizeof(buf), stdin); if(feof(stdin)) exit(0); switch(buf[0]) { case 'q': exit(0); case 'n': case 'd': case '\n': fclose(mf); unlink(line); break; case '!': system(buf+1); printf("!\n"); goto cmnd; case 's': case 'w': rewind(mf); if(buf[1] == '\n' || buf[1] == '\0') strcpy(buf, "s mbox\n"); for(p = buf+1; isspace(*p); p++); p[strlen(p)-1] = 0; kf = fopen(p, "a"); if(kf == NULL) { perror(p); goto cmnd; } decipher(mf, kf); fclose(mf); fclose(kf); unlink(line); break; default: printf("Commands are:\n"); printf("q quit, leaving unread messages\n"); printf("n delete current message and goto next\n"); printf("d same as above\n"); printf("\\n same as above\n"); printf("! execute shell command\n"); printf("s save message in the named file or mbox\n"); printf("w same as above\n"); printf("? prints this list\n"); goto cmnd; } } exit(0); }
FILE* posix_storage::open_file(file_index_t idx, open_mode_t const mode , std::int64_t const offset, storage_error& ec) { std::string const fn = files().file_path(idx, m_save_path); char const* mode_str = (mode & open_mode::write) ? "rb+" : "rb"; FILE* f = fopen(fn.c_str(), mode_str); if (f == nullptr) { ec.ec.assign(errno, generic_category()); // if we fail to open a file for writing, and the error is ENOENT, // it is likely because the directory we're creating the file in // does not exist. Create the directory and try again. if ((mode & open_mode::write) && ec.ec == boost::system::errc::no_such_file_or_directory) { // this means the directory the file is in doesn't exist. // so create it ec.ec.clear(); create_directories(parent_path(fn), ec.ec); if (ec.ec) { ec.file(idx); ec.operation = operation_t::mkdir; return nullptr; } // now that we've created the directories, try again // and make sure we create the file this time ("r+") opens for // reading and writing, but doesn't create the file. "w+" creates // the file and truncates it f = fopen(fn.c_str(), "wb+"); if (f == nullptr) { ec.ec.assign(errno, generic_category()); ec.file(idx); ec.operation = operation_t::file_open; return nullptr; } } else { ec.file(idx); ec.operation = operation_t::file_open; return nullptr; } } #ifdef TORRENT_WINDOWS #define fseek _fseeki64 #endif if (offset != 0) { if (fseek(f, offset, SEEK_SET) != 0) { ec.ec.assign(errno, generic_category()); ec.file(idx); ec.operation = operation_t::file_seek; fclose(f); return nullptr; } } return f; }
int main(int argc, char** argv) { #if MAPPER_USE_QTSINGLEAPPLICATION // Create single-instance application. // Use "oo-mapper" instead of the executable as identifier, in case we launch from different paths. QtSingleApplication qapp("oo-mapper", argc, argv); if (qapp.isRunning()) { // Send a message to activate the running app, and optionally open a file qapp.sendMessage((argc > 1) ? argv[1] : ""); return 0; } #else QApplication qapp(argc, argv); #endif // Load resources #ifdef MAPPER_USE_QT_CONF_QRC Q_INIT_RESOURCE(qt); #endif Q_INIT_RESOURCE(resources); Q_INIT_RESOURCE(licensing); // QSettings on OS X benefits from using an internet domain here. QCoreApplication::setOrganizationName("OpenOrienteering.org"); QCoreApplication::setApplicationName("Mapper"); // Set settings defaults Settings& settings = Settings::getInstance(); settings.applySettings(); #ifdef WIN32 // Load plugins on Windows qapp.addLibraryPath(QCoreApplication::applicationDirPath() + "/plugins"); #endif // Localization TranslationUtil::setBaseName(QString("OpenOrienteering")); QLocale::Language lang = (QLocale::Language)settings.getSetting(Settings::General_Language).toInt(); QString translation_file = settings.getSetting(Settings::General_TranslationFile).toString(); TranslationUtil translation(lang, translation_file); QLocale::setDefault(translation.getLocale()); #if defined(Mapper_DEBUG_TRANSLATIONS) if (!translation.getAppTranslator().isEmpty()) { // Debug translation only if there is a Mapper translation, i.e. not for English. qapp.installTranslator(new RecordingTranslator()); } #endif qapp.installTranslator(&translation.getQtTranslator()); qapp.installTranslator(&translation.getAppTranslator()); // Avoid numeric issues in libraries such as GDAL setlocale(LC_NUMERIC, "C"); // Initialize static things like the file format registry. doStaticInitializations(); QStyle* base_style = nullptr; #if !defined(Q_OS_WIN) && !defined(Q_OS_OSX) if (QGuiApplication::platformName() == QLatin1String("xcb")) { // Use the modern 'fusion' style instead of the // default "windows" style on X11. base_style = QStyleFactory::create("fusion"); } #endif QApplication::setStyle(new MapperProxyStyle(base_style)); #if !defined(Q_OS_OSX) QApplication::setPalette(QApplication::style()->standardPalette()); #endif // Create first main window MainWindow first_window(true); first_window.setAttribute(Qt::WA_DeleteOnClose, false); first_window.setController(new HomeScreenController()); bool no_files_given = true; #ifdef Q_OS_ANDROID QAndroidJniObject activity = QtAndroid::androidActivity(); QAndroidJniObject intent = activity.callObjectMethod("getIntent", "()Landroid/content/Intent;"); const QString action = intent.callObjectMethod<jstring>("getAction").toString(); static const QString action_edit = QAndroidJniObject::getStaticObjectField<jstring>("android/content/Intent", "ACTION_EDIT").toString(); static const QString action_view = QAndroidJniObject::getStaticObjectField<jstring>("android/content/Intent", "ACTION_VIEW").toString(); if (action == action_edit || action == action_view) { const QString data_string = intent.callObjectMethod<jstring>("getDataString").toString(); const QString local_file = QUrl(data_string).toLocalFile(); first_window.setHomeScreenDisabled(true); first_window.setCentralWidget(new QLabel(MainWindow::tr("Loading %1...").arg(local_file))); first_window.setVisible(true); first_window.raise(); // Empircal tested: We need to process the loop twice. QApplication::processEvents(QEventLoop::ExcludeUserInputEvents); QApplication::processEvents(QEventLoop::ExcludeUserInputEvents); if (!first_window.openPath(local_file)) return -1; return qapp.exec(); } #else // Open given files later, i.e. after the initial home screen has been // displayed. In this way, error messages for missing files will show on // top of a regular main window (home screen or other file). // Treat all program parameters as files to be opened QStringList args(qapp.arguments()); args.removeFirst(); // the program name for (auto&& arg : args) { if (arg[0] != '-') { first_window.openPathLater(arg); no_files_given = false; } } #endif // Optionally open most recently used file on startup if (no_files_given && settings.getSettingCached(Settings::General_OpenMRUFile).toBool()) { QStringList files(settings.getSettingCached(Settings::General_RecentFilesList).toStringList()); if (!files.isEmpty()) first_window.openPathLater(files[0]); } #if MAPPER_USE_QTSINGLEAPPLICATION // If we need to respond to a second app launch, do so, but also accept a file open request. qapp.setActivationWindow(&first_window); QObject::connect(&qapp, SIGNAL(messageReceived(const QString&)), &first_window, SLOT(openPath(const QString &))); #endif // Let application run first_window.setVisible(true); first_window.raise(); return qapp.exec(); }
void FindSegmentsFile::doRun(IndexCommitPtr commit) { if (commit) { if (directory != commit->getDirectory()) boost::throw_exception(IOException(L"The specified commit does not match the specified Directory")); runBody(commit->getSegmentsFileName()); return; } String segmentFileName; int64_t lastGen = -1; int64_t gen = 0; int32_t genLookaheadCount = 0; bool retry = false; LuceneException exc; SegmentInfosPtr segmentInfos(_segmentInfos); int32_t method = 0; // Loop until we succeed in calling runBody() without hitting an IOException. An IOException most likely // means a commit was in process and has finished, in the time it took us to load the now-old infos files // (and segments files). It's also possible it's a true error (corrupt index). To distinguish these, // on each retry we must see "forward progress" on which generation we are trying to load. If we don't, // then the original error is real and we throw it. // We have three methods for determining the current generation. We try the first two in parallel, and // fall back to the third when necessary. while (true) { if (method == 0) { // Method 1: list the directory and use the highest segments_N file. This method works well as long // as there is no stale caching on the directory contents (NOTE: NFS clients often have such stale caching) HashSet<String> files(directory->listAll()); int64_t genA = segmentInfos->getCurrentSegmentGeneration(files); segmentInfos->message(L"directory listing genA=" + StringUtils::toString(genA)); // Method 2: open segments.gen and read its contents. Then we take the larger of the two gens. This way, // if either approach is hitting a stale cache (NFS) we have a better chance of getting the right generation. int64_t genB = -1; for (int32_t i = 0; i < SegmentInfos::defaultGenFileRetryCount; ++i) { IndexInputPtr genInput; try { genInput = directory->openInput(IndexFileNames::SEGMENTS_GEN()); } catch (FileNotFoundException& e) { segmentInfos->message(L"Segments.gen open: FileNotFoundException " + e.getError()); break; } catch (IOException& e) { segmentInfos->message(L"Segments.gen open: IOException " + e.getError()); } if (genInput) { LuceneException finally; bool fileConsistent = false; try { int32_t version = genInput->readInt(); if (version == SegmentInfos::FORMAT_LOCKLESS) { int64_t gen0 = genInput->readLong(); int64_t gen1 = genInput->readLong(); segmentInfos->message(L"fallback check: " + StringUtils::toString(gen0) + L"; " + StringUtils::toString(gen1)); if (gen0 == gen1) { // the file is consistent genB = gen0; fileConsistent = true; } } } catch (IOException&) { // will retry } catch (LuceneException& e) { finally = e; } genInput->close(); finally.throwException(); if (fileConsistent) break; } LuceneThread::threadSleep(SegmentInfos::defaultGenFileRetryPauseMsec); } segmentInfos->message(String(IndexFileNames::SEGMENTS_GEN()) + L" check: genB=" + StringUtils::toString(genB)); // pick the larger of the two gen's gen = std::max(genA, genB); // neither approach found a generation if (gen == -1) boost::throw_exception(FileNotFoundException(L"No segments* file found in directory")); } // Third method (fallback if first & second methods are not reliable): since both directory cache and // file contents cache seem to be stale, just advance the generation. if (method == 1 || (method == 0 && lastGen == gen && retry)) { method = 1; if (genLookaheadCount < SegmentInfos::defaultGenLookaheadCount) { ++gen; ++genLookaheadCount; segmentInfos->message(L"look ahead increment gen to " + StringUtils::toString(gen)); } } if (lastGen == gen) { // This means we're about to try the same segments_N last tried. This is allowed, exactly once, because // writer could have been in the process of writing segments_N last time. if (retry) { // OK, we've tried the same segments_N file twice in a row, so this must be a real error. exc.throwException(); } else retry = true; } else if (method == 0) { // Segment file has advanced since our last loop, so reset retry retry = false; } lastGen = gen; segmentFileName = IndexFileNames::fileNameFromGeneration(IndexFileNames::SEGMENTS(), L"", gen); try { runBody(segmentFileName); segmentInfos->message(L"success on " + segmentFileName); return; } catch (LuceneException& err) { // Save the original root cause if (exc.isNull()) exc = err; segmentInfos->message(L"primary Exception on '" + segmentFileName + L"': " + err.getError() + L"'; will retry: retry=" + StringUtils::toString(retry) + L"; gen = " + StringUtils::toString(gen)); if (!retry && gen > 1) { // This is our first time trying this segments file (because retry is false), and, there is possibly a // segments_(N-1) (because gen > 1). So, check if the segments_(N-1) exists and try it if so. String prevSegmentFileName(IndexFileNames::fileNameFromGeneration(IndexFileNames::SEGMENTS(), L"", gen - 1)); if (directory->fileExists(prevSegmentFileName)) { segmentInfos->message(L"fallback to prior segment file '" + prevSegmentFileName + L"'"); try { runBody(prevSegmentFileName); if (!exc.isNull()) segmentInfos->message(L"success on fallback " + prevSegmentFileName); return; } catch (LuceneException& err2) { segmentInfos->message(L"secondary Exception on '" + prevSegmentFileName + L"': " + err2.getError() + L"'; will retry"); } } } } } }
QVariant AppsModel::data(const QModelIndex &index, int role) const { if (!index.isValid() || index.row() >= m_entryList.count()) { return QVariant(); } const AbstractEntry *entry = m_entryList.at(index.row()); if (role == Qt::DisplayRole) { return entry->name(); } else if (role == Qt::DecorationRole) { return entry->icon(); } else if (role == Kicker::IsParentRole) { return (entry->type() == AbstractEntry::GroupType); } else if (role == Kicker::HasChildrenRole) { if (entry->type() == AbstractEntry::GroupType) { const AbstractGroupEntry *groupEntry = static_cast<const AbstractGroupEntry *>(entry); if (groupEntry->model() && groupEntry->model()->count()) { return true; } } } else if (role == Kicker::FavoriteIdRole) { if (entry->type() == AbstractEntry::RunnableType) { return QVariant("app:" + static_cast<AppEntry *>(m_entryList.at(index.row()))->service()->storageId()); } } else if (role == Kicker::HasActionListRole) { if (entry->type() == AbstractEntry::RunnableType || !m_hiddenEntries.isEmpty()) { return true; } else if (entry->type() == AbstractEntry::GroupType) { const AbstractGroupEntry *groupEntry = static_cast<const AbstractGroupEntry *>(entry); if (groupEntry->model()) { const AppsModel *appsModel = qobject_cast<const AppsModel *>(groupEntry->model()); if (appsModel && !appsModel->hiddenEntries().isEmpty()) { return true; } } } } else if (role == Kicker::ActionListRole) { QVariantList actionList; if (entry->type() == AbstractEntry::RunnableType) { const KService::Ptr service = static_cast<const AppEntry *>(entry)->service(); if (ContainmentInterface::mayAddLauncher(m_appletInterface, ContainmentInterface::Desktop)) { actionList << Kicker::createActionItem(i18n("Add to Desktop"), "addToDesktop"); } if (ContainmentInterface::mayAddLauncher(m_appletInterface, ContainmentInterface::Panel)) { actionList << Kicker::createActionItem(i18n("Add to Panel"), "addToPanel"); } if (ContainmentInterface::mayAddLauncher(m_appletInterface, ContainmentInterface::TaskManager, service->entryPath())) { actionList << Kicker::createActionItem(i18n("Add as Launcher"), "addToTaskManager"); } if (m_menuEntryEditor->canEdit(service->entryPath())) { actionList << Kicker::createSeparatorActionItem(); QVariantMap editAction = Kicker::createActionItem(i18n("Edit Application..."), "editApplication"); editAction["icon"] = "kmenuedit"; // TODO: Using the KMenuEdit icon might be misleading. actionList << editAction; } #ifdef PackageKitQt5_FOUND QStringList files(service->entryPath()); if (service->isApplication()) { files += QStandardPaths::findExecutable(KShell::splitArgs(service->exec()).first()); } FindPackageJob* job = new FindPackageJob(files); // TODO: Would be great to make this async. if (job->exec() && !job->packageNames().isEmpty()) { QString packageName = job->packageNames().first(); QVariantMap removeAction = Kicker::createActionItem(i18n("Remove '%1'...", packageName), "removeApplication", packageName); removeAction["icon"] = "applications-other"; actionList << removeAction; } #endif if (appletConfig() && appletConfig()->contains("hiddenApplications")) { const QStringList &hiddenApps = appletConfig()->value("hiddenApplications").toStringList(); if (!hiddenApps.contains(service->menuId())) { actionList << Kicker::createActionItem(i18n("Hide Application"), "hideApplication"); } } } if (!m_hiddenEntries.isEmpty()) { actionList << Kicker::createSeparatorActionItem(); actionList << Kicker::createActionItem(i18n("Unhide Applications in this Submenu"), "unhideSiblingApplications"); } if (entry->type() == AbstractEntry::GroupType) { const AbstractGroupEntry *groupEntry = static_cast<const AbstractGroupEntry *>(entry); if (groupEntry->model()) { const AppsModel *appsModel = qobject_cast<const AppsModel *>(groupEntry->model()); if (appsModel && !appsModel->hiddenEntries().isEmpty()) { actionList << Kicker::createActionItem(i18n("Unhide Applications in '%1'", entry->name()), "unhideChildApplications"); } } } return actionList; } else if (role == Kicker::UrlRole) { if (entry->type() == AbstractEntry::RunnableType) { return QUrl::fromLocalFile(static_cast<AppEntry *>(m_entryList.at(index.row()))->service()->entryPath()); } } return QVariant(); }
void ShipType::Init() { static bool isInitted = false; if (isInitted) return; isInitted = true; lua_State *l = luaL_newstate(); LUA_DEBUG_START(l); luaL_requiref(l, "_G", &luaopen_base, 1); luaL_requiref(l, LUA_DBLIBNAME, &luaopen_debug, 1); luaL_requiref(l, LUA_MATHLIBNAME, &luaopen_math, 1); lua_pop(l, 3); LuaConstants::Register(l); LuaVector::Register(l); LUA_DEBUG_CHECK(l, 0); // provide shortcut vector constructor: v = vector.new lua_getglobal(l, LuaVector::LibName); lua_getfield(l, -1, "new"); assert(lua_iscfunction(l, -1)); lua_setglobal(l, "v"); lua_pop(l, 1); // pop the vector library table LUA_DEBUG_CHECK(l, 0); // register ship definition functions lua_register(l, "define_ship", define_ship); lua_register(l, "define_static_ship", define_static_ship); lua_register(l, "define_missile", define_missile); LUA_DEBUG_CHECK(l, 0); // load all ship definitions namespace fs = FileSystem; for (fs::FileEnumerator files(fs::gameDataFiles, "ships", fs::FileEnumerator::Recurse); !files.Finished(); files.Next()) { const fs::FileInfo &info = files.Current(); if (ends_with(info.GetPath(), ".lua")) { const std::string name = info.GetName(); s_currentShipFile = name.substr(0, name.size()-4); pi_lua_dofile(l, info.GetPath()); s_currentShipFile.clear(); } } LUA_DEBUG_END(l, 0); lua_close(l); if (ShipType::player_ships.empty()) Error("No playable ships have been defined! The game cannot run."); //collect ships that can fit atmospheric shields for (std::vector<ShipType::Type>::const_iterator it = ShipType::player_ships.begin(); it != ShipType::player_ships.end(); ++it) { const ShipType &ship = ShipType::types[*it]; if (ship.equipSlotCapacity[Equip::SLOT_ATMOSHIELD] != 0) ShipType::playable_atmospheric_ships.push_back(*it); } if (ShipType::playable_atmospheric_ships.empty()) Error("No ships can fit atmospheric shields! The game cannot run."); }
// Commit //------------------------------------------------------------------------------ /*virtual*/ bool FunctionVCXProject::Commit( const BFFIterator & funcStartIter ) const { // required AStackString<> projectOutput; AStackString<> rootNamespace; AStackString<> projectGuid; AStackString<> defaultLanguage; AStackString<> applicationEnvironment; if ( !GetString( funcStartIter, projectOutput, ".ProjectOutput", true ) || !GetString( funcStartIter, rootNamespace, ".RootNamespace", false ) || !GetString( funcStartIter, projectGuid, ".ProjectGuid", false ) || !GetString( funcStartIter, defaultLanguage, ".DefaultLanguage", false ) || !GetString( funcStartIter, applicationEnvironment, ".ApplicationEnvironment", false ) ) { return false; } // optional inputs Array< AString > inputPaths; Array< AString > inputPathsExclude; if ( !GetStrings( funcStartIter, inputPaths, ".ProjectInputPaths", false ) || !GetStrings( funcStartIter, inputPathsExclude, ".ProjectInputPathsExclude", false ) ) { return false; } // project base Array< AString > basePaths; if ( !GetStrings( funcStartIter, basePaths, ".ProjectBasePath", false ) ) { return false; } CleanFolderPaths( basePaths ); // references Array< AString > references; Array< AString > projectReferences; if ( !GetStrings( funcStartIter, references, ".ProjectReferences", false ) || !GetStrings( funcStartIter, projectReferences, ".ProjectProjectReferences", false ) ) { return false; } // permitted file extensions Array< AString > allowedFileExtensions( 8, true ); if ( !GetStrings( funcStartIter, allowedFileExtensions, ".ProjectAllowedFileExtensions", false ) ) { return true; } if ( allowedFileExtensions.IsEmpty() ) { const char * extensions[] = { ".cpp", ".hpp", ".cxx",".hxx",".c",".h",".cc",".hh", ".cp",".hp",".cs",".inl",".bff",".rc",".resx",".m",".mm", ".cu", nullptr }; AStackString<> tmp; const char ** item = extensions; while ( *item ) { tmp.Assign( *item ); allowedFileExtensions.Append( tmp ); ++item; } } // files and filesToExclude Array< AString > files( 8, true ); Array< AString > filesToExclude( 8, true ); if ( !GetStrings( funcStartIter, files, ".ProjectFiles", false ) || !GetStrings( funcStartIter, filesToExclude, ".ProjectFilesToExclude", false ) ) { return false; } // filetypes Array< VSProjectFileType > fileTypes; const BFFVariable * projectFileTypes = BFFStackFrame::GetVar( ".ProjectFileTypes" ); if ( projectFileTypes ) { if ( projectFileTypes->IsArrayOfStructs() == false ) { Error::Error_1050_PropertyMustBeOfType( funcStartIter, this, ".ProjectFileTypes", projectFileTypes->GetType(), BFFVariable::VAR_ARRAY_OF_STRUCTS ); return false; } const Array< const BFFVariable * > & structs = projectFileTypes->GetArrayOfStructs(); const BFFVariable * const * end = structs.End(); for ( const BFFVariable ** it = structs.Begin(); it != end; ++it ) { const BFFVariable * s = *it; VSProjectFileType ft; // .FileType must be provided if ( !GetStringFromStruct( s, ".FileType", ft.m_FileType ) ) { // TODO:B custom error Error::Error_1101_MissingProperty( funcStartIter, this, AStackString<>( ".FileType" ) ); return false; } // .Pattern must be provided if ( !GetStringFromStruct( s, ".Pattern", ft.m_Pattern ) ) { // TODO:B custom error Error::Error_1101_MissingProperty( funcStartIter, this, AStackString<>( ".Pattern" ) ); return false; } fileTypes.Append( ft ); } } // path cleaning CleanFolderPaths( inputPaths ); // input paths CleanFolderPaths( inputPathsExclude ); // exclude paths CleanFilePaths( files ); // explicit files // per-config options VSProjectConfig baseConfig; // various options if ( !GetString( funcStartIter, baseConfig.m_BuildCommand, ".ProjectBuildCommand", false ) || !GetString( funcStartIter, baseConfig.m_RebuildCommand,".ProjectRebuildCommand", false ) || !GetString( funcStartIter, baseConfig.m_CleanCommand, ".ProjectCleanCommand", false ) || !GetString( funcStartIter, baseConfig.m_Output, ".Output", false ) || !GetString( funcStartIter, baseConfig.m_PreprocessorDefinitions, ".PreprocessorDefinitions", false ) || !GetString( funcStartIter, baseConfig.m_IncludeSearchPath, ".IncludeSearchPath", false ) || !GetString( funcStartIter, baseConfig.m_ForcedIncludes, ".ForcedIncludes", false ) || !GetString( funcStartIter, baseConfig.m_AssemblySearchPath, ".AssemblySearchPath", false ) || !GetString( funcStartIter, baseConfig.m_ForcedUsingAssemblies, ".ForcedUsingAssemblies", false ) || !GetString( funcStartIter, baseConfig.m_AdditionalOptions, ".AdditionalOptions", false ) || !GetString( funcStartIter, baseConfig.m_OutputDirectory, ".OutputDirectory", false ) || !GetString( funcStartIter, baseConfig.m_IntermediateDirectory, ".IntermediateDirectory", false ) || !GetString( funcStartIter, baseConfig.m_Xbox360DebuggerCommand,".Xbox360DebuggerCommand", false ) || !GetString( funcStartIter, baseConfig.m_LayoutDir, ".LayoutDir", false ) || !GetString( funcStartIter, baseConfig.m_LayoutExtensionFilter, ".LayoutExtensionFilter", false ) || !GetString( funcStartIter, baseConfig.m_DebuggerFlavor, ".DebuggerFlavor", false ) || !GetString( funcStartIter, baseConfig.m_AumidOverride, ".AumidOverride", false ) || !GetString( funcStartIter, baseConfig.m_PlatformToolset, ".PlatformToolset", false ) || !GetString( funcStartIter, baseConfig.m_DeploymentType, ".DeploymentType", false ) || !GetString( funcStartIter, baseConfig.m_DeploymentFiles, ".DeploymentFiles", false ) || !GetString( funcStartIter, baseConfig.m_LocalDebuggerCommandArguments, ".LocalDebuggerCommandArguments", false ) || !GetString( funcStartIter, baseConfig.m_LocalDebuggerWorkingDirectory, ".LocalDebuggerWorkingDirectory", false ) || !GetString( funcStartIter, baseConfig.m_LocalDebuggerCommand, ".LocalDebuggerCommand", false ) || !GetString( funcStartIter, baseConfig.m_LocalDebuggerEnvironment, ".LocalDebuggerEnvironment", false ) ) { return false; } // create configs Array< VSProjectConfig > configs( 16, true ); const BFFVariable * projectConfigs = BFFStackFrame::GetVar( ".ProjectConfigs" ); if ( projectConfigs ) { if ( projectConfigs->IsArrayOfStructs() == false ) { Error::Error_1050_PropertyMustBeOfType( funcStartIter, this, ".ProjectConfigs", projectConfigs->GetType(), BFFVariable::VAR_ARRAY_OF_STRUCTS ); return false; } const Array< const BFFVariable * > & structs = projectConfigs->GetArrayOfStructs(); const BFFVariable * const * end = structs.End(); for ( const BFFVariable ** it = structs.Begin(); it != end; ++it ) { const BFFVariable * s = *it; // start with the base configuration VSProjectConfig newConfig( baseConfig ); // .Platform must be provided if ( !GetStringFromStruct( s, ".Platform", newConfig.m_Platform ) ) { // TODO:B custom error Error::Error_1101_MissingProperty( funcStartIter, this, AStackString<>( ".Platform" ) ); return false; } // .Config must be provided if ( !GetStringFromStruct( s, ".Config", newConfig.m_Config ) ) { // TODO:B custom error Error::Error_1101_MissingProperty( funcStartIter, this, AStackString<>( ".Config" ) ); return false; } GetStringFromStruct( s, ".ProjectBuildCommand", newConfig.m_BuildCommand ); GetStringFromStruct( s, ".ProjectRebuildCommand", newConfig.m_RebuildCommand ); GetStringFromStruct( s, ".ProjectCleanCommand", newConfig.m_CleanCommand ); GetStringFromStruct( s, ".Output", newConfig.m_Output ); GetStringFromStruct( s, ".PreprocessorDefinitions", newConfig.m_PreprocessorDefinitions ); GetStringFromStruct( s, ".IncludeSearchPath", newConfig.m_IncludeSearchPath ); GetStringFromStruct( s, ".ForcedIncludes", newConfig.m_ForcedIncludes ); GetStringFromStruct( s, ".AssemblySearchPath", newConfig.m_AssemblySearchPath ); GetStringFromStruct( s, ".ForcedUsingAssemblies", newConfig.m_ForcedUsingAssemblies ); GetStringFromStruct( s, ".AdditionalOptions", newConfig.m_AdditionalOptions ); GetStringFromStruct( s, ".OutputDirectory", newConfig.m_OutputDirectory ); GetStringFromStruct( s, ".IntermediateDirectory", newConfig.m_IntermediateDirectory ); GetStringFromStruct( s, ".LayoutDir", newConfig.m_LayoutDir ); GetStringFromStruct( s, ".LayoutExtensionFilter", newConfig.m_LayoutExtensionFilter ); GetStringFromStruct( s, ".Xbox360DebuggerCommand", newConfig.m_Xbox360DebuggerCommand ); GetStringFromStruct( s, ".DebuggerFlavor", newConfig.m_DebuggerFlavor ); GetStringFromStruct( s, ".AumidOverride", newConfig.m_AumidOverride ); GetStringFromStruct( s, ".PlatformToolset", newConfig.m_PlatformToolset ); GetStringFromStruct( s, ".DeploymentType", newConfig.m_DeploymentType ); GetStringFromStruct( s, ".DeploymentFiles", newConfig.m_DeploymentFiles ); GetStringFromStruct( s, ".LocalDebuggerCommandArguments", newConfig.m_LocalDebuggerCommandArguments ); GetStringFromStruct( s, ".LocalDebuggerWorkingDirectory", newConfig.m_LocalDebuggerWorkingDirectory ); GetStringFromStruct( s, ".LocalDebuggerCommand", newConfig.m_LocalDebuggerCommand ); GetStringFromStruct( s, ".LocalDebuggerEnvironment", newConfig.m_LocalDebuggerEnvironment ); configs.Append( newConfig ); } } else { // no user specified configs, make some defaults // start from the default VSProjectConfig config( baseConfig ); // make the configs config.m_Platform = "Win32"; config.m_Config = "Debug"; configs.Append( config ); config.m_Config = "Release"; configs.Append( config ); config.m_Platform = "x64"; configs.Append( config ); config.m_Config = "Debug"; configs.Append( config ); } NodeGraph & ng = FBuild::Get().GetDependencyGraph(); // create all of the DirectoryListNodes we need Dependencies dirNodes( inputPaths.GetSize() ); if ( !GetDirectoryListNodeList( funcStartIter, inputPaths, Array< AString >(), Array< AString >(), true, nullptr, "ProjectInputPaths", dirNodes ) ) { return false; // GetDirectoryListNodeList will have emitted an error } // Check for existing node if ( ng.FindNode( projectOutput ) ) { Error::Error_1100_AlreadyDefined( funcStartIter, this, projectOutput ); return false; } VCXProjectNode * pn = ng.CreateVCXProjectNode( projectOutput, basePaths, dirNodes, inputPathsExclude, // TODO:B Remove this (handled by DirectoryListNode now) allowedFileExtensions, // TODO:B Remove this (handled by DirectoryListNode now) files, filesToExclude, rootNamespace, projectGuid, defaultLanguage, applicationEnvironment, configs, fileTypes, references, projectReferences ); ASSERT( pn ); return ProcessAlias( funcStartIter, pn ); }
// ----------------------------------------------------------------------------- // Reads pod format data from a MemChunk // Returns true if successful, false otherwise // ----------------------------------------------------------------------------- bool PodArchive::open(MemChunk& mc) { // Check data was given if (!mc.hasData()) return false; // Read no. of files mc.seek(0, 0); uint32_t num_files; mc.read(&num_files, 4); // Read id mc.read(id_, 80); // Read directory vector<FileEntry> files(num_files); mc.read(files.data(), num_files * sizeof(FileEntry)); // Stop announcements (don't want to be announcing modification due to entries being added etc) setMuted(true); // Create entries UI::setSplashProgressMessage("Reading pod archive data"); for (unsigned a = 0; a < num_files; a++) { // Get the entry name as a wxFileName (so we can break it up) wxFileName fn(files[a].name); // Create entry auto new_entry = std::make_shared<ArchiveEntry>(fn.GetFullName(), files[a].size); new_entry->exProp("Offset") = files[a].offset; new_entry->setLoaded(false); // Add entry and directory to directory tree string path = fn.GetPath(false); auto ndir = createDir(path); ndir->addEntry(new_entry); new_entry->setState(ArchiveEntry::State::Unmodified); LOG_MESSAGE(5, "File size: %d, offset: %d, name: %s", files[a].size, files[a].offset, files[a].name); } // Detect entry types vector<ArchiveEntry*> all_entries; putEntryTreeAsList(all_entries); UI::setSplashProgressMessage("Detecting entry types"); for (unsigned a = 0; a < all_entries.size(); a++) { // Skip dir/marker if (all_entries[a]->size() == 0 || all_entries[a]->type() == EntryType::folderType()) { all_entries[a]->setState(ArchiveEntry::State::Unmodified); continue; } // Update splash window progress UI::setSplashProgress((float)a / (float)all_entries.size()); // Read data MemChunk edata; mc.exportMemChunk(edata, all_entries[a]->exProp("Offset").intValue(), all_entries[a]->size()); all_entries[a]->importMemChunk(edata); // Detect entry type EntryType::detectEntryType(all_entries[a]); // Unload entry data if needed if (!archive_load_data) all_entries[a]->unloadData(); // Set entry to unchanged all_entries[a]->setState(ArchiveEntry::State::Unmodified); LOG_MESSAGE(5, "entry %s size %d", CHR(all_entries[a]->name()), all_entries[a]->size()); } // Setup variables setMuted(false); setModified(false); announce("opened"); UI::setSplashProgressMessage(""); return true; }
int main() { std::cout << "Initializing MCMCAlgorithm object---------------" << std::endl; int samples = 200; int thinning = 10; int useSamples = 100; std::cout << "\t# Samples: " << samples << "\n"; std::cout << "\tThinning: " << thinning << "\n"; std::cout << "\t# Samples used: " << useSamples << "\n"; MCMCAlgorithm mcmc = MCMCAlgorithm(samples, thinning, 100, false, true, true); mcmc.setRestartFileSettings(std::string("test"), 100, true); //mcmc.setRestartFileSettings("RestartFile.txt", 20, true); std::cout << "Done!-------------------------------\n\n\n"; std::cout << "initialize Genome object--------------------------" << std::endl; bool withPhi = false; Genome genome; genome.readFasta("/home/clandere/CodonUsageBias/RibosomeModel/RibModelDev/data/twoMixtures/simulatedMutationSharedR.fasta"); //genome.readFasta("F:/GitHub/RibModelDev/data/twoMixtures/simulatedAllUniqueR.fasta"); //genome.readFasta("E:/RibosomeModel/RibModelDev/data/twoMixtures/simulatedAllUniqueR_unevenMixtures.fasta"); if(withPhi) { genome.readObservedPhiValues("F:/GitHub/RibModelDev/data/twoMixtures/simulatedAllUniqueR_phi_withPhiSet.csv", false); //genome.readObservedPhiValues("E:/RibosomeModel/RibModelDev/data/twoMixtures/simulatedAllUniqueR_phi_unevenMixtures.csv", false); } std::cout << "Done!-------------------------------\n\n\n"; std::cout << "Initializing shared parameter variables---------------\n"; std::cout << "Done!-------------------------------\n\n\n"; std::cout << "Initializing shared parameter variables---------------\n"; std::vector<unsigned> geneAssignment(genome.getGenomeSize()); unsigned numMixtures = 2; std::vector<double> sphi_init(numMixtures, 1); /* For 2 mixture */ for (unsigned i = 0u; i < genome.getGenomeSize(); i++) { geneAssignment[i] = ( ((double)rand() / (double)RAND_MAX) < 0.5 ? 0u : 1u ); } std::vector<std::vector<unsigned>> mixtureDefinitionMatrix; std::cout << "Done!------------------------\n\n\n"; std::cout << "initialize ROCParameter object" << std::endl; std::string mixDef = ROCParameter::mutationShared; ROCParameter parameter(sphi_init, numMixtures, geneAssignment, mixtureDefinitionMatrix, true, mixDef); for (unsigned i = 0u; i < numMixtures; i++) { unsigned selectionCategry = parameter.getSelectionCategory(i); std::cout << "Sphi_init for selection category " << selectionCategry << ": " << sphi_init[selectionCategry] << std::endl; } std::cout << "\t# mixtures: " << numMixtures << "\n"; std::cout << "\tmixture definition: " << mixDef << "\n"; std::vector<std::string> files(1); //files[0] = std::string("F:/GitHub/RibModelDev/data/twoMixtures/simulated_mutation0.csv"); //files[1] = std::string("F:/GitHub/RibModelDev/data/twoMixtures/simulated_mutation1.csv"); files[0] = std::string("/home/clandere/CodonUsageBias/RibosomeModel/RibModelDev/data/twoMixtures/simulated_mutation0.csv"); //files[1] = std::string("/home/clandere/CodonUsageBias/RibosomeModel/RibModelDev/data/twoMixtures/simulated_mutation1.csv"); parameter.initMutationCategories(files, parameter.getNumMutationCategories()); files.resize(2); //files[0] = std::string("F:/GitHub/RibModelDev/data/twoMixtures/simulated_selection0.csv"); //files[1] = std::string("F:/GitHub/RibModelDev/data/twoMixtures/simulated_selection1.csv"); files[0] = std::string("/home/clandere/CodonUsageBias/RibosomeModel/RibModelDev/data/twoMixtures/simulated_selection0.csv"); files[1] = std::string("/home/clandere/CodonUsageBias/RibosomeModel/RibModelDev/data/twoMixtures/simulated_selection1.csv"); parameter.initSelectionCategories(files, parameter.getNumSelectionCategories()); parameter.InitializeSynthesisRate(genome, sphi_init[0]); //std::vector<double> phiVals = parameter.readPhiValues("/home/clandere/CodonUsageBias/RibosomeModel/RibModelFramework/ribModel/data/Skluyveri_ChrA_ChrCleft_phi_est.csv"); //parameter.InitializeSynthesisRate(phiVals); std::cout << "done initialize ROCParameter object" << std::endl; std::cout << "Initializing ROCModel object\n"; ROCModel model(withPhi); model.setParameter(parameter); std::cout << "starting MCMC for ROC" << std::endl; mcmc.run(genome, model, 1, 0); std::cout << std::endl << "Finished MCMC for ROC" << std::endl; double temp[] = { 0.025, 0.5, 0.975 }; std::vector<double> probs(temp, temp + sizeof(temp) / sizeof(double)); //std::vector<double> quants = parameter.getCodonSpecificQuantile(1, 100, std::string("GCA"), 0, probs, true); std::string codon = std::string("TTT"); double a = parameter.getCodonSpecificPosteriorMean(0u, 50u, codon, 0u, true); double b = parameter.getCodonSpecificPosteriorMean(0u, 50u, codon, 1u, true); double c = parameter.getCodonSpecificPosteriorMean(1u, 50u, codon, 0u, true); double d = parameter.getCodonSpecificPosteriorMean(1u, 50u, codon, 1u, true); std::cout << std::endl << "Exiting" << std::endl; }
string getDBStructure() { return "----------------------------------------------------------------------\n\ --\n\ -- MOPSLinux package system\n\ -- Database creation script\n\ -- $Id: dbstruct.cpp,v 1.3 2007/11/02 20:19:45 i27249 Exp $\n\ --\n\ ----------------------------------------------------------------------\n\ \n\ create table packages (\n\ package_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ package_name TEXT NOT NULL,\n\ package_version TEXT NOT NULL,\n\ package_arch TEXT NOT NULL,\n\ package_build TEXT NULL,\n\ package_compressed_size TEXT NOT NULL,\n\ package_installed_size TEXT NOT NULL,\n\ package_short_description TEXT NULL,\n\ package_description TEXT NULL, \n\ package_changelog TEXT NULL,\n\ package_packager TEXT NULL,\n\ package_packager_email TEXT NULL,\n\ package_installed INTEGER NOT NULL,\n\ package_configexist INTEGER NOT NULL,\n\ package_action INTEGER NOT NULL,\n\ package_md5 TEXT NOT NULL,\n\ package_filename TEXT NOT NULL,\n\ package_betarelease TEXT NOT NULL,\n\ package_installed_by_dependency INTEGER NOT NULL DEFAULT '0',\n\ package_type INTEGER NOT NULL DEFAULT '0'\n\ );\n\ create index ppname on packages (package_id, package_name, package_version, package_action, package_installed, package_md5);\n\ \n\ create table files (\n\ file_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ file_name TEXT NOT NULL,\n\ file_type INTEGER NOT NULL,\n\ packages_package_id INTEGER NOT NULL\n\ );\n\ create index pname on files (file_name, packages_package_id);\n\ \n\ create table conflicts (\n\ conflict_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ conflict_file_name TEXT NOT NULL,\n\ backup_file TEXT NOT NULL,\n\ conflicted_package_id INTEGER NOT NULL\n\ );\n\ \n\ create table locations (\n\ location_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ packages_package_id INTEGER NOT NULL,\n\ server_url TEXT NOT NULL,\n\ location_path TEXT NOT NULL\n\ );\n\ create index locpid on locations(packages_package_id, location_path, server_url);\n\ create table tags (\n\ tags_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ tags_name TEXT NOT NULL\n\ );\n\ create index ptag on tags (tags_id, tags_name);\n\ \n\ create table tags_links (\n\ tags_link_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ packages_package_id INTEGER NOT NULL,\n\ tags_tag_id INTEGER NOT NULL\n\ );\n\ create index ptaglink on tags_links (packages_package_id, tags_tag_id);\n\ \n\ create table dependencies (\n\ dependency_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ packages_package_id INTEGER NOT NULL,\n\ dependency_condition INTEGER NOT NULL DEFAULT '1',\n\ dependency_type INTEGER NOT NULL DEFAULT '1',\n\ dependency_package_name TEXT NOT NULL,\n\ dependency_package_version TEXT NULL,\n\ dependency_build_only INTEGER NOT NULL DEFAULT '0' \ );\n\ \n\ create index pdeps on dependencies (packages_package_id, dependency_id, dependency_package_name, dependency_package_version, dependency_condition);\n\ \n\ -- INTERNATIONAL SUPPORT\n\ \n\ --create table descriptions (\n\ -- description_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ -- packages_package_id INTEGER NOT NULL,\n\ -- description_language TEXT NOT NULL,\n\ -- description_text TEXT NOT NULL,\n\ -- short_description_text TEXT NOT NULL\n\ --);\n\ \n\ --create table changelogs (\n\ -- changelog_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ -- packages_package_id INTEGER NOT NULL,\n\ -- changelog_language TEXT NOT NULL,\n\ -- changelog_text TEXT NOT NULL\n\ --);\n\ \n\ -- RATING SYSTEM - SUPPORT FOR FUTURE\n\ --create table ratings (\n\ -- rating_id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,\n\ -- rating_value INTEGER NOT NULL,\n\ -- packages_package_name TEXT NOT NULL\n\ --);\n\ "; }
bool MainComponent::perform (const juce::ApplicationCommandTarget::InvocationInfo& info) { CodeFileList codeFilesToEdit; { juce::StringArray files (codeFiles.getSelectedCodeFiles()); if (files.size() <= 0) { const juce::Array<juce::File>& list (codeFiles.getCodeFiles().getFiles()); for (int i = 0; i < list.size(); ++i) files.addIfNotAlreadyThere (list.getUnchecked (i).getFullPathName()); } codeFilesToEdit.addFiles (files); } switch (info.commandID) { case CommandIDs::ProjectNew: { } break; case CommandIDs::ProjectOpen: { } break; case CommandIDs::ProjectSave: { } break; case CommandIDs::ProjectSaveAs: { } break; case CommandIDs::ProjectClose: { } break; case CommandIDs::OpenFiles: { } break; case CommandIDs::OpenIntrojucerProject: { } break; case CommandIDs::Exit: { } break; case CommandIDs::EditUndo: { undoManager.undo(); } break; case CommandIDs::EditRedo: { undoManager.redo(); } break; case CommandIDs::FilesCapitaliseStringLiterals: { } break; case CommandIDs::FilesCleanTrailingWhitespace: { TrailingWhitespaceCleaner (codeFilesToEdit) .perform (UserSettings::getInstance()->getBool ("RemoveDocumentStartWhitespace"), (TrailingWhitespaceCleaner::WhitespaceRemovalOptions) UserSettings::getInstance()->getInt ("RemoveDocumentStartWhitespace", (int) TrailingWhitespaceCleaner::RemoveAll)); } break; case CommandIDs::FilesConvertLineEndings: { } break; case CommandIDs::FilesConvertTabsToSpaces: { } break; case CommandIDs::FilesModularise: { } break; case CommandIDs::ShowSettings: { BasicWindow* doc = new BasicWindow (TRANS ("Settings"), juce::Colours::darkgrey, juce::DocumentWindow::closeButton); doc->setResizable (false, false); doc->setUsingNativeTitleBar (true); ConfigurationWindow* cw = new ConfigurationWindow(); doc->setContentOwned (cw, true); doc->centreWithSize (cw->getWidth(), cw->getHeight()); doc->setVisible (true); } break; default: jassertfalse; return false; break; }; return true; }
void IndexReader::main(Collection<String> args) { String filename; bool extract = false; for (Collection<String>::iterator arg = args.begin(); arg != args.end(); ++arg) { if (*arg == L"-extract") { extract = true; } else if (filename.empty()) { filename = *arg; } } if (filename.empty()) { std::wcout << L"Usage: IndexReader [-extract] <cfsfile>"; return; } DirectoryPtr dir; CompoundFileReaderPtr cfr; LuceneException finally; try { String dirname(FileUtils::extractPath(filename)); filename = FileUtils::extractPath(filename); dir = FSDirectory::open(dirname); cfr = newLucene<CompoundFileReader>(dir, filename); HashSet<String> _files(cfr->listAll()); Collection<String> files(Collection<String>::newInstance(_files.begin(), _files.end())); std::sort(files.begin(), files.end()); // sort the array of filename so that the output is more readable for (Collection<String>::iterator file = files.begin(); file != files.end(); ++file) { int64_t len = cfr->fileLength(*file); if (extract) { std::wcout << L"extract " << *file << L" with " << len << L" bytes to local directory..."; IndexInputPtr ii(cfr->openInput(*file)); boost::filesystem::ofstream f(*file, std::ios::binary | std::ios::out); // read and write with a small buffer, which is more effective than reading byte by byte ByteArray buffer(ByteArray::newInstance(1024)); int32_t chunk = buffer.size(); while (len > 0) { int32_t bufLen = std::min(chunk, (int32_t)len); ii->readBytes(buffer.get(), 0, bufLen); f.write((char*)buffer.get(), bufLen); len -= bufLen; } ii->close(); } else { std::wcout << *file << L": " << len << " bytes\n"; } } } catch (LuceneException& e) { finally = e; } if (dir) { dir->close(); } if (cfr) { cfr->close(); } finally.throwException(); }
bool cAlarmServer::loadAlarms() { // load global alarm config from alarm-config.xml UtlString strAlarmFilename = SipXecsService::Path(SipXecsService::ConfigurationDirType, "alarm-config.xml"); UtlString strGroupFilename = SipXecsService::Path(SipXecsService::ConfigurationDirType, "alarm-groups.xml"); loadAlarmConfig(strAlarmFilename, strGroupFilename); // load specific alarm definitions from ${confdir}/alarms/*.xml UtlString alarmDefDir = SipXecsService::Path(SipXecsService::ConfigurationDirType); alarmDefDir.append("/alarms/"); OsSysLog::add(FAC_ALARM, PRI_INFO, "Looking for alarm def files in '%s'", alarmDefDir.data()); OsFileIterator files(alarmDefDir); OsPath entry; // for each file in the ${confdir}/alarms, load alarm definitions OsStatus status; int numFound; for (status=files.findFirst(entry, ".*\\.xml$", OsFileIterator::FILES), numFound=0; status == OS_SUCCESS; status = files.findNext(entry) ) { loadAlarmDefinitions(alarmDefDir + entry); } // load alarm strings and local language version from ${datadir}/alarms/*.xml UtlString alarmStringsDir = SipXecsService::Path(SipXecsService::DataDirType); alarmStringsDir.append("/alarms/"); OsSysLog::add(FAC_ALARM, PRI_INFO, "Looking for alarm string files in '%s'", alarmStringsDir.data()); OsFileIterator stringFiles(alarmStringsDir); // for each "base" file (*-strings.xml) in the ${datadir}/alarms, load alarm strings for (status=stringFiles.findFirst(entry, ".*-strings\\.xml$", OsFileIterator::FILES), numFound=0; status == OS_SUCCESS; status = stringFiles.findNext(entry) ) { loadAlarmStrings(alarmStringsDir + entry); } #ifdef DEBUG UtlHashMapIterator alarmIter(mAlarmMap); UtlString* alarmKey; int count=0; while ((alarmKey = dynamic_cast<UtlString*>(alarmIter()))) { cAlarmData* alarm = dynamic_cast<cAlarmData*>(alarmIter.value()); OsSysLog::add(FAC_ALARM, PRI_DEBUG, "alarm[%d]: %s %s: %s, Log:%d, Email:%d", count, alarmKey->data(), alarm->getCode().data(), OsSysLog::priorityName(alarm->getSeverity()), alarm->actions[cAlarmData::eActionLog], alarm->actions[cAlarmData::eActionEmail]); OsSysLog::add(FAC_ALARM, PRI_DEBUG, " Title:%s", alarm->getShortTitle().data()); OsSysLog::add(FAC_ALARM, PRI_DEBUG, " Description:%s", alarm->getDescription().data()); OsSysLog::add(FAC_ALARM, PRI_DEBUG, " Resolution:%s", alarm->getResolution().data()); count++; } #endif return true; }
// DoBuild //------------------------------------------------------------------------------ /*virtual*/ Node::BuildResult DirectoryListNode::DoBuild( Job * UNUSED( job ) ) { // NOTE: The DirectoryListNode makes no assumptions about whether no files // is an error or not. That's up to the dependent nodes to decide. Array< FileIO::FileInfo > files( 4096, true ); FileIO::GetFilesEx( m_Path, &m_Patterns, m_Recursive, &files ); m_Files.SetCapacity( files.GetSize() ); // filter exclusions const FileIO::FileInfo * const end = files.End(); for ( const FileIO::FileInfo * it = files.Begin(); it != end; it++ ) { bool excluded = false; // filter excluded paths const AString * const eEnd = m_ExcludePaths.End(); for ( const AString * eIt=m_ExcludePaths.Begin(); eIt != eEnd; ++eIt ) { if ( PathUtils::PathBeginsWith( it->m_Name, *eIt ) ) { excluded = true; break; } } // filter excluded files if ( !excluded ) { const AString * fit = m_FilesToExclude.Begin(); const AString * const fend = m_FilesToExclude.End(); for ( ; fit != fend; ++fit ) { if ( PathUtils::PathEndsWithFile( it->m_Name, *fit ) ) { excluded = true; break; } } } if ( !excluded ) { m_Files.Append( *it ); } } if ( FLog::ShowInfo() ) { const size_t numFiles = m_Files.GetSize(); FLOG_INFO( "Dir: '%s' (found %u files)\n", m_Name.Get(), (uint32_t)numFiles); for ( size_t i=0; i<numFiles; ++i ) { FLOG_INFO( " - %s\n", m_Files[ i ].m_Name.Get() ); } } return NODE_RESULT_OK; }
/// This is where the link is actually performed. bool Driver::link(const TargetInfo &targetInfo) { // Honor -mllvm if (!targetInfo.llvmOptions().empty()) { unsigned numArgs = targetInfo.llvmOptions().size(); const char **args = new const char*[numArgs + 2]; args[0] = "lld (LLVM option parsing)"; for (unsigned i = 0; i != numArgs; ++i) args[i + 1] = targetInfo.llvmOptions()[i]; args[numArgs + 1] = 0; llvm::cl::ParseCommandLineOptions(numArgs + 1, args); } // Read inputs ScopedTask readTask(getDefaultDomain(), "Read Args"); std::vector<std::vector<std::unique_ptr<File>>> files( targetInfo.inputFiles().size()); size_t index = 0; std::atomic<bool> fail(false); TaskGroup tg; for (const auto &input : targetInfo.inputFiles()) { if (targetInfo.logInputFiles()) llvm::outs() << input.getPath() << "\n"; tg.spawn([ &, index]{ if (error_code ec = targetInfo.readFile(input.getPath(), files[index])) { llvm::errs() << "Failed to read file: " << input.getPath() << ": " << ec.message() << "\n"; fail = true; return; } }); ++index; } tg.sync(); readTask.end(); if (fail) return true; InputFiles inputs; for (auto &f : files) inputs.appendFiles(f); // Give target a chance to add files. targetInfo.addImplicitFiles(inputs); // assign an ordinal to each file so sort() can preserve command line order inputs.assignFileOrdinals(); // Do core linking. ScopedTask resolveTask(getDefaultDomain(), "Resolve"); Resolver resolver(targetInfo, inputs); if (resolver.resolve()) { if (!targetInfo.allowRemainingUndefines()) return true; } MutableFile &merged = resolver.resultFile(); resolveTask.end(); // Run passes on linked atoms. ScopedTask passTask(getDefaultDomain(), "Passes"); PassManager pm; targetInfo.addPasses(pm); pm.runOnFile(merged); passTask.end(); // Give linked atoms to Writer to generate output file. ScopedTask writeTask(getDefaultDomain(), "Write"); if (error_code ec = targetInfo.writeFile(merged)) { llvm::errs() << "Failed to write file '" << targetInfo.outputPath() << "': " << ec.message() << "\n"; return true; } return false; }
DWORD ParseArgs(int argc, char* argv[]) // This function parses arguments given to the client application // // argc : The number of arguments // argv : The array pointing to the arguments { try { po::options_description certtoolArgs(""); po::options_description desc("certool general command options"); po::options_description config("configuration file format ( for example see : certool.cfg )"); po::options_description init("CA server initialization functions"); po::options_description functions("14 managment functions"); po::options_description files("certificate data files"); po::options_description params("additional params"); AddGeneralOptions(desc); AddConfigOptions(config); AddInitOptions(init); AddFunctionsOptions(functions); AddFilesOptions(files); AddParamOptions(params); certtoolArgs. add(desc). add(config). add(init). add(functions). add(files). add(params); po::store(po::parse_command_line(argc, argv, certtoolArgs), argsMap); po::notify(argsMap); if (argsMap.count("help") || argc == 1) { if (argHelpModule.compare("init") == 0) { std::cout << init << "\n"; return ERROR_SUCCESS; } if (argHelpModule.compare("functions") == 0) { std::cout << functions << "\n"; return ERROR_SUCCESS; } if (argHelpModule.compare("config") == 0) { std::cout << config << "\n"; return ERROR_SUCCESS; } if (argHelpModule.compare("files") == 0) { std::cout << files << "\n"; return ERROR_SUCCESS; } std::cout << desc << "\n"; return ERROR_SUCCESS; } return DispatchCmd(argsMap, config); } catch (std::bad_alloc& e) { std::cerr << "error - Allocation failed -" << e.what() << std::endl; return VMCA_OUT_MEMORY_ERR; } catch (std::exception& e) { std::cerr << "error: " << e.what() << "\n"; return VMCA_UNKNOW_ERROR; } catch(...) { std::cerr << "Exception of unknown type!\n"; return VMCA_UNKNOW_ERROR; } }