const options_description& optionsDescription,

const std::string& configFile = std::string())

{

for (const auto& pOptionsDesc : optionsDescription.options())

{

std::string optionName = pOptionsDesc->long_name();

if ( !(vm.count(optionName)) )

{

std::string msg = "Required option " + optionName + " not specified";

if (!configFile.empty())

msg += " in config file " + configFile;

reportError(msg, ERROR_LOCATION);

return false ;

}

}

// all options validated

return true;

{

if (core::system::stderrIsTerminal())

std::cerr << errorMessage << std::endl;

else

core::log::logErrorMessage(errorMessage, location);

const ErrorLocation& location)

{

if (core::system::stderrIsTerminal())

std::cerr << "WARNINGS: " << warningMessages << std::endl;

else

core::log::logWarningMessage(warningMessages, location);

const OptionsDescription& optionsDescription,

const options_description& commandLineOptions,

int argc,

const char * const argv[],

std::vector<std::string>* pUnrecognized)

{

// parse the command line

command_line_parser parser(argc, const_cast<char**>(argv));

parser.options(commandLineOptions);

parser.positional(optionsDescription.positionalOptions);

if (pUnrecognized != nullptr)

parser.allow_unregistered();

parsed_options parsed = parser.run();

store(parsed, vm);

notify(vm) ;

// collect unrecognized if necessary

if (pUnrecognized != nullptr)

{

*pUnrecognized = collect_unrecognized(parsed.options,

include_positional);

}

const std::string& configFile,

const OptionsDescription& optionsDescription,

bool allowUnregisteredConfigOptions)

{

// open the config file

if (!configFile.empty())

{

std::shared_ptr<std::istream> pIfs;

Error error = FilePath(configFile).openForRead(pIfs);

if (error)

{

reportError("Unable to open config file: " + configFile,

ERROR_LOCATION);

return false;

}

try

{

// parse config file

store(parse_config_file(*pIfs, optionsDescription.configFile, allowUnregisteredConfigOptions), vm) ;

notify(vm) ;

}

catch(const std::exception& e)

{

reportError(

"Error reading " + configFile + ": " + std::string(e.what()),

ERROR_LOCATION);

return false;

}

}

return true;

int argc,

const char * const argv[],

std::vector<std::string>* pUnrecognized,

bool* pHelp,

bool allowUnregisteredConfigOptions,

bool configFileHasPrecedence)

{

*pHelp = false;

std::string configFile;

try

{

// general options

options_description general("general") ;

general.add_options()

("help", "print help message")

("test-config", "test to ensure the config file is valid")

("config-file",

value<std::string>(&configFile)->default_value(

optionsDescription.defaultConfigFilePath),

std::string("configuration file").c_str());

// make copy of command line options so we can add general to them

options_description commandLineOptions(optionsDescription.commandLine);

commandLineOptions.add(general);

variables_map vm ;

// the order of parsing is determined based on whether or not the config file has precedence

// if it does, parse it first, otherwise parse the command line first

if (configFileHasPrecedence)

{

// if we are parsing the config file first, do not attempt to parse

// the config file path from the command line arguments - just use

// the default value that was passed in

configFile = optionsDescription.defaultConfigFilePath;

if (!parseConfigFile(vm, configFile, optionsDescription, allowUnregisteredConfigOptions))

return ProgramStatus::exitFailure();

parseCommandLine(vm, optionsDescription, commandLineOptions, argc, argv, pUnrecognized);

}

else

{

parseCommandLine(vm, optionsDescription, commandLineOptions, argc, argv, pUnrecognized);

// "none" is a special sentinel value for the config-file which

// explicitly prevents us from reading the default config file above

// now that we are past that we can reset it to empty

if (configFile == "none")

configFile = "";

if (!parseConfigFile(vm, configFile, optionsDescription, allowUnregisteredConfigOptions))

return ProgramStatus::exitFailure();

}

// show help if requested

if (vm.count("help"))

{

*pHelp = true;

std::cout << commandLineOptions ;

return ProgramStatus::exitSuccess() ;

}

// validate all options are provided

else

{

if (!validateOptionsProvided(vm, optionsDescription.commandLine))

return ProgramStatus::exitFailure();

if (!configFile.empty())

{

if (!validateOptionsProvided(vm,

optionsDescription.configFile,

configFile))

return ProgramStatus::exitFailure();

}

}

// if this was a config-test then return exitSuccess, otherwise run

if (vm.count("test-config"))

{

return ProgramStatus::exitSuccess();

}

else

{

return ProgramStatus::run() ;

}

}

catch(const boost::program_options::error& e)

{

std::string msg(e.what());

if (!configFile.empty())

msg += " in config file " + configFile;

reportError(msg, ERROR_LOCATION);

return ProgramStatus::exitFailure();

}

CATCH_UNEXPECTED_EXCEPTION

// keep compiler happy

return ProgramStatus::exitFailure();