C++ po::options_description类代码示例

	void _setOptions(po::options_description &desc,
			po::positional_options_description &p) {

		po::options_description usage("Usage: DistributedNucleatingAssembly <options> [[--contig-file contigs.fa] [[--input-file input.fq ...]\n\tNote: --contig-file and --input-file can be specified either as a positional argument or within the options");

		p.add("contig-file", 1);
		p.add("input-file", -1);

		desc.add(usage);

		po::options_description opts("DistributedNucleatingAssembly Options");
		opts.add_options()
					("max-iterations", po::value<int>()->default_value(maxIterations), "the maximum number of rounds to extend the set of contigs")

					("max-contigs-per-batch", po::value<int>()->default_value(maxContigsPerBatch), "the maximum number of assemblies (per mpi) to gather reads and execute per batch")

					("max-contig-length", po::value<int>()->default_value(maxContigLength), "the maximum size of a contig to continue extending");

		desc.add(opts);

		MatcherInterfaceOptions::_setOptions(desc,p);
		KmerMatchOptions::_setOptions(desc,p);
		KmerBaseOptions::_setOptions(desc,p);
		KmerSpectrumOptions::_setOptions(desc,p);
		VmatchOptions::_setOptions(desc,p);
		ContigExtenderBaseOptions::_setOptions(desc,p);
		NewblerOptions::_setOptions(desc, p);
		Cap3Options::_setOptions(desc,p);
		MPIOptions::_setOptions(desc,p);
		FilterKnownOdditiesOptions::_setOptions(desc,p);
		GeneralOptions::_setOptions(desc,p);

	};

void inflate_initializer(po::options_description& inflate_desc)
{
    UtilityProgramOptions::add_help_suboption(inflate_desc);
    UtilityProgramOptions::add_desc_suboption(inflate_desc);
    UtilityProgramOptions::add_output_suboption(inflate_desc);
    inflate_desc.add_options()("structure,s", po::value<fs::path>()->required(),
                               "POS.vasp like file you want to "
                               "increase the boundaries of");
    inflate_desc.add_options()("length,l", po::value<std::vector<double>>()->multitoken()->required(),
                               "amount that each lattice vector will grow (three values "
                               "corresponding to a, b, and c)");
    return;
}

void struc_score_initializer(po::options_description& struc_score_desc)
{
    UtilityProgramOptions::add_help_suboption(struc_score_desc);
    UtilityProgramOptions::add_output_suboption(struc_score_desc);

    struc_score_desc.add_options()("reference,r", po::value<fs::path>()->required(),
                    "POS.vasp like file to use as reference structure.");
    struc_score_desc.add_options()("mappable,m", po::value<std::vector<fs::path>>()->multitoken(),
                    "POS.vasp like file(s) to map, get structure score for."); 
    struc_score_desc.add_options()("batch,b", po::value<fs::path>(),
                    "Batch file containing list of structures files to get structure score for.");    
    struc_score_desc.add_options()("weight,w", po::value<double>()->default_value(0.5),
                    "Weight w in structure score: w*lattice_score + (1-w)*basis_score."); 
    return;
}

    void InitOptions(po::options_description& opts, po::positional_options_description&) override {
        opts.add_options()
            ("home", po::value<std::string>()->required(), "home directory")
            ("proxy,p", po::value<std::string>()->default_value("localhost"), "proxy host")
            ;

        po::options_description indexerOpts("Lister options");

        indexerOpts.add_options()
            ("verbose,v", "use verbose mode")
            ("chunk-size", po::value<size_t>(), "custom chunk size")
            ;

        opts.add(indexerOpts);
    }

