void delayed_node_plugin::plugin_set_program_options(bpo::options_description& cli, bpo::options_description& cfg)
{
   cli.add_options()
         ("trusted-node", boost::program_options::value<std::string>(), "RPC endpoint of a trusted validating node (required)")
         ;
   cfg.add(cli);
}

void application::set_program_options(boost::program_options::options_description& command_line_options,
                                      boost::program_options::options_description& configuration_file_options) const
{
   configuration_file_options.add_options()
         ("p2p-endpoint", bpo::value<string>(), "Endpoint for P2P node to listen on")
         ("seed-node,s", bpo::value<vector<string>>()->composing(), "P2P nodes to connect to on startup (may specify multiple times)")
         ("rpc-endpoint", bpo::value<string>()->implicit_value("127.0.0.1:8090"), "Endpoint for websocket RPC to listen on")
         ("rpc-tls-endpoint", bpo::value<string>()->implicit_value("127.0.0.1:8089"), "Endpoint for TLS websocket RPC to listen on")
         ("server-pem,p", bpo::value<string>()->implicit_value("server.pem"), "The TLS certificate file for this server")
         ("server-pem-password,P", bpo::value<string>()->implicit_value(""), "Password for this certificate")
         ("genesis-json", bpo::value<boost::filesystem::path>(), "File to read Genesis State from")
         ("apiaccess", bpo::value<boost::filesystem::path>(), "JSON file specifying API permissions")
         ;
   command_line_options.add(configuration_file_options);
   command_line_options.add_options()
         ("create-genesis-json", bpo::value<boost::filesystem::path>(),
          "Path to create a Genesis State at. If a well-formed JSON file exists at the path, it will be parsed and any "
          "missing fields in a Genesis State will be added, and any unknown fields will be removed. If no file or an "
          "invalid file is found, it will be replaced with an example Genesis State.")
         ("replay-blockchain", "Rebuild object graph by replaying all blocks")
         ("resync-blockchain", "Delete all blocks and re-sync with network from scratch")
         ;
   command_line_options.add(_cli_options);
   configuration_file_options.add(_cfg_options);
}

inline void initRules2WeightsOptions (po::options_description& desc
                                      , bool addAllOptions=true) {
  using namespace HifstConstants;
  if (addAllOptions) {
    desc.add_options()
        ( kRangeExtended.c_str(),
          po::value<std::string>()->default_value ("1"),
          "Indices of sentences to process" )
        // Not supported. Very low priority, it's super fast as it is.
        // ( kNThreads.c_str(), po::value<unsigned>(),
        //   "Number of threads (trimmed to number of cpus in the machine) " )

        // Not supported yet
        // ( kRulesToWeightsLatticeFilterbyAlilats.c_str(),
        //   "Filter the flower lattice with the vocabulary of the alignment lattices" )
        ( kRulesToWeightsLoadGrammar.c_str(), po::value<std::string>(),
          "Load a synchronous context-free grammar file" )
        ( kRulesToWeightsLoadalilats.c_str() ,
          po::value<std::string>(), "Load hifst sparse weight translation lattice" )
        ( kRulesToWeightsNumberOfLanguageModels.c_str()
          , po::value<unsigned>()->default_value ( 1 )
          , "Number of language models" )
        ;
  }
  desc.add_options()
      ( kRulesToWeightsLatticeStore.c_str() ,
        po::value<std::string>()->default_value ( "" ),
        "Store the fst (tropical tuple sparse weight) containing a vector of features per arc " )
      ;
}

    void CmdLine::addGlobalOptions( boost::program_options::options_description& general , 
                                    boost::program_options::options_description& hidden ){
        /* support for -vv -vvvv etc. */
        for (string s = "vv"; s.length() <= 12; s.append("v")) {
            hidden.add_options()(s.c_str(), "verbose");
        }
        
        general.add_options()
            ("help,h", "show this usage information")
            ("version", "show version information")
            ("config,f", po::value<string>(), "configuration file specifying additional options")
            ("verbose,v", "be more verbose (include multiple times for more verbosity e.g. -vvvvv)")
            ("quiet", "quieter output")
            ("port", po::value<int>(&cmdLine.port), "specify port number")
            ("bind_ip", po::value<string>(&cmdLine.bind_ip), "comma separated list of ip addresses to listen on - all local ips by default")
            ("logpath", po::value<string>() , "log file to send write to instead of stdout - has to be a file, not directory" )
            ("logappend" , "append to logpath instead of over-writing" )
            ("pidfilepath", po::value<string>(), "full path to pidfile (if not set, no pidfile is created)")
            ("keyFile", po::value<string>(), "private key for cluster authentication (only for replica sets)")
#ifndef _WIN32
            ("fork" , "fork server process" )
#endif
            ;
        
    }

