bool parse_config(const char* config_file, Arguments& args) { std::ifstream config_stream(config_file); if (!config_stream) { fprintf(stderr, "ERROR: cannot find config file\n"); return false; } config_stream >> args.config; // parse JSON return true; }
void ConfigTable::parse_config_file(const std::string& config_file) { std::ifstream config_stream(config_file.c_str()); if(!config_stream) { std::clog << "ConfigTable: Error: Could not open file " << config_file << "." << std::endl; return; } po::store(po::parse_config_file(config_stream, options.options), options.variables); notify(options.variables); }
void FFM::avito_init_params(const std::string & data_conf_path) { bool debug = false; std::ifstream config_stream((char*)data_conf_path.c_str(), std::ios::in); std::string line; std::string token; std::string header; // Read header: for(unsigned int i = 0; i < 8; i++){ getline(config_stream, line); } std::istringstream line_stream(line); while(line_stream){ if (!getline( line_stream, token, ':' )) break; } if(debug) std::cout << "Default hash: " << token << std::endl; bool useDefaultHash = ( token != "false" ) ? true : false; if ( useDefaultHash ){ num_features = atoi(token.c_str()); } getline(config_stream, line); getline(config_stream, line); unsigned int feature_count = 0; while(getline(config_stream, line)){ std::istringstream hash_stream(line); getline( hash_stream, header, ':' ); getline( hash_stream, token, ':' ); num_fields++; if ( !useDefaultHash ) { num_features += atoi(token.c_str()); } if(debug) std::cout << header << ": " << token << " Current inputDim: " << num_features << std::endl; feature_count++; } if(debug) std::cout << "Num-features: " << num_features << std::endl; initParams(); }
Imbalancer::Imbalancer(const std::string config_path) : Imbalancer() { if (config_path.length()) { char hostname[HOST_NAME_MAX + 1]; hostname[HOST_NAME_MAX] = '\0'; if (gethostname(hostname, HOST_NAME_MAX)) { throw geopm::Exception("gethostname():", errno ? errno : GEOPM_ERROR_RUNTIME, __FILE__, __LINE__); } std::ifstream config_stream(config_path, std::ifstream::in); std::string this_host; double this_frac; while(config_stream.good()) { config_stream >> this_host >> this_frac; if (strncmp(hostname, this_host.c_str(), HOST_NAME_MAX) == 0) { frac(this_frac); } } config_stream.close(); }
rapidjson::Document parseJSONConfig(const std::string &config_filename) { rapidjson::Document config_doc; FILE *config_file_ptr = fopen(config_filename.c_str(), "r"); if (!config_file_ptr) { throw std::runtime_error( (boost::format("Cannot open configuration input file %s.") % config_filename).str() ); } char readBuffer[65536]; rapidjson::FileReadStream config_stream(config_file_ptr, readBuffer, sizeof(readBuffer)); config_doc.ParseStream(config_stream); if (config_doc.HasParseError()) { throw std::runtime_error( (boost::format("Error parsing %s (offset %d):\t%s") % config_filename % config_doc.GetErrorOffset() % rapidjson::GetParseError_En(config_doc.GetParseError())).str() ); } fclose(config_file_ptr); return config_doc; }
rapidjson::Document parseJSONConfig(const std::string &config_filename) { rapidjson::Document config_doc; FILE* config_file_ptr = fopen(config_filename.c_str(), "r"); if (!config_file_ptr) { throw std::runtime_error( (boost::format("Cannot open configuration input file %s.") % config_filename).str() ); } char readBuffer[65536]; rapidjson::FileReadStream config_stream(config_file_ptr, readBuffer, sizeof(readBuffer)); config_doc.ParseStream(config_stream); fclose(config_file_ptr); if (!config_doc.IsObject()) { throw std::runtime_error( (boost::format("Invalid configuration file: %s") % config_filename).str() ); } return config_doc; }
void FFM::read_conf(const std::string &conf_path) { bool debug = false; std::ifstream config_stream((char*)conf_path.c_str(), std::ios::in); std::istringstream line_stream; std::string line; std::string token; // Read header: getline(config_stream, line); //Read parameters: getline(config_stream, line); line_stream.str(line); while(line_stream){ if (!getline( line_stream, token, '=' )) break; } parameters.num_factors = atoi(token.c_str()); line_stream.str(std::string()); line_stream.clear(); if(debug) std::cout << "num_factors: " << token << " " << parameters.num_factors << std::endl; //Read parameters: getline(config_stream, line); line_stream.str(line); while(line_stream){ if (!getline( line_stream, token, '=' )) break; } parameters.stepsize = atof(token.c_str()); line_stream.str(std::string()); line_stream.clear(); if(debug) std::cout << "stepsize: " << token << " " << parameters.stepsize << std::endl; //Read parameters: getline(config_stream, line); line_stream.str(line); while(line_stream){ if (!getline( line_stream, token, '=' )) break; } parameters.stepsize_decay = atof(token.c_str()); line_stream.str(std::string()); line_stream.clear(); if(debug) std::cout << "stepsize_decay: " << token << " " << parameters.stepsize_decay << std::endl; //Read parameters: getline(config_stream, line); line_stream.str(line); while(line_stream){ if (!getline( line_stream, token, '=' )) break; } parameters.l1_lambda_v = atof(token.c_str()); line_stream.str(std::string()); line_stream.clear(); if(debug) std::cout << "l1_lambda_v:" << token << " " << parameters.l1_lambda_v << std::endl; //Read parameters: getline(config_stream, line); line_stream.str(line); while(line_stream){ if (!getline( line_stream, token, '=' )) break; } parameters.l2_lambda_v = atof(token.c_str()); line_stream.str(std::string()); line_stream.clear(); if(debug) std::cout << "l2_lambda_v:" << token << " " << parameters.l2_lambda_v << std::endl; //Read parameters: getline(config_stream, line); line_stream.str(line); while(line_stream){ if (!getline( line_stream, token, '=' )) break; } parameters.epochs = atoi(token.c_str()); line_stream.str(std::string()); line_stream.clear(); if(debug) std::cout << "epochs:" << token << " " << parameters.epochs << std::endl; //Read parameters: getline(config_stream, line); line_stream.str(line); while(line_stream){ if (!getline( line_stream, token, '=' )) break; } num_features = atoi(token.c_str()); line_stream.str(std::string()); line_stream.clear(); if(debug) std::cout << "num_features:" << token << " " << num_features << std::endl; }
// generate boost::program_options object for the routing part inline unsigned GenerateServerProgramOptions(const int argc, const char *argv[], ServerPaths &paths, std::string &ip_address, int &ip_port, int &requested_num_threads, bool &use_shared_memory, bool &trial, int &max_locations_distance_table, int &max_locations_map_matching) { // declare a group of options that will be allowed only on command line boost::program_options::options_description generic_options("Options"); generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")( "config,c", boost::program_options::value<boost::filesystem::path>(&paths["config"]) ->default_value("server.ini"), "Path to a configuration file")( "trial", boost::program_options::value<bool>(&trial)->implicit_value(true), "Quit after initialization"); // declare a group of options that will be allowed both on command line // as well as in a config file boost::program_options::options_description config_options("Configuration"); config_options.add_options()( "hsgrdata", boost::program_options::value<boost::filesystem::path>(&paths["hsgrdata"]), ".hsgr file")("nodesdata", boost::program_options::value<boost::filesystem::path>(&paths["nodesdata"]), ".nodes file")( "edgesdata", boost::program_options::value<boost::filesystem::path>(&paths["edgesdata"]), ".edges file")("geometry", boost::program_options::value<boost::filesystem::path>(&paths["geometries"]), ".geometry file")( "ramindex", boost::program_options::value<boost::filesystem::path>(&paths["ramindex"]), ".ramIndex file")( "fileindex", boost::program_options::value<boost::filesystem::path>(&paths["fileindex"]), "File index file")( "namesdata", boost::program_options::value<boost::filesystem::path>(&paths["namesdata"]), ".names file")("timestamp", boost::program_options::value<boost::filesystem::path>(&paths["timestamp"]), ".timestamp file")( "ip,i", boost::program_options::value<std::string>(&ip_address)->default_value("0.0.0.0"), "IP address")("port,p", boost::program_options::value<int>(&ip_port)->default_value(5000), "TCP/IP port")( "threads,t", boost::program_options::value<int>(&requested_num_threads)->default_value(8), "Number of threads to use")( "shared-memory,s", boost::program_options::value<bool>(&use_shared_memory)->implicit_value(true), "Load data from shared memory")( "max-table-size,m", boost::program_options::value<int>(&max_locations_distance_table)->default_value(1000000), "Max. locations supported in distance table query")( "max-matching-size,m", boost::program_options::value<int>(&max_locations_map_matching)->default_value(2), "Max. locations supported in map matching query"); // hidden options, will be allowed both on command line and in config // file, but will not be shown to the user boost::program_options::options_description hidden_options("Hidden options"); hidden_options.add_options()( "base,b", boost::program_options::value<boost::filesystem::path>(&paths["base"]), "base path to .osrm file"); // positional option boost::program_options::positional_options_description positional_options; positional_options.add("base", 1); // combine above options for parsing boost::program_options::options_description cmdline_options; cmdline_options.add(generic_options).add(config_options).add(hidden_options); boost::program_options::options_description config_file_options; config_file_options.add(config_options).add(hidden_options); boost::program_options::options_description visible_options( boost::filesystem::basename(argv[0]) + " <base.osrm> [<options>]"); visible_options.add(generic_options).add(config_options); // parse command line options boost::program_options::variables_map option_variables; boost::program_options::store(boost::program_options::command_line_parser(argc, argv) .options(cmdline_options) .positional(positional_options) .run(), option_variables); if (option_variables.count("version")) { SimpleLogger().Write() << g_GIT_DESCRIPTION; return INIT_OK_DO_NOT_START_ENGINE; } if (option_variables.count("help")) { SimpleLogger().Write() << visible_options; return INIT_OK_DO_NOT_START_ENGINE; } boost::program_options::notify(option_variables); // parse config file auto path_iterator = paths.find("config"); if (path_iterator != paths.end() && boost::filesystem::is_regular_file(path_iterator->second) && !option_variables.count("base")) { SimpleLogger().Write() << "Reading options from: " << path_iterator->second.string(); std::string ini_file_contents = read_file_lower_content(path_iterator->second); std::stringstream config_stream(ini_file_contents); boost::program_options::store(parse_config_file(config_stream, config_file_options), option_variables); boost::program_options::notify(option_variables); return INIT_OK_START_ENGINE; } if (1 > requested_num_threads) { throw osrm::exception("Number of threads must be a positive number"); } if (!use_shared_memory && option_variables.count("base")) { return INIT_OK_START_ENGINE; } if (use_shared_memory && !option_variables.count("base")) { return INIT_OK_START_ENGINE; } if (1 > max_locations_distance_table) { throw osrm::exception("Max location for distance table must be a positive number"); } if (2 > max_locations_map_matching) { throw osrm::exception("Max location for map matching must be at least two"); } SimpleLogger().Write() << visible_options; return INIT_OK_DO_NOT_START_ENGINE; }
return_code ExtractorOptions::ParseArguments(int argc, char *argv[], ExtractorConfig &extractor_config) { // declare a group of options that will be allowed only on command line boost::program_options::options_description generic_options("Options"); generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")( "config,c", boost::program_options::value<boost::filesystem::path>( &extractor_config.config_file_path)->default_value("extractor.ini"), "Path to a configuration file."); // declare a group of options that will be allowed both on command line and in config file boost::program_options::options_description config_options("Configuration"); config_options.add_options()("profile,p", boost::program_options::value<boost::filesystem::path>( &extractor_config.profile_path)->default_value("profile.lua"), "Path to LUA routing profile")( "threads,t", boost::program_options::value<unsigned int>(&extractor_config.requested_num_threads) ->default_value(tbb::task_scheduler_init::default_num_threads()), "Number of threads to use"); // hidden options, will be allowed both on command line and in config file, but will not be // shown to the user boost::program_options::options_description hidden_options("Hidden options"); hidden_options.add_options()("input,i", boost::program_options::value<boost::filesystem::path>( &extractor_config.input_path), "Input file in .osm, .osm.bz2 or .osm.pbf format"); // positional option boost::program_options::positional_options_description positional_options; positional_options.add("input", 1); // combine above options for parsing boost::program_options::options_description cmdline_options; cmdline_options.add(generic_options).add(config_options).add(hidden_options); boost::program_options::options_description config_file_options; config_file_options.add(config_options).add(hidden_options); boost::program_options::options_description visible_options( boost::filesystem::basename(argv[0]) + " <input.osm/.osm.bz2/.osm.pbf> [options]"); visible_options.add(generic_options).add(config_options); // parse command line options try { boost::program_options::variables_map option_variables; boost::program_options::store(boost::program_options::command_line_parser(argc, argv) .options(cmdline_options) .positional(positional_options) .run(), option_variables); if (option_variables.count("version")) { SimpleLogger().Write() << g_GIT_DESCRIPTION; return return_code::exit; } if (option_variables.count("help")) { SimpleLogger().Write() << visible_options; return return_code::exit; } boost::program_options::notify(option_variables); // parse config file if (boost::filesystem::is_regular_file(extractor_config.config_file_path)) { SimpleLogger().Write() << "Reading options from: " << extractor_config.config_file_path.string(); std::string ini_file_contents = read_file_lower_content(extractor_config.config_file_path); std::stringstream config_stream(ini_file_contents); boost::program_options::store(parse_config_file(config_stream, config_file_options), option_variables); boost::program_options::notify(option_variables); } if (!option_variables.count("input")) { SimpleLogger().Write() << visible_options; return return_code::exit; } } catch (std::exception &e) { SimpleLogger().Write(logWARNING) << e.what(); return return_code::fail; } return return_code::ok; }
int main(int argc, char* argv[]) { //************************************************ // Initialize environments //************************************************ MPI_Init(&argc,&argv); int rank; MPI_Comm_rank(MPI_COMM_WORLD, &rank); // variables to be filled by command line and/or input file values std::string inputFile; double priorMean; double priorVar; std::string dataString; likelihoodData dat; po::options_description generic("Generic options"); generic.add_options() ("help,h", "Produce help message"); po::options_description config("GaussianMean1DRegression specific options"); config.add_options() ("GaussianMean1DRegression_priorMean", po::value<double>(&priorMean)->default_value(priorMeanODV), "Prior Mean") ("GaussianMean1DRegression_priorVar", po::value<double>(&priorVar)->default_value(priorVarODV), "Prior Standard Deviation") ("GaussianMean1DRegression_samplingVar", po::value<double>(&dat.samplingVar)->default_value(samplingVarODV), "Data Sampling Standard Deviation") ("GaussianMean1DRegression_dataSet", po::value<std::string>(&dataString)->default_value(dataSetODV), "Calibration Data"); po::options_description hidden("hidden options"); hidden.add_options() ("input_file", po::value<std::string>(&inputFile)->default_value(inputFileODV), "QUESO configuration file"); po::positional_options_description p; p.add("input_file", -1); po::options_description cmdline_options; cmdline_options.add(generic).add(config).add(hidden); po::options_description visible("Allowed options"); visible.add(generic).add(config); // parse command line for help, inputFile, and any config options present po::variables_map vm; try { po::store(po::command_line_parser(argc, argv). options(cmdline_options).positional(p).run(), vm); } catch (std::exception& e) { if(rank == 0) std::cout<<"Caught exception: "<<e.what()<<std::endl; MPI_Abort(MPI_COMM_WORLD, -1); } po::notify(vm); // if help is requested, print out usgae and visible options, then exit cleanly if (vm.count("help")) { if (rank == 0) { std::cout << "Usage: " << argv[0] << " <input_file (=" << inputFileODV << ")>" << std::endl; std::cout << visible << std::endl; } MPI_Finalize(); return 1; } // parse the input file to get GaussianMean1DRegression option values std::ifstream config_stream(inputFile.c_str()); try { po::store(po::parse_config_file(config_stream, config, true), vm); } catch (std::exception& e) { if(rank == 0) std::cout << "Caught exception: " << e.what() << std::endl; MPI_Abort(MPI_COMM_WORLD, -1); } po::notify(vm); config_stream.close(); // parse the data string into a vector of doubles and store them in dat.dataSet std::istringstream iss(dataString); std::copy(std::istream_iterator<double>(iss), std::istream_iterator<double>(), std::back_inserter(dat.dataSet)); // output the option values that will be used by QUESO if (rank == 0) { std::cout << "QUESO options file: " << inputFile << std::endl; std::cout << "Read option GaussianMean1DRegression_priorMean: " << priorMean << std::endl; std::cout << "Read option GaussianMean1DRegression_priorVar: " << priorVar << std::endl; std::cout << "Read option GaussianMean1DRegression_samplingVar: " << dat.samplingVar << std::endl; std::cout << "Read option GaussianMean1DRegression_dataSet: "; for (unsigned int i = 0; i < dat.dataSet.size(); i++) std::cout << dat.dataSet[i] << " "; std::cout << std::endl; } // initilize environment QUESO::FullEnvironment env(MPI_COMM_WORLD, // MPI communicator inputFile.c_str(), // input file name "", // name prefix NULL ); // alt options // reset seed to value in input file + fullRank env.resetSeed(env.seed() + env.fullRank()); // Work routine, with GSL GaussianMean1DRegressionCompute<QUESO::GslVector, QUESO::GslMatrix>(env, priorMean, priorVar, dat); MPI_Finalize(); return 0; }
//------------------------------------------------------------------------------ // Purpose : Parse the command line and config file // Parameters : argc, argv // Returns : Filled-in Options structure //------------------------------------------------------------------------------ Options GetOptions(int argc, char * const argv[]) { // Read command line options Options opt; po::options_description desc("Allowed options"); desc.add_options() ("help,h", "Show this message") ("callsign", po::value<string>(&opt.callsign), "Sender's Callsign") ("sequence", po::value<int>(&opt.sequence)->default_value(1), "Message Sequence Number") ("user", po::value<string>(&opt.user), "Google User Name") ("password", po::value<string>(&opt.password), "Google Password") ("from", po::value<string>(&opt.from), "FM Addee") ("to", po::value<string>(&opt.to), "TO Addee") ("info", po::value<string>(&opt.info), "INFO Addee") ("subject", po::value<string>(&opt.subject), "Message Subject") ("spreadsheet-name", po::value<string>(&opt.spreadsheet_name), "Spreadsheet Name") ("spreadsheet-id", po::value<string>(&opt.spreadsheet_id), "Spreadsheet ID") ("worksheet-name", po::value<string>(&opt.worksheet_name), "Worksheet Name") ("worksheet-id", po::value<string>(&opt.worksheet_id), "Worksheet ID") ; // Config file string config_file = ExpandDirectory("~/.thirteenrc"); fs::path config_path(config_file); // Load configuration po::variables_map vm; try { po::store(po::parse_command_line(argc, argv, desc), vm); if(fs::exists(config_path)) { ifstream config_stream(config_file.c_str()); po::store(po::parse_config_file(config_stream, desc), vm); } } catch(exception& e) { cerr << "Unable to parse command line: " << e.what() << endl; exit(1); } po::notify(vm); if (vm.count("help")) { cout << desc << "\n"; exit(1); } // Test for errors vector<string> errors; if(!(opt.spreadsheet_name.size() || opt.spreadsheet_id.size())) { errors.push_back("Either a spreadsheet name or a spreadsheet" " id must be specified"); } if(!opt.user.size()) { errors.push_back("No Google Docs user specified"); } if(!opt.password.size()) { errors.push_back("No Google Docs password specified"); } if(!opt.from.size()) { errors.push_back("No FM addee specified"); } if(!opt.to.size()) { errors.push_back("No TO addee specified"); } if(!opt.info.size()) { errors.push_back("No INFO addee specified"); } if(!opt.subject.size()) { errors.push_back("No subject specified"); } if(errors.size()) { cout << "Error:" << endl; BOOST_FOREACH(string error, errors) { cout << " " << error << endl; } exit(1); }
int main (int argc, char *argv[]) { try { LogPolicy::GetInstance().Unmute(); double startup_time = get_timestamp(); boost::filesystem::path config_file_path, input_path, profile_path; int requested_num_threads; // declare a group of options that will be allowed only on command line boost::program_options::options_description generic_options("Options"); generic_options.add_options() ("version,v", "Show version") ("help,h", "Show this help message") ("config,c", boost::program_options::value<boost::filesystem::path>(&config_file_path)->default_value("extractor.ini"), "Path to a configuration file."); // declare a group of options that will be allowed both on command line and in config file boost::program_options::options_description config_options("Configuration"); config_options.add_options() ("profile,p", boost::program_options::value<boost::filesystem::path>(&profile_path)->default_value("profile.lua"), "Path to LUA routing profile") ("threads,t", boost::program_options::value<int>(&requested_num_threads)->default_value(8), "Number of threads to use"); // hidden options, will be allowed both on command line and in config file, but will not be shown to the user boost::program_options::options_description hidden_options("Hidden options"); hidden_options.add_options() ("input,i", boost::program_options::value<boost::filesystem::path>(&input_path), "Input file in .osm, .osm.bz2 or .osm.pbf format"); // positional option boost::program_options::positional_options_description positional_options; positional_options.add("input", 1); // combine above options for parsing boost::program_options::options_description cmdline_options; cmdline_options.add(generic_options).add(config_options).add(hidden_options); boost::program_options::options_description config_file_options; config_file_options.add(config_options).add(hidden_options); boost::program_options::options_description visible_options(boost::filesystem::basename(argv[0]) + " <input.osm/.osm.bz2/.osm.pbf> [options]"); visible_options.add(generic_options).add(config_options); // parse command line options boost::program_options::variables_map option_variables; boost::program_options::store(boost::program_options::command_line_parser(argc, argv). options(cmdline_options).positional(positional_options).run(), option_variables); if(option_variables.count("version")) { SimpleLogger().Write() << g_GIT_DESCRIPTION; return 0; } if(option_variables.count("help")) { SimpleLogger().Write() << visible_options; return 0; } boost::program_options::notify(option_variables); // parse config file if(boost::filesystem::is_regular_file(config_file_path)) { SimpleLogger().Write() << "Reading options from: " << config_file_path.c_str(); std::string config_str; PrepareConfigFile( config_file_path.c_str(), config_str ); std::stringstream config_stream( config_str ); boost::program_options::store(parse_config_file(config_stream, config_file_options), option_variables); boost::program_options::notify(option_variables); } if(!option_variables.count("input")) { SimpleLogger().Write(logWARNING) << "No input file specified"; SimpleLogger().Write() << visible_options; return -1; } if(1 > requested_num_threads) { SimpleLogger().Write(logWARNING) << "Number of threads must be 1 or larger"; return -1; } SimpleLogger().Write() << "Input file: " << input_path.filename().string(); SimpleLogger().Write() << "Profile: " << profile_path.filename().string(); SimpleLogger().Write() << "Threads: " << requested_num_threads; /*** Setup Scripting Environment ***/ ScriptingEnvironment scriptingEnvironment(profile_path.c_str()); omp_set_num_threads( std::min( omp_get_num_procs(), requested_num_threads) ); bool file_has_pbf_format(false); std::string output_file_name(input_path.c_str()); std::string restrictionsFileName(input_path.c_str()); std::string::size_type pos = output_file_name.find(".osm.bz2"); if(pos==std::string::npos) { pos = output_file_name.find(".osm.pbf"); if(pos!=std::string::npos) { file_has_pbf_format = true; } } if(pos==std::string::npos) { pos = output_file_name.find(".pbf"); if(pos!=std::string::npos) { file_has_pbf_format = true; } } if(pos!=std::string::npos) { output_file_name.replace(pos, 8, ".osrm"); restrictionsFileName.replace(pos, 8, ".osrm.restrictions"); } else { pos=output_file_name.find(".osm"); if(pos!=std::string::npos) { output_file_name.replace(pos, 5, ".osrm"); restrictionsFileName.replace(pos, 5, ".osrm.restrictions"); } else { output_file_name.append(".osrm"); restrictionsFileName.append(".osrm.restrictions"); } } StringMap stringMap; ExtractionContainers externalMemory; stringMap[""] = 0; extractCallBacks = new ExtractorCallbacks(&externalMemory, &stringMap); BaseParser* parser; if(file_has_pbf_format) { parser = new PBFParser(input_path.c_str(), extractCallBacks, scriptingEnvironment); } else { parser = new XMLParser(input_path.c_str(), extractCallBacks, scriptingEnvironment); } if(!parser->ReadHeader()) { throw OSRMException("Parser not initialized!"); } SimpleLogger().Write() << "Parsing in progress.."; double parsing_start_time = get_timestamp(); parser->Parse(); SimpleLogger().Write() << "Parsing finished after " << (get_timestamp() - parsing_start_time) << " seconds"; if( externalMemory.all_edges_list.empty() ) { SimpleLogger().Write(logWARNING) << "The input data is empty, exiting."; return -1; } externalMemory.PrepareData(output_file_name, restrictionsFileName); delete parser; delete extractCallBacks; SimpleLogger().Write() << "extraction finished after " << get_timestamp() - startup_time << "s"; SimpleLogger().Write() << "To prepare the data for routing, run: " << "./osrm-prepare " << output_file_name << std::endl; } catch(boost::program_options::too_many_positional_options_error& e) { SimpleLogger().Write(logWARNING) << "Only one input file can be specified"; return -1; } catch(boost::program_options::error& e) { SimpleLogger().Write(logWARNING) << e.what(); return -1; } catch(std::exception & e) { SimpleLogger().Write(logWARNING) << "Unhandled exception: " << e.what(); return -1; } return 0; }
void init_gamedata(gamedata &g){ //--JAM: Read from config file ap_home = getHomeDir(ap_home); string filename((string)ap_home); filename += "apricots.cfg"; printf("Filename: %s\n", filename.c_str()); ifstream config_stream(filename.c_str()); string config; if (!config_stream.fail()){ // Read config file line by line char line[256]; while (!config_stream.eof()){ config_stream.getline(line, 255); if (line[0] != '#'){ config.append(line); config += "\n"; } } }else{ // Config file not found config = "\n"; } config_stream.close(); // Number of planes (1-6) g.planes = getConfig(config, "NUM_PLANES", 2, 1, 6); // Number of players (1 or 2) g.players = getConfig(config, "NUM_HUMANS", 1, 1, 2); // Error check if (g.players > g.planes){ cerr << "Invalid configuration in apricots.cfg" << endl; cerr << "Number of human players cannot exceed number of planes" << endl; exit(EXIT_FAILURE); } // Mission // 0/1 means winner is first to reach targetscore and reach airbase // 1 makes score reduce to targetscore-200 upon dying (so must land) // 2 means winner is first to destroy all enemy airbases and reach airbase g.mission = getConfig(config, "MISSION", 0, 0, 2); // Targetscore for missions 0/1 g.targetscore = getConfig(config, "TARGET_SCORE", 1400, 100, 5000); // Planetypes: 1=Spitfire, 2=Jet, 3=Stealth Bomber g.planeinfo[1].planetype = getConfig(config, "PLANE1", 1, 1, 3); g.planeinfo[2].planetype = getConfig(config, "PLANE2", 1, 1, 3); g.planeinfo[3].planetype = getConfig(config, "PLANE3", 1, 1, 3); g.planeinfo[4].planetype = getConfig(config, "PLANE4", 1, 1, 3); g.planeinfo[5].planetype = getConfig(config, "PLANE5", 1, 1, 3); g.planeinfo[6].planetype = getConfig(config, "PLANE6", 1, 1, 3); // Basetype: See create_airbases in setup.cpp g.planeinfo[1].basetype = getConfig(config, "BASE1", 1, 1, 7); g.planeinfo[2].basetype = getConfig(config, "BASE2", 1, 1, 7); g.planeinfo[3].basetype = getConfig(config, "BASE3", 1, 1, 7); g.planeinfo[4].basetype = getConfig(config, "BASE4", 1, 1, 7); g.planeinfo[5].basetype = getConfig(config, "BASE5", 1, 1, 7); g.planeinfo[6].basetype = getConfig(config, "BASE6", 1, 1, 7); // Control: 1=Player 1, 2=Player 2, 0=AI g.planeinfo[1].control = getConfig(config, "CONTROL1", 1, 0, 2); g.planeinfo[2].control = getConfig(config, "CONTROL2", 0, 0, 2); g.planeinfo[3].control = getConfig(config, "CONTROL3", 0, 0, 2); g.planeinfo[4].control = getConfig(config, "CONTROL4", 0, 0, 2); g.planeinfo[5].control = getConfig(config, "CONTROL5", 0, 0, 2); g.planeinfo[6].control = getConfig(config, "CONTROL6", 0, 0, 2); // Error check int count[3]; count[0] = 0; count[1] = 0; count[2] = 0; for (int i=1; i<=g.planes; i++){ count[g.planeinfo[i].control]++; } if (count[1] != 1){ cerr << "Invalid configuration in apricots.cfg" << endl; cerr << "Invalid control selection for player 1" << endl; exit(EXIT_FAILURE); } if (count[2] != (g.players-1)){ cerr << "Invalid configuration in apricots.cfg" << endl; cerr << "Invalid control selection for player 2" << endl; exit(EXIT_FAILURE); } for (int j=g.planes+1;j<=6;j++){ if (g.planeinfo[j].control > 0){ cerr << "Invalid configuration in apricots.cfg" << endl; cerr << "Human controls specified for non-playing plane" << endl; exit(EXIT_FAILURE); } } // Number of towerblocks g.towers = getConfig(config, "NUM_TOWERS", 5, 0, 30); // Number of neutral anti-aircraft guns g.guns = getConfig(config, "NUM_GUNS", 5, 0, 20); // Number of other buildings g.buildings = getConfig(config, "NUM_BUILDINGS", 20, 0 ,50); // Number of trees (max) g.trees = getConfig(config, "NUM_TREES", 50, 0, 100); // Draks: 0=Never, 1=5% probability, 2=Always string drakval = getConfig(config, "DRAK", "sometimes"); if (!drakval.compare("always")) { g.drakoption = 2; } else if (!drakval.compare("sometimes")) { g.drakoption = 1; } else { g.drakoption = 0; } g.playerJoy[0] = -1; g.playerJoy[1] = -1; g.playerJoyBut[0][0] = -1; g.playerJoyBut[0][1] = -1; g.playerJoyBut[0][2] = -1; g.playerJoyBut[1][0] = -1; g.playerJoyBut[1][1] = -1; g.playerJoyBut[1][2] = -1; // Score bar position g.scoreBarPos = getConfig(config, "SCOREBAR_POS", 0, 0, 1); }
bool ParseString(const std::string &config_string) { std::stringstream config_stream(config_string); return parser_.Parse(&config_stream, &config_); }