void NSCPClient::add_local_options(po::options_description &desc, client::configuration::data_type data) {
	desc.add_options()
 		("no-ssl,n", po::value<bool>()->zero_tokens()->default_value(false)->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_bool_data, &data->recipient, "no ssl", _1)), 
			"Do not initial an ssl handshake with the server, talk in plaintext.")

		("certificate,c", po::value<std::string>()->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_string_data, &data->recipient, "certificate", _1)), 
		"Length of payload (has to be same as on the server)")

		("dh", po::value<std::string>()->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_string_data, &data->recipient, "dh", _1)), 
		"Length of payload (has to be same as on the server)")

		("certificate-key,k", po::value<std::string>()->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_string_data, &data->recipient, "certificate key", _1)), 
		"Client certificate to use")

		("certificate-format", po::value<std::string>()->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_string_data, &data->recipient, "certificate format", _1)), 
		"Client certificate format")

		("ca", po::value<std::string>()->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_string_data, &data->recipient, "ca", _1)), 
		"Certificate authority")

		("verify", po::value<std::string>()->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_string_data, &data->recipient, "verify mode", _1)), 
		"Client certificate format")

		("allowed-ciphers", po::value<std::string>()->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_string_data, &data->recipient, "allowed ciphers", _1)), 
		"Client certificate format")

 		("ssl,n", po::value<bool>()->zero_tokens()->default_value(false)->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_bool_data, &data->recipient, "ssl", _1)), 
			"Initial an ssl handshake with the server.")

		("timeout", po::value<unsigned int>()->notifier(boost::bind(&nscapi::protobuf::functions::destination_container::set_int_data, &data->recipient, "timeout", _1)), 
		"")


		;
}

void options_includes::fill_desc( po::options_description& desc )
{
	desc.add_options()
		( include_tag, po::value< vector<string> >(&includes)->composing(), include_desc )
		( sysincl_tag, po::value< vector<string> >(&sysincls)->composing(), sysincl_desc )
		;
}

void SyslogClient::add_local_options(po::options_description &desc, client::configuration::data_type data) {
	desc.add_options()
		("severity,s", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "severity", _1)), 
		"Severity of error message")

		("unknown-severity", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "unknown_severity", _1)), 
		"Severity of error message")

		("ok-severity", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "ok_severity", _1)), 
		"Severity of error message")

		("warning-severity", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "warning_severity", _1)), 
		"Severity of error message")

		("critical-severity", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "critical_severity", _1)), 
		"Severity of error message")

		("facility,f", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "facility", _1)), 
		"Facility of error message")

		("tag template", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "tag template", _1)), 
		"Tag template (TODO)")

		("message template", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "message template", _1)), 
		"Message template (TODO)")
		;
}

// Private methods ----------------------------------
void
EnvironmentOptions::defineMyOptions(po::options_description& optionsDesc) const
{
#ifdef QUESO_MEMORY_DEBUGGING
    std::cout << "In EnvOptions::defineMyOptions(), before add_options()" << std::endl;
#endif
    optionsDesc.add_options()
    (m_option_help.c_str(),                                                                                                 "produce help message for  environment"       )
    (m_option_numSubEnvironments.c_str(),    po::value<unsigned int>()->default_value(UQ_ENV_NUM_SUB_ENVIRONMENTS_ODV),     "number of subEnvironments"                     )
    (m_option_subDisplayFileName.c_str(),    po::value<std::string >()->default_value(UQ_ENV_SUB_DISPLAY_FILE_NAME_ODV),    "output filename for subscreen writing"         )
    (m_option_subDisplayAllowAll.c_str(),    po::value<bool        >()->default_value(UQ_ENV_SUB_DISPLAY_ALLOW_ALL_ODV),    "Allow all processors to write to output file"  )
    (m_option_subDisplayAllowInter0.c_str(), po::value<bool        >()->default_value(UQ_ENV_SUB_DISPLAY_ALLOW_INTER0_ODV), "Allow all inter0 nodes to write to output file")
    (m_option_subDisplayAllowedSet.c_str(),  po::value<std::string >()->default_value(UQ_ENV_SUB_DISPLAY_ALLOWED_SET_ODV),  "subEnvs that will write to output file"        )
    (m_option_displayVerbosity.c_str(),      po::value<unsigned int>()->default_value(UQ_ENV_DISPLAY_VERBOSITY_ODV),        "set verbosity"                                 )
    (m_option_syncVerbosity.c_str(),         po::value<unsigned int>()->default_value(UQ_ENV_SYNC_VERBOSITY_ODV),           "set sync verbosity"                            )
    (m_option_checkingLevel.c_str(),         po::value<unsigned int>()->default_value(UQ_ENV_CHECKING_LEVEL_ODV),           "set checking level"                            )
    (m_option_rngType.c_str(),               po::value<std::string >()->default_value(UQ_ENV_RNG_TYPE_ODV),                 "set rngType"                                   )
    (m_option_seed.c_str(),                  po::value<int         >()->default_value(UQ_ENV_SEED_ODV),                     "set seed"                                      )
    (m_option_platformName.c_str(),          po::value<std::string >()->default_value(UQ_ENV_PLATFORM_NAME_ODV),            "platform name"                                 )
    (m_option_identifyingString.c_str(),     po::value<std::string >()->default_value(UQ_ENV_IDENTIFYING_STRING_ODV),       "identifying string"                            )
    //(m_option_numDebugParams.c_str(),        po::value<unsigned int>()->default_value(UQ_ENV_NUM_DEBUG_PARAMS_ODV),         "set number of debug parameters"                )
    ;
#ifdef QUESO_MEMORY_DEBUGGING
    std::cout << "In EnvOptions::defineMyOptions(), after add_options()" << std::endl;
#endif

    return;
}