void BackendPlugin::plugin_set_program_options(boost::program_options::options_description& command_line_options,
                                                    boost::program_options::options_description& config_file_options) {
    namespace bpo = boost::program_options;
    command_line_options.add_options()("port,p", bpo::value<uint16_t>()->default_value(17073),
                                       "The port for the server to listen on");
    config_file_options.add_options()("port,p", bpo::value<uint16_t>()->default_value(17073),
                                      "The port for the server to listen on");
}

void monitor_plugin::plugin_set_program_options(
   boost::program_options::options_description& command_line_options,
   boost::program_options::options_description& config_file_options)
{
   command_line_options.add_options()
         (MONITOR_OPT_ACTION_TYPE, boost::program_options::value<uint32_t>(), "The type of operation monitored")
         ;
   config_file_options.add(command_line_options);
}

void account_history_plugin::plugin_set_program_options(
   boost::program_options::options_description& cli,
   boost::program_options::options_description& cfg
   )
{
   cli.add_options()
         ("track-account", boost::program_options::value<std::vector<std::string>>()->composing()->multitoken(), "Account ID to track history for (may specify multiple times)")
         ;
   cfg.add(cli);
}

void account_history_plugin::plugin_set_program_options(
   boost::program_options::options_description& cli,
   boost::program_options::options_description& cfg
   )
{
   cli.add_options()
         ("track-account-range", boost::program_options::value<std::vector<std::string>>()->composing()->multitoken(), "Defines a range of accounts to track as a json pair [\"from\",\"to\"] [from,to]")
         ("filter-posting-ops", "Ignore posting operations, only track transfers and account updates")
         ;
   cfg.add(cli);
}

void snapshot_plugin::plugin_set_program_options(
   boost::program_options::options_description& command_line_options,
   boost::program_options::options_description& config_file_options)
{
   command_line_options.add_options()
         (OPT_BLOCK_NUM, bpo::value<uint32_t>(), "Block number after which to do a snapshot")
         (OPT_BLOCK_TIME, bpo::value<string>(), "Block time (ISO format) after which to do a snapshot")
         (OPT_DEST, bpo::value<string>(), "Pathname of JSON file where to store the snapshot")
         ;
   config_file_options.add(command_line_options);
}

	void SetCommand::addOptions(po::options_description &options, po::options_description &hidden_options)
	{
		m_target.addOptions(options, hidden_options);
		options.add_options()
			("pin", po::value<int>(&m_pin), "pin index (starting from 0)")
			("value", po::value<bool>(&m_value), "pin value")
			("mask", po::value<BitMap<uint8_t>>(&m_mask), "pin mask")
		;
		hidden_options.add_options()
			("values", po::value<BitMap<uint8_t>>(&m_values), "")
		;
	}

void CmdLine::addGlobalOptions( boost::program_options::options_description& general ,
                                boost::program_options::options_description& hidden ,
                                boost::program_options::options_description& ssl_options ) {
    /* support for -vv -vvvv etc. */
    for (string s = "vv"; s.length() <= 12; s.append("v")) {
        hidden.add_options()(s.c_str(), "verbose");
    }

    StringBuilder portInfoBuilder;
    StringBuilder maxConnInfoBuilder;

    portInfoBuilder << "specify port number - " << DefaultDBPort << " by default";
    maxConnInfoBuilder << "max number of simultaneous connections - " << DEFAULT_MAX_CONN << " by default";

    general.add_options()
    ("help,h", "show this usage information")
    ("version", "show version information")
    ("config,f", po::value<string>(), "configuration file specifying additional options")
    ("verbose,v", "be more verbose (include multiple times for more verbosity e.g. -vvvvv)")
    ("quiet", "quieter output")
    ("port", po::value<int>(&cmdLine.port), portInfoBuilder.str().c_str())
    ("bind_ip", po::value<string>(&cmdLine.bind_ip), "comma separated list of ip addresses to listen on - all local ips by default")
    ("maxConns",po::value<int>(), maxConnInfoBuilder.str().c_str())
    ("objcheck", "inspect client data for validity on receipt")
    ("logpath", po::value<string>() , "log file to send write to instead of stdout - has to be a file, not directory" )
    ("logappend" , "append to logpath instead of over-writing" )
    ("pidfilepath", po::value<string>(), "full path to pidfile (if not set, no pidfile is created)")
    ("keyFile", po::value<string>(), "private key for cluster authentication")
    ("enableFaultInjection", "enable the fault injection framework, for debugging."
     " DO NOT USE IN PRODUCTION")
#ifndef _WIN32
    ("nounixsocket", "disable listening on unix sockets")
    ("unixSocketPrefix", po::value<string>(), "alternative directory for UNIX domain sockets (defaults to /tmp)")
    ("fork" , "fork server process" )
    ("syslog" , "log to system's syslog facility instead of file or stdout" )
#endif
    ;


#ifdef MONGO_SSL
    ssl_options.add_options()
    ("sslOnNormalPorts" , "use ssl on configured ports" )
    ("sslPEMKeyFile" , po::value<string>(&cmdLine.sslPEMKeyFile), "PEM file for ssl" )
    ("sslPEMKeyPassword" , new PasswordValue(&cmdLine.sslPEMKeyPassword) , "PEM file password" )
#endif
    ;

    // Extra hidden options
    hidden.add_options()
    ("traceExceptions", "log stack traces for every exception");
}

