/usr/include/cc++/cmdoptns.h is in libcommoncpp2-dev 1.8.1-6.1.
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 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 | // Copyright (C) 2001-2010 Gianni Mariani
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// Common C++. If you copy code from other releases into a copy of GNU
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way. To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//
/**
* @file cmdoptns.h
* @short Command line option parsing interface.
**/
#ifndef CCXX_CMDOPTNS_H_
#define CCXX_CMDOPTNS_H_
#ifndef CCXX_STRING_H_
#include <cc++/string.h>
#endif
#ifdef CCXX_NAMESPACES
namespace ost {
#endif
class CommandOption;
class CommandOptionParse;
/**
* This defines a linked list head pointer for all the command line
* options that use the default list. It will most likely
* be used in most cases without being explicitly referenced in application
* code. It is a default value of various method's parameters.
*
*/
extern __EXPORT CommandOption * defaultCommandOptionList;
/**
* CommandOption is the base class for all command line options. Command
* line options can be defined statically and used when constructing
* a command line parser onject using makeCommandOptionParse. This serves
* only as a base class to CommandOptionWithArg, CommandOptionRest or
* CommandOptionNoArg which can also be used to derive more complex
* classes or even entire applications.
*
* @author Gianni Mariani <gianni@mariani.ws>
*/
class __EXPORT CommandOption {
public:
/**
* Long option name, these will be preceded with "--" on the command line.
* e.g. --file foo.x
*/
const char * optionName;
/**
* option letter, these will be preceded with "-" on the command line.
* e.g. -f foo.x
*/
const char * optionLetter;
/**
* A short description of the option for Usage messages.
* e.g. Usage: mycommand : blah
* -f, --file \<DESCRIPTION here\>
*/
const char * description;
/**
* OptionType is for denoting what type of option this is, with an
* arg, without an arg or the trailing args.
* @short Option type
*/
enum OptionType {
/**
* This option is associated with a value
*/
hasArg,
/**
* This option is a flag only
*/
noArg,
/**
* Remaining of the command line arguments
*/
trailing,
/**
* Collect values that are not a value to an option
*/
collect
};
/**
* This command option's OptionType.
*/
OptionType optionType; // HasArg, NoArg or Trailing
/**
* True if this parameter is required. If the parameter is not supplied
* and required is true, an error will be flagged in the option processor.
*/
bool required; // Option is required - fail without it
/**
* This next CommandOption in this list of options or nil if no more
* options exist.
*/
CommandOption * next;
/**
* A virtual destructor just in case.
*/
virtual ~CommandOption();
/**
* CommandOption contructor. Note the default values for required and
* ppNext.
*
* @param inOptionName long option name
* @param inOptionLetter short letter name
* @param inDescription short description of the option
* @param inOptionType the type of this option
* @param inRequired true if option is required
* @param ppNext the linked list header
*/
CommandOption(
const char * inOptionName,
const char * inOptionLetter,
const char * inDescription,
OptionType inOptionType,
bool inRequired = false,
CommandOption ** ppNext = & defaultCommandOptionList
);
/**
* foundOption is called by the CommandOptionParse object during the parsing
* of the command line options.
*
* @param cop pointer to the command option parser
* @param value the value of this option
*/
virtual void foundOption( CommandOptionParse * cop, const char * value = 0 );
/**
* foundOption is called by the CommandOptionParse object during the parsing
* of the command line options.
*
* @param cop pointer to the command option parser
* @param value an array of values of this option
* @param num number of values in the array
*/
virtual void foundOption( CommandOptionParse * cop, const char ** value, int num );
/**
* Once parsing of command line options is complete, this method is called.
* This can be used to perform last minute checks on the options collected.
*
* @param cop pointer to the command option parser
*/
virtual void parseDone( CommandOptionParse * cop );
/**
* Once CommandOption objects have completed parsing and there are no
* errors they may have some specific tasks to perform. PerformTask
* must return.
*
* @param cop pointer to the command option parser
*/
virtual void performTask( CommandOptionParse * cop );
/**
* For fields with the required flag set, this method is used to determine
* if the Option has satisfied it's required status. The default methods
* simply returns true if any values have been found. This could be specialized
* to return true based on some other criteria.
*/
virtual bool hasValue();
};
/**
* Derived class of CommandOption for options that have a value associated with them.
* Classes CommandOptionRest and CommandOptionArg derive from this class.
*/
class __EXPORT CommandOptionWithArg : public CommandOption {
public:
/**
* Array of list of values collected for this option.
*/
const char ** values;
/**
* Number of values in the values array.
*/
int numValue;
/**
* CommandOptionWithArg contructor. Note the default values for required and
* ppNext.
*
* @param inOptionName long option name
* @param inOptionLetter short letter name
* @param inDescription short description of the option
* @param inOptionType the type of this option
* @param inRequired true if option is required
* @param ppNext the linked list header
*/
CommandOptionWithArg(
const char * inOptionName,
const char * inOptionLetter,
const char * inDescription,
OptionType inOptionType,
bool inRequired = false,
CommandOption ** ppNext = & defaultCommandOptionList
);
virtual ~CommandOptionWithArg();
virtual void foundOption( CommandOptionParse * cop, const char * value = 0 );
virtual void foundOption( CommandOptionParse * cop, const char ** value, int num );
virtual bool hasValue();
};
/**
* Class for options with an argument e.g. --option value .
*/
class __EXPORT CommandOptionArg : public CommandOptionWithArg {
public:
/**
* CommandOptionArg contructor. This sets the optionType for this
* object to HasArg.
*
* @param inOptionName long option name
* @param inOptionLetter short letter name
* @param inDescription short description of the option
* @param inRequired true if option is required
* @param ppNext the linked list header
*/
CommandOptionArg(
const char * inOptionName,
const char * inOptionLetter,
const char * inDescription,
bool inRequired = false,
CommandOption ** ppNext = & defaultCommandOptionList
);
virtual ~CommandOptionArg();
};
/**
* It only makes sense to have a single one of these set and it is
* exclusive with CommandOptionCollect. It is the option that takes the rest
* of the command line options that are not part of any other options.
* e.g. "strace -ofile command arg1 arg2". The "command arg1 arg2" part is
* placed in objects of this class.
*
* @short CommandOption to take the rest of the command line
*/
class __EXPORT CommandOptionRest : public CommandOptionWithArg {
public:
/**
* CommandOptionRest contructor. This sets the optionType for this
* object to Trailing.
*
* @param inOptionName long option name
* @param inOptionLetter short letter name
* @param inDescription short description of the option
* @param inRequired true if option is required
* @param ppNext the linked list header
*/
CommandOptionRest(
const char * inOptionName,
const char * inOptionLetter,
const char * inDescription,
bool inRequired = false,
CommandOption ** ppNext = & defaultCommandOptionList
);
};
/**
* It only makes sense to have a single one of these set and it is also
* exclusive with CommandOptionRest. This makes parameter collecting
* behave line the Unix "cat" command.
*
* @short CommandOption to collect parameters that are not options.
*/
class __EXPORT CommandOptionCollect : public CommandOptionWithArg {
public:
/**
* CommandOptionRest contructor. This sets the optionType for this
* object to Collect.
*
* @param inOptionName long option name
* @param inOptionLetter short letter name
* @param inDescription short description of the option
* @param inRequired true if option is required
* @param ppNext the linked list header
*/
CommandOptionCollect(
const char * inOptionName,
const char * inOptionLetter,
const char * inDescription,
bool inRequired = false,
CommandOption ** ppNext = & defaultCommandOptionList
);
};
/**
* CommandOption type for flags.
*/
class __EXPORT CommandOptionNoArg : public CommandOption {
public:
/**
* The number of times this value has been set.
*/
int numSet; // The number of times this argument is set
/**
* CommandOptionArg contructor. This sets the optionType for this
* object to NoArg.
*
* @param inOptionName long option name
* @param inOptionLetter short letter name
* @param inDescription short description of the option
* @param inRequired true if option is required
* @param ppNext the linked list header
*/
CommandOptionNoArg(
const char * inOptionName,
const char * inOptionLetter,
const char * inDescription,
bool inRequired = false,
CommandOption ** ppNext = & defaultCommandOptionList
);
/**
* CommandOptionNoArg::foundOption will evpect a nil "value" passed in.
*/
virtual void foundOption( CommandOptionParse * cop, const char * value = 0 );
};
/**
* This is the CommandOptionParse interface class. To implement this object you can
* call makeCommandOptionParse(); This will instantiate a dynamically allocated
* version of this class and parse the command line for the list of command options
* that are passed in.
*
* @author Gianni Mariani <gianni@mariani.ws>
*/
class __EXPORT CommandOptionParse {
public:
/**
* Virtual destructor needed so that the object may be correctly deleted.
*/
virtual ~CommandOptionParse() = 0;
/**
* Get the value of the error flag set if the parser encountered errors.
*/
virtual bool argsHaveError() = 0;
/**
* Return a string of text describing the list of errors encountered.
*/
virtual const char * printErrors() = 0;
/**
* Return a string that contains the usage description of this list of paramaters.
*/
virtual const char * printUsage() = 0;
/**
* Register an error with this parser. This string will be appended to the
* errors already buffered in this object.
*/
virtual void registerError( const char * errMsg ) = 0;
/**
* The method should be invoked by the main code once it has determined that
* the application should be started.
*/
virtual void performTask() = 0;
};
/**
* makeCommandOptionParse will create an implementation of a CommandOptionParse
* object. This particular implementation is a wrapper around getopt_long(3).
* That interface unfortunatly does not provide enough information to give
* the best error messages with malformed input. If the implementation changes
* there is a good chance that the binary interface will remain the same.
*
*/
__EXPORT CommandOptionParse * makeCommandOptionParse(
int argc,
char ** argv,
const char * comment,
CommandOption * options = defaultCommandOptionList
);
#ifdef CCXX_NAMESPACES
}
#endif
#endif
/** EMACS **
* Local variables:
* mode: c++
* c-basic-offset: 4
* End:
*/
|