// Private methods ---------------------------------
void
uqMonteCarloSGOptionsClass::defineMyOptions(po::options_description& optionsDesc) const
{
  optionsDesc.add_options()     
    (m_option_help.c_str(),                                                                                                            "produce help message for Monte Carlo distribution calculator")
    (m_option_dataOutputFileName.c_str(),        po::value<std::string >()->default_value(UQ_MOC_SG_DATA_OUTPUT_FILE_NAME_ODV       ), "name of generic data output file"                            )
    (m_option_dataOutputAllowedSet.c_str(),      po::value<std::string >()->default_value(UQ_MOC_SG_DATA_OUTPUT_ALLOWED_SET_ODV     ), "subEnvs that will write to generic data output file"         )
    (m_option_pseq_dataOutputPeriod.c_str(),     po::value<unsigned int>()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_PERIOD_ODV     ), "period of message display during param sequence generation"  )
    (m_option_pseq_dataOutputFileName.c_str(),   po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_NAME_ODV  ), "name of data output file for parameters"                     )
    (m_option_pseq_dataOutputFileType.c_str(),   po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_FILE_TYPE_ODV  ), "type of data output file for parameters"                     )
    (m_option_pseq_dataOutputAllowedSet.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_PSEQ_DATA_OUTPUT_ALLOWED_SET_ODV), "subEnvs that will write to data output file for parameters"  )
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
    (m_option_pseq_computeStats.c_str(),         po::value<bool        >()->default_value(UQ_MOC_SG_PSEQ_COMPUTE_STATS_ODV          ), "compute statistics on sequence of parameter"                 )
#endif
    (m_option_qseq_dataInputFileName.c_str(),    po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_NAME_ODV   ), "name of data input file for qois"                            )
    (m_option_qseq_dataInputFileType.c_str(),    po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_INPUT_FILE_TYPE_ODV   ), "type of data input file for qois"                            )
    (m_option_qseq_size.c_str(),                 po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_SIZE_ODV                   ), "size of qoi sequence"                                        )
    (m_option_qseq_displayPeriod.c_str(),        po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_DISPLAY_PERIOD_ODV         ), "period of message display during qoi sequence generation"    )
    (m_option_qseq_measureRunTimes.c_str(),      po::value<bool        >()->default_value(UQ_MOC_SG_QSEQ_MEASURE_RUN_TIMES_ODV      ), "measure run times"                                           )
    (m_option_qseq_dataOutputPeriod.c_str(),     po::value<unsigned int>()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_PERIOD_ODV     ), "period of message display during qoi sequence generation"    )
    (m_option_qseq_dataOutputFileName.c_str(),   po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_NAME_ODV  ), "name of data output file for qois"                           )
    (m_option_qseq_dataOutputFileType.c_str(),   po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_FILE_TYPE_ODV  ), "type of data output file for qois"                           )
    (m_option_qseq_dataOutputAllowedSet.c_str(), po::value<std::string >()->default_value(UQ_MOC_SG_QSEQ_DATA_OUTPUT_ALLOWED_SET_ODV), "subEnvs that will write to data output file for qois"        )
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
    (m_option_qseq_computeStats.c_str(),         po::value<bool        >()->default_value(UQ_MOC_SG_QSEQ_COMPUTE_STATS_ODV          ), "compute statistics on sequence of qoi"                       )