void elasticsearch_plugin::plugin_set_program_options(
   boost::program_options::options_description& cli,
   boost::program_options::options_description& cfg
   )
{
   cli.add_options()
         ("elasticsearch-node-url", boost::program_options::value<std::string>(), "Elastic Search database node url")
         ("elasticsearch-bulk-replay", boost::program_options::value<uint32_t>(), "Number of bulk documents to index on replay(5000)")
         ("elasticsearch-bulk-sync", boost::program_options::value<uint32_t>(), "Number of bulk documents to index on a syncronied chain(10)")
         ("elasticsearch-logs", boost::program_options::value<bool>(), "Log bulk events to database")
         ("elasticsearch-visitor", boost::program_options::value<bool>(), "Use visitor to index additional data(slows down the replay)")
         ;
   cfg.add(cli);
}

void witness_plugin::plugin_set_program_options(
   boost::program_options::options_description& command_line_options,
   boost::program_options::options_description& config_file_options)
{
   command_line_options.add_options()
         ("enable-stale-production", bpo::bool_switch()->notifier([this](bool e){_production_enabled = e;}), "Enable block production, even if the chain is stale")
         ("witness-id,w", bpo::value<vector<string>>()->composing()->multitoken(),
          "ID of witness controlled by this node (e.g. \"1.7.0\", quotes are required, may specify multiple times)")
         ("private-key", bpo::value<vector<string>>()->composing()->multitoken()->
          DEFAULT_VALUE_VECTOR(std::make_pair(chain::key_id_type(), fc::ecc::private_key::regenerate(fc::sha256::hash(std::string("genesis"))))),
          "Tuple of [key ID, private key] (may specify multiple times)")
         ;
   config_file_options.add(command_line_options);
}

 void CmdLine::addWindowsOptions( boost::program_options::options_description& windows , 
                                 boost::program_options::options_description& hidden ){
     windows.add_options()
         ("install", "install mongodb service")
         ("remove", "remove mongodb service")
         ("reinstall", "reinstall mongodb service (equivilant of mongod --remove followed by mongod --install)")
         ("serviceName", po::value<string>(), "windows service name")
         ("serviceDisplayName", po::value<string>(), "windows service display name")
         ("serviceDescription", po::value<string>(), "windows service description")
         ("serviceUser", po::value<string>(), "user name service executes as")
         ("servicePassword", po::value<string>(), "password used to authenticate serviceUser")
         ;
     hidden.add_options()("service", "start mongodb service");
 }

		void process(boost::program_options::options_description &desc, client::destination_container &source, client::destination_container &data) {
			desc.add_options()
				("path", po::value<std::string>()->notifier(boost::bind(&client::destination_container::set_string_data, data, "path", _1)),
					"")

				;
		}

  void
  Engine::getCommonOptions(boost::program_options::options_description& opts)
  {
    boost::program_options::options_description simopts("Common Engine Options");

    simopts.add_options()
      ("events,c", boost::program_options::value<size_t>()
       ->default_value(std::numeric_limits<size_t>::max(), "no-limit"),
       "No. of events to run the simulation for.")
      ("print-events,p", boost::program_options::value<size_t>()->default_value(100000), 
       "No. of events between periodic screen output.")
      ("random-seed,s", boost::program_options::value<unsigned int>(),
       "Random seed for generator (To make the simulation reproduceable - Only for debugging!)")
      ("ticker-period,t",boost::program_options::value<double>(), 
       "Time between data collections. Defaults to the system MFT or 1 if no MFT available")
      ("equilibrate,E", "Turns off most output for a fast silent run")
      ("load-plugin,L", boost::program_options::value<std::vector<std::string> >(), 
       "Additional individual plugins to load")
      ("sim-end-time,f", boost::program_options::value<double>()->default_value(std::numeric_limits<double>::max(), "no limit"), 
       "Simulation end time (Note, In replica exchange, each systems end time is scaled by"
       "(T_cold/T_i)^{1/2}, see replex-interval)")
      ("unwrapped", "Don't apply the boundary conditions of the system when writing out the particle positions.")
      ("snapshot", boost::program_options::value<double>(),
       "Sets the system time inbetween saving snapshots of the system.")
      ;
  
    opts.add(simopts);
  }

