Class Hierarchy   Compound List   File List   Header Files   Compound Members   File Members  

---

suifkernel/command_line_parsing.h

This is the verbatim text of the command_line_parsing.h include file.

---

#ifndef SUIFKERNEL_COMMANDLINE_PARSING_H
#define SUIFKERNEL_COMMANDLINE_PARSING_H

#include "suifkernel_forwarders.h"













typedef suif_vector<Option*> Options;
enum AllowEmpty { DontAllowEmptySelection, AllowEmptySelection };


class ValueClass {
  friend class Option;
public:
  virtual ~ValueClass();
protected:
  ValueClass( ValueClass* parent, Option* owning_option );

  ValueClass* _parent;
  Option* _owning_option;
};

class StructureValueClass : public ValueClass {
  friend class OptionLoop;
  friend class OptionSelection;
  friend class OptionList;
protected:
  StructureValueClass( ValueClass* parent, Option* owning_option );
};



class StringValueClass : public ValueClass {
  friend class OptionString;
  friend class OptionMultiString;
  friend class OptionLiteral;
  friend class OptionPrefixString;
public:
  virtual const String get_string() const;
  virtual ~StringValueClass();
protected:
  StringValueClass( Token& t, ValueClass* parent, Option* owning_option );
  Token* sf_owned _token;
};


class IntValueClass : public ValueClass {
  friend class OptionInt;
public:
  virtual ~IntValueClass();
  virtual int get_int() const;
protected:
  IntValueClass( Token& t, ValueClass* parent, Option* owning_option );
  Token* _token;
};


class StreamValueClass : public ValueClass {
  friend class OptionStream;
public:
  virtual istream& get_stream() const;
protected:
  StreamValueClass( istream* stream,
                    ValueClass* parent,
		     Option* owning_option );
private:
  istream* _stream;
};


class Option {
public:
  
   virtual bool parse_options( istream& input_stream,
			       bool &changed,
			       ErrorSubSystem* output_for_errors );

   virtual bool parse_options( int argc, char *argv[],
			       bool &changed,
                               ErrorSubSystem* output_for_errors );

   virtual void print_to_stream( ostream& print_stream ) const;
   virtual String to_string() const;
   virtual void print_debug() const;

  
   virtual bool parse( TokenStream* tokens, bool &changed,
		       ValueClass* parent = 0) = 0;

   virtual int get_number_of_values() const;

   virtual void delete_values();

  
   virtual void print( String& command_line_string,
                       suif_vector<OptionDescription>* descriptions ) const;

  
   virtual void set_argument( const String& argument );

   
   virtual void set_description( const String& description,
                                 const String& group = emptyString );

  virtual String get_description() const;

   virtual ~Option();

protected:
   Option( String arguments = emptyString,
           Option* parent = 0);
   Option( String arguments, String description,
           Option* parent);

//   virtual Option* get_parent() { return _parent; }

    virtual ValueClass* get_value_class( ValueClass* value,
                                         Option* context ) const;

   String _description;
   String _group;
   String _argument;
   Option* _parent;
   suif_vector<sf_owned ValueClass*>* sf_owned _values;
};

class OptionString : public Option {
public:
  
   OptionString( String argument = String( "string" ),
                 String* storage_for_string = 0 );

   virtual ~OptionString();

   virtual const StringValueClass* get_string( int number = 0 ) const;
   virtual StringValueClass* get_string( ValueClass* value,
                                         Option* context ) const;

   
   virtual bool parse( TokenStream* tokens, bool &changed, 
		       ValueClass* parent = 0);

private:
   String* _storage_for_string;
};

// This option will match any string
// that begins with the "prefix"
class OptionPrefixString : public Option {
public:
  
   OptionPrefixString( String prefix,
		       String argname,
		       String description,
		       String* storage_for_string = 0 );

   virtual ~OptionPrefixString();

   virtual const StringValueClass* get_string( int number = 0 ) const;
   virtual StringValueClass* get_string( ValueClass* value,
                                         Option* context ) const;


