C++ (Cpp) parse_program_options Examples

Example #1

File: irods_parse_command_line_options.cpp Project: nesi/irods

// single C-friendly interface for the above two functions
int parse_opts_and_paths(
    int               _argc,
    char**            _argv,
    rodsArguments_t&  _rods_args,
    rodsEnv*          _rods_env,
    int               _src_type,
    int               _dst_type,
    int               _flag,
    rodsPathInp_t*    _rods_paths ) {

    path_list_t paths;
    int p_err = parse_program_options(
                    _argc,
                    _argv,
                    _rods_args,
                    paths );
    if( p_err < 0 ) {
        return p_err;

    }

    p_err = build_irods_path_structure(
                 paths,
                 _rods_env,
                 _src_type,
                 _dst_type,
                 _flag,
                 _rods_paths );
    if( p_err < 0 ) {
        return p_err;
    }

    return 0;

} // parse_opts_and_paths

Example #2

File: mytrace.cpp Project: meungochoo/2015_fall_computer_security

int main(int argn, char* argv[])
{
	po::variables_map vm = parse_program_options(argn, argv);

	if(vm.empty() || vm.count("help"))
	{
		return 0;
	}

	pid_t child_pid = fork();

	if(child_pid == 0)
	{
		// Make args string vector into null-terminated char* array
		std::vector<std::string> args_vec = vm["commands"].as<std::vector<std::string>>();
		std::vector<char*> args;

		for(auto& arg : args_vec)
		{
			args.push_back(const_cast<char*>(arg.c_str()));
		}

		args.push_back(nullptr);

		// Run given process
		if(!run_child(args_vec.front(), args.data()))
		{
			std::cerr << "Error : Failed to execute and trace the given commands." << std::endl;
		}
	}
	else if(child_pid == -1)
	{
		std::cerr << "Error : Failed to execute the given commands." << std::endl;
	}
	else
	{
		Tracer tracer;
		tracer.do_trace(child_pid, vm);
	}

	return 0;
}

Example #3

File: random_features.cpp Project: TPNguyen/libskylark

int main(int argc, char* argv[]) {

    El::Initialize(argc, argv);

    int seed, s, mind;
    std::string infile, outfile;
    double sigma;

    int flag = parse_program_options(argc, argv, seed, s, mind,
        infile, outfile, sigma);
    if (flag != 1000)
        return flag;

    skylark::base::context_t context(seed);

    boost::mpi::communicator world;
    int rank = world.rank();

    typedef El::DistMatrix<double, El::STAR, El::VR> data_matrix_t;
    typedef El::DistMatrix<El::Int, El::STAR, El::VR> label_matrix_t;

    data_matrix_t X;
    label_matrix_t L;

    boost::mpi::timer timer;

    // Load A and Y
    if (rank == 0) {
        std::cout << "Reading the matrix... ";
        std::cout.flush();
        timer.restart();
    }

    skylark::utility::io::ReadLIBSVM(infile, X, L,
        skylark::base::COLUMNS, mind);

    if (rank == 0)
        std::cout <<"took " << boost::format("%.2e") % timer.elapsed()
                  << " sec\n";

    // Compute kernel matrix
    if (rank == 0) {
        std::cout << "Computing the transformed matrix... ";
        std::cout.flush();
        timer.restart();
    }

    data_matrix_t Z(s, X.Width());
    skylark::ml::gaussian_t k(X.Height(), sigma);
    auto S = k.create_rft<data_matrix_t, data_matrix_t>(s,
        skylark::ml::regular_feature_transform_tag(), context);
    S->apply(X, Z, skylark::sketch::columnwise_tag());

    if (rank == 0)
        std::cout << "took " << boost::format("%.2e") % timer.elapsed()
                  << " sec\n";

    // Write output
    if (rank == 0) {
        std::cout << "Writing the matrix... ";
        std::cout.flush();
        timer.restart();
    }

    skylark::utility::io::WriteLIBSVM(outfile, Z, L, skylark::base::COLUMNS);

    if (rank == 0)
        std::cout <<"took " << boost::format("%.2e") % timer.elapsed()
                  << " sec\n";

    El::Finalize();
    return 0;
}