void addGFlag<bool>(
    gflags::CommandLineFlagInfo&& flag,
    po::options_description& desc,
    ProgramOptionsStyle style) {
  auto gflagInfo = std::make_shared<GFlagInfo<bool>>(std::move(flag));
  auto& info = gflagInfo->info();
  auto name = getName(info.name);
  std::string negationPrefix;

  switch (style) {
    case ProgramOptionsStyle::GFLAGS:
      negationPrefix = "no";
      break;
    case ProgramOptionsStyle::GNU:
      std::replace(name.begin(), name.end(), '_', '-');
      negationPrefix = "no-";
      break;
  }

  // clang-format off
  desc.add_options()
    (name.c_str(),
     new BoolGFlagValueSemantic(gflagInfo),
     info.description.c_str())
    ((negationPrefix + name).c_str(),
     new NegativeBoolGFlagValueSemantic(gflagInfo),
     folly::to<std::string>("(no) ", info.description).c_str());
  // clang-format on
}

void ConsoleCommand::InitParameters(boost::program_options::options_description& visibleDesc,
    boost::program_options::options_description& hiddenDesc) const
{
	visibleDesc.add_options()
		("connect,c", po::value<std::string>(), "connect to an Icinga 2 instance")
	;
}

void
GpmsaComputerModelOptions::defineMyOptions(boost::program_options::options_description& optionsDesc) const
{
  queso_deprecated();

  optionsDesc.add_options()
    (m_option_help.c_str(),                                                                                                                        "produce help message for mixed inverse problem")
    (m_option_checkAgainstPreviousSample.c_str(),      boost::program_options::value<bool        >()->default_value(UQ_GCM_CHECK_AGAINST_PREVIOUS_SAMPLE_ODV        ), "check against previous sample"                 )
    (m_option_dataOutputFileName.c_str(),              boost::program_options::value<std::string >()->default_value(UQ_GCM_DATA_OUTPUT_FILE_NAME_ODV                ), "name of data output file"                      )
    (m_option_dataOutputAllowAll.c_str(),              boost::program_options::value<bool        >()->default_value(UQ_GCM_DATA_OUTPUT_ALLOW_ALL_ODV                ), "allow all or not"                              )
    (m_option_dataOutputAllowedSet.c_str(),            boost::program_options::value<std::string >()->default_value(UQ_GCM_DATA_OUTPUT_ALLOWED_SET_ODV              ), "subEnvs that will write to data output file"   )
    (m_option_priorSeqNumSamples.c_str(),              boost::program_options::value<unsigned int>()->default_value(UQ_GCM_PRIOR_SEQ_NUM_SAMPLES_ODV                ), "prior sequence size"                           )
    (m_option_priorSeqDataOutputFileName.c_str(),      boost::program_options::value<std::string >()->default_value(UQ_GCM_PRIOR_SEQ_DATA_OUTPUT_FILE_NAME_ODV      ), "prior sequence data output filename"           )
    (m_option_priorSeqDataOutputFileType.c_str(),      boost::program_options::value<std::string >()->default_value(UQ_GCM_PRIOR_SEQ_DATA_OUTPUT_FILE_TYPE_ODV      ), "prior sequence data output filetype"           )
    (m_option_priorSeqDataOutputAllowAll.c_str(),      boost::program_options::value<bool        >()->default_value(UQ_GCM_PRIOR_SEQ_DATA_OUTPUT_ALLOW_ALL_ODV      ), "allow all or not"                              )
    (m_option_priorSeqDataOutputAllowedSet.c_str(),    boost::program_options::value<std::string >()->default_value(UQ_GCM_PRIOR_SEQ_DATA_OUTPUT_ALLOWED_SET_ODV    ), "subEnvs that will write to data output file"   )
    (m_option_nuggetValueForBtWyB.c_str(),             boost::program_options::value<double      >()->default_value(UQ_GCM_NUGGET_VALUE_FOR_BT_WY_B_ODV             ), "nugget value for Bt_Wy_W matrix"               )
    (m_option_nuggetValueForBtWyBInv.c_str(),          boost::program_options::value<double      >()->default_value(UQ_GCM_NUGGET_VALUE_FOR_BT_WY_B_INV_ODV         ), "nugget value for Bt_Wy_W inverse matrix"       )
    (m_option_formCMatrix.c_str(),                     boost::program_options::value<double      >()->default_value(UQ_GCM_FORM_C_MATRIX_ODV                        ), "form C matrix"                                 )
    (m_option_useTildeLogicForRankDefficientC.c_str(), boost::program_options::value<bool        >()->default_value(UQ_GCM_USE_TILDE_LOGIC_FOR_RANK_DEFFICIENT_C_ODV), "use tilde logic for rank defficient C"         )
    (m_option_predLag.c_str(),                         boost::program_options::value<unsigned int>()->default_value(UQ_GCM_PRED_LAG_ODV                             ), "predLag"                                       )
    (m_option_predVUsBySamplingRVs.c_str(),            boost::program_options::value<bool        >()->default_value(UQ_GCM_PRED_VUS_BY_SAMPLING_RVS_ODV             ), "predVUsBySamplingRVs"                          )
    (m_option_predVUsBySummingRVs.c_str(),             boost::program_options::value<bool        >()->default_value(UQ_GCM_PRED_VUS_BY_SUMMING_RVS_ODV              ), "predVUsBySummingRVs"                           )
    (m_option_predVUsAtKeyPoints.c_str(),              boost::program_options::value<bool        >()->default_value(UQ_GCM_PRED_VUS_AT_KEY_POINTS_ODV               ), "predVUsAtKeyPoints"                            )
    (m_option_predWsBySamplingRVs.c_str(),             boost::program_options::value<bool        >()->default_value(UQ_GCM_PRED_WS_BY_SAMPLING_RVS_ODV              ), "predWsBySamplingRVs"                           )
    (m_option_predWsBySummingRVs.c_str(),              boost::program_options::value<bool        >()->default_value(UQ_GCM_PRED_WS_BY_SUMMING_RVS_ODV               ), "predWsBySummingRVs"                            )
    (m_option_predWsAtKeyPoints.c_str(),               boost::program_options::value<bool        >()->default_value(UQ_GCM_PRED_WS_AT_KEY_POINTS_ODV                ), "predWsAtKeyPoints"                             )
  ;

  return;
}

