/usr/include/Poco/Util/OptionProcessor.h is in libpoco-dev 1.8.0.1-1ubuntu4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 | //
// OptionProcessor.h
//
// Library: Util
// Package: Options
// Module: OptionProcessor
//
// Definition of the OptionProcessor class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Util_OptionProcessor_INCLUDED
#define Util_OptionProcessor_INCLUDED
#include "Poco/Util/Util.h"
#include <set>
namespace Poco {
namespace Util {
class OptionSet;
class Util_API OptionProcessor
/// An OptionProcessor is used to process the command line
/// arguments of an application.
///
/// The process() method takes an argument from the command line.
/// If that argument starts with an option prefix, the argument
/// is further processed. Otherwise, the argument is ignored and
/// false is returned. The argument must match one of the options
/// given in the OptionSet that is passed to the OptionProcessor
/// with the constructor. If an option is part of a group, at most
/// one option of the group can be passed to the OptionProcessor.
/// Otherwise an IncompatibleOptionsException is thrown.
/// If the same option is given multiple times, but the option
/// is not repeatable, a DuplicateOptionException is thrown.
/// If the option is not recognized, a UnexpectedArgumentException
/// is thrown.
/// If the option requires an argument, but none is given, an
/// MissingArgumentException is thrown.
/// If no argument is expected, but one is present, a
/// UnexpectedArgumentException is thrown.
/// If a partial option name is ambiguous, an AmbiguousOptionException
/// is thrown.
///
/// The OptionProcessor supports two modes: Unix mode and default mode.
/// In Unix mode, the option prefix is a dash '-'. A dash must be followed
/// by a short option name, or another dash, followed by a (partial)
/// long option name.
/// In default mode, the option prefix is a slash '/', followed by
/// a (partial) long option name.
/// If the special option '--' is encountered in Unix mode, all following
/// options are ignored.
///
/// Option arguments can be specified in three ways. If a Unix short option
/// ("-o") is given, the argument directly follows the option name, without
/// any delimiting character or space ("-ovalue"). In default option mode, or if a
/// Unix long option ("--option") is given, the option argument is
/// delimited from the option name with either an equal sign ('=') or
/// a colon (':'), as in "--option=value" or "/option:value". Finally,
/// a required option argument can be specified on the command line after the
/// option, delimited with a space, as in "--option value" or "-o value".
/// The latter only works for required option arguments, not optional ones.
{
public:
OptionProcessor(const OptionSet& options);
/// Creates the OptionProcessor, using the given OptionSet.
~OptionProcessor();
/// Destroys the OptionProcessor.
void setUnixStyle(bool flag);
/// Enables (flag == true) or disables (flag == false) Unix-style
/// option processing.
///
/// If Unix-style processing is enabled, options are expected to
/// begin with a single or a double dash ('-' or '--', respectively).
/// A single dash must be followed by a short option name. A double
/// dash must be followed by a (partial) full option name.
///
/// If Unix-style processing is disabled, options are expected to
/// begin with a slash ('/'), followed by a (partial) full option name.
bool isUnixStyle() const;
/// Returns true iff Unix-style option processing is enabled.
bool process(const std::string& argument, std::string& optionName, std::string& optionArg);
/// Examines and processes the given command line argument.
///
/// If the argument begins with an option prefix, the option is processed
/// and true is returned. The full option name is stored in optionName and the
/// option argument, if present, is stored in optionArg.
///
/// If the option does not begin with an option prefix, false is returned.
void checkRequired() const;
/// Checks if all required options have been processed.
///
/// Does nothing if all required options have been processed.
/// Throws a MissingOptionException otherwise.
private:
bool processUnix(const std::string& argument, std::string& optionName, std::string& optionArg);
bool processDefault(const std::string& argument, std::string& optionName, std::string& optionArg);
bool processCommon(const std::string& option, bool isShort, std::string& optionName, std::string& optionArg);
const OptionSet& _options;
bool _unixStyle;
bool _ignore;
std::set<std::string> _groups;
std::set<std::string> _specifiedOptions;
std::string _deferredOption;
};
//
// inlines
//
inline bool OptionProcessor::isUnixStyle() const
{
return _unixStyle;
}
} } // namespace Poco::Util
#endif // Util_OptionProcessor_INCLUDED
|