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;
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,
                       ErrorSubSystem* output_for_errors );

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

   virtual void print_to_stream( ostream& print_stream );

   virtual bool parse( TokenStream* tokens, 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 );

  
   virtual void set_argument( const String& argument );

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

   virtual ~Option();

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

//   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, ValueClass* parent = 0 );

private:
   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, 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, 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 );
   virtual ~OptionLiteral();


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

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

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

private:
  bool* _storage_for_is_set;
  bool _default_value;
};





class OptionSelection : public Option {
public:
  OptionSelection( bool allow_empty = false );

  virtual ~OptionSelection();

  virtual OptionSelection* add( Option* );

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

  virtual void delete_values();

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

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




class OptionList : public Option {
public:
  OptionList();

  virtual ~OptionList();

  virtual OptionList* add( Option* );

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

  virtual void delete_values();

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

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, ValueClass* parent );

  virtual void delete_values();

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

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, 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

---