void producer_plugin::set_program_options(
   boost::program_options::options_description& command_line_options,
   boost::program_options::options_description& config_file_options)
{
   auto default_priv_key = private_key_type::regenerate<fc::ecc::private_key_shim>(fc::sha256::hash(std::string("nathan")));
   auto private_key_default = std::make_pair(default_priv_key.get_public_key(), default_priv_key );

   boost::program_options::options_description producer_options;

   producer_options.add_options()
         ("enable-stale-production,e", boost::program_options::bool_switch()->notifier([this](bool e){my->_production_enabled = e;}), "Enable block production, even if the chain is stale.")
         ("required-participation", boost::program_options::value<uint32_t>()
                                       ->default_value(uint32_t(config::required_producer_participation/config::percent_1))
                                       ->notifier([this](uint32_t e) {
                                          my->_required_producer_participation = std::min(e, 100u) * config::percent_1;
                                       }),
                                       "Percent of producers (0-100) that must be participating in order to produce blocks")
         ("producer-name,p", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "ID of producer controlled by this node (e.g. inita; may specify multiple times)")
         ("private-key", boost::program_options::value<vector<string>>()->composing()->multitoken()->default_value({fc::json::to_string(private_key_default)},
                                                                                                fc::json::to_string(private_key_default)),
          "Tuple of [public key, WIF private key] (may specify multiple times)")
         ;
   config_file_options.add(producer_options);
}