#endif
   ;

  return;
}

    void InitOptions(po::options_description& opts, po::positional_options_description&) override {
        opts.add_options()
            ("path,p", po::value<std::string>()->default_value("."), "path to a root directory")
            ("index,i", po::value<std::string>()->required(), "index path prefix")
            ;

        po::options_description listerOpts("Lister options");

        listerOpts.add_options()
            ("verbose,v", "use verbose mode")
            ("recursive,r", po::value<bool>()->default_value(true), "traverse recursively")
            ("hidden", "do not ignore hidden directories/files")
            ("max-depth", po::value<int>()->default_value(-1), "max recursion depth")
            ;

        opts.add(listerOpts);
    }

void runner::register_options(const po::options_description& options)
{
    assert(m_impl);

    const auto& opt = options.options();
    for (const auto& o: opt)
        m_impl->m_options_description.add(o);
}

void applystrain_initializer(po::options_description& applystrain_desc)
{
    UtilityProgramOptions::add_help_suboption(applystrain_desc);
    UtilityProgramOptions::add_output_suboption(applystrain_desc);

    applystrain_desc.add_options()("structure,s", po::value<fs::path>()->required(),
                                   "POS.vasp like file that you want to apply strain to.");
    applystrain_desc.add_options()("mode,m", po::value<std::string>()->default_value("GL"),
                                   "Accepts strain convention as mode ('GL' [Green-Lagrange, default], 'EA' "
                                   "[Euler-Almansi], 'B' [Biot], or 'H' [Hencky])."
                                   " Also accepts 'F' [Deformation] as an argument to apply a deformation tensor");
    applystrain_desc.add_options()("tensor,t", po::value<fs::path>()->required(),
                                   "Path to a file with strain tensor."
                                   " Unrolled strain should be provided for GL, B, H, EA modes."
                                   " Ordered as E(0,0) E(1,1) E(2,2) E(1,2) E(0,2) E(0,1)."
                                   " Takes a 3X3 matrix for F (Deformation) mode.");
    return;
}

void Viewer<T>::appendOptions(po::options_description &opts)
{
    // Common program options
    opts.add_options()
        ("config,c", po::value<std::vector<std::string> >()->multitoken(),
        "Configuration file/key pair.\n"
        "e.g. 'config.toml mykey'")
        ;
}

 void Application::buildOptions(po::options_description &desc)
 {
     desc.add_options()
         ("camera,c", po::value(&m_OptCameraName)->default_value(CVTRACKER_DEFAULT_CAMERA), "specific camera to calibrate")
         ("width,w", po::value(&m_OptCameraWidth)->default_value(320), "camera capture width")
         ("height,h", po::value(&m_OptCameraHeight)->default_value(240), "camera capture height")
         ("rate,r", po::value(&m_OptCameraRate)->default_value(25), "camera capture rate")
         ("tracker,t", po::value(&m_OptTracker)->default_value(CVTRACKER_DEFAULT_TRACKER), "tracker to use");
 }

//==============================================================================
void CC_Base::init_options(po::options_description &desc)
{
	desc.add_options()
		("help,h", "produce help message");

	desc.add_options()
		("log", po::value<String>(&option_log_name_)->implicit_value(""),
				"create log of all operations");

	desc.add_options()
		("device,d", po::value<String>(&option_device_address_),
				"set programmer deivce usb address 'bus:device'");

	desc.add_options()
		("fast,f", "set fast debug interface speed (by default: slow)"); //TODO made fast by default

	desc.add_options()
		("name,n", po::value<String>(&option_unit_name_),
				"specify target name e.g. CC2530 etc.");
}