   virtual bool parse( TokenStream* tokens, bool &changed, 
                       ValueClass* parent = 0 );

private:
  // for -Ddefine the _argument "-D" is the part to match
  String _argname;  // for -Ddefine  this would be "define"
  String* _storage_for_string;
};


class OptionMultiString : public Option {
public:

   OptionMultiString( String argument = String( "multi-string" ),
		      suif_vector<String> *storage_for_string = 0 );

   virtual ~OptionMultiString();

   virtual const StringValueClass* get_string( int number = 0 ) const;
   virtual StringValueClass* get_string( ValueClass* value,
                                         Option* context ) const;

  
   virtual bool parse( TokenStream* tokens, bool &changed,
		       ValueClass* parent = 0 );

private:
  suif_vector<String> *_storage_for_string;
};


class OptionInt : public Option {
public:


   OptionInt( String arguments = String("int"),
              int* storage_for_integer = 0 );

   virtual ~OptionInt();

   virtual IntValueClass* get_int( int number = 0 );
   virtual IntValueClass* get_int( ValueClass* value,
                                   Option* context ) const;

   virtual bool parse( TokenStream* tokens, bool &changed,
                       ValueClass* parent = 0 );

private:
  int* _storage_for_default_value;
};


class OptionLiteral : public Option {
public:


   OptionLiteral( String argument,
                  bool* storage_for_is_set = 0,
                  bool default_value = false );
   OptionLiteral( String argument,
		  String description,
                  bool* storage_for_is_set = 0,
                  bool default_value = false );
   virtual ~OptionLiteral();


   virtual bool is_set() const;
   virtual bool is_set ( ValueClass* value,
                                   Option* context ) const;

   virtual bool parse( TokenStream* tokens, bool &changed,
                       ValueClass* parent = 0 );

   virtual void print( String& command_line_string,
                       suif_vector<OptionDescription>* descriptions ) const;

private:
  bool* _storage_for_is_set;
  bool _default_value;
};


class OptionSelection : public Option {
public:
  OptionSelection( bool allow_empty = false );
  OptionSelection( Option *opt1, bool allow_empty );
  // add more options with "add"
  OptionSelection( Option *opt1, Option *opt2, bool allow_empty );

  virtual ~OptionSelection();

  virtual OptionSelection* add( Option* );

  virtual bool parse( TokenStream* tokens, bool &changed,
		      ValueClass* parent );

  virtual void delete_values();

  virtual void print( String& command_line_string,
                       suif_vector<OptionDescription>* descriptions ) const;

protected:
  bool _allow_empty;
  Options* sf_owned _selection_list;
};


class OptionList : public Option {
public:
  OptionList();
  OptionList(Option *opt1);
  OptionList(Option *opt1, Option *opt2);

  virtual ~OptionList();

  virtual OptionList* add( Option* );

  virtual bool parse( TokenStream* tokens, bool &changed,
		       ValueClass* parent = 0 );

  virtual void delete_values();

  virtual void print( String& command_line_string,
                       suif_vector<OptionDescription>* descriptions ) const;

private:
  suif_vector<sf_owned Option*>* sf_owned _option_list;
};


class OptionLoop : public Option {
public:
  OptionLoop( Option* loop_contents,
              bool allow_empty = true );

  virtual ~OptionLoop();

  bool parse( TokenStream* tokens, bool &changed,
              ValueClass* parent );

  virtual void delete_values();

  virtual void print( String& command_line_string,
                       suif_vector<OptionDescription>* descriptions ) const;

private:
  Option sf_owned * _loop_contents;
  bool _allow_empty;
};


class OptionStream : public Option {
public:
  OptionStream( String argument = emptyString,
               istream** storage_for_stream = 0 );
  virtual ~OptionStream();

  bool parse( TokenStream* tokens, bool &changed,
	      ValueClass* parent );

private:
  istream** _storage_for_stream;
};


Option* build_prefixed_string( String prefix, String argument,
			       String* storage,
			       String description = emptyString);


Option* build_multi_string( String argument,
                            suif_vector<String> &storage,
                            String description = emptyString);

#endif

---