ErrOptParser.hh

#ifndef ERROPTPARSER_HH
#define ERROPTPARSER_HH

//--------------------------------------------------------------------------
//
// $Id: ErrOptParser.hh,v 1.1.1.1 2005/03/29 17:04:19 steinke Exp $
//
// Environment:
//      This software was developed for the BaBar collaboration.  If you
//      use all or part of it, please give an appropriate acknowledgement.
//
// Copyright Information:
//      Copyright (C) 2002   California Institute of Technology
//
//------------------------------------------------------------------------

//-----------------
// C/C++ Headers --
//-----------------
#include <string>
#include <map>
#include <iostream>

#include "ErrLogger/ErrOpt.hh"

/**
 *  ErrOptParser keeps a register of acceptable error suboptions for a given
 *  derivative of ErrLog and processes values specified at the command 
 *  line.
 *
 *  How to use it:
 *    1) Create an ErrOptParser.
 *    2) Instantiate some variables to hold suboption values.
 *    3) Instantiate ErrOptRef<T>'s specifying names and value-parsing
 *       behavior for suboptions and attach them to the corresponding
 *       variables.
 *    4) Call registerOption() and registerNegatableOption() as desired.
 *    5) Obtain a suboption string suitable for use as the first 
 *       argument to Unix98 getsubopt().  Typically this might be the
 *       value for the "-E" option on the command line.
 *    6) Pass this string to parseOpt() and check return value for success.
 *    7) Use the values in the option variables.
 *
 *  The class is intended to be extensible so that additional types of
 *  options beyond the two already provided can be defined.  (This hasn't
 *  been attempted; please complain if you try to do so and the right 
 *  things haven't been exposed as "protected".
 *
 *  This software was developed for the BaBar collaboration.  If you
 *  use all or part of it, please give an appropriate acknowledgement.
 *
 *  Copyright (C) 2002   California Institute of Technology
 *
 *  @version $Id: ErrOptParser.hh,v 1.1.1.1 2005/03/29 17:04:19 steinke Exp $
 *
 *  @author Matt Dorsten  (originator)
 *  @author Gregory Dubois-Felsmann
 */

class ErrOptParser {

public:
  ErrOptParser() : optmap_() { }
  virtual ~ErrOptParser(); 

  /**
   *  Register a named suboption associated with a value of type T.
   *  Instances of "<name>=<value>" in the parsed suboption string
   *  will result in the value string being converted to T using the
   *  operator>>(std::istream&, T&) stream extractor.  An error message and
   *  failure status will be returned if that conversion fails.
   *
   *  Whether the value is required to be present or not is controlled
   *  by the ErrOpt::ValType used in the construction of the ErrOptRef<T>.
   *
   *  Following parsing, the ErrOptRef<T>::present() function can be used
   *  to determine whether the suboption was specified at all.
   */
  template<class T> bool registerOption( ErrOptRef<T>& );

  /**
   *  Register a named negatable Boolean suboption.  This causes the
   *  following forms to be acceptable in the parse:
   *
   *     <name>
   *     <name>=<value>
   *     no<name>
   *
   *  Whether one or the other or both of the first two are accepted 
   *  is under the the control of the ErrOpt::ValType used in the
   *  construction of the ErrOptRef<bool>.
   *
   *  The acceptable value strings are "true", "1", "false", and "0",
   *  the ones understood when "boolalpha" is used in Standard iostreams
   *  input of bool values (i.e., not "yes" or "no" and not abbreviations),
   *  for consistency with the templated form of registerOption().  This 
   *  is subject to future revision.
   *
   *  An error message and failure status will be returned if this conversion
   *  fails.
   *
   *  Following parsing, the ErrOptRef<bool>::present() function can be 
   *  used to determine whether the suboption was specified at all.  The
   *  presence of either the "<name>" or "no<name>" form will cause
   *  present() to return true.
   */
  bool registerNegatableOption( ErrOptRef<bool>& );

  /** 
   *  Parse a suboption string suitable for use as the first argument to
   *  Unix98 getsubopt().  The string is copied internally before being
   *  passed to getsubopt(), however, so the caller's string will not see
   *  the modifications (insertions of '\0') that getsubopt() performs on
   *  its input.
   *
   *  Returns false if any unregistered option is found, if the 
   *  ErrOpt::ValType constraint for any registered option is violated,
   *  or if the parsing of any value fails.  It is unspecified whether
   *  all the parsing will have been attempted if any of it fails.  It is
   *  intended that an application not try to proceed beyond such a failure
   *  and use the variables attached to the options; they may not be in a
   *  consistent state.
   */
  virtual bool parseOpts( const char* );
  
protected:

  /**
   *  Process the value for a single named suboption.  The second 
   *  argument is intended to be the value pointer obtained from 
   *  getsubopt(), and so can be 0 if the suboption didn't come with
   *  an "=<value>" string in the input.
   */
  virtual bool processOption( const std::string&, const char* );

  class OptHelperBase{
  protected:
    OptHelperBase( ) { }
  public:
    virtual ~OptHelperBase( ) { }
    virtual bool processValue(const char*) = 0;
  };  

  template<class T> class OptHelper : public OptHelperBase{
  public:
    OptHelper( ErrOptRef<T>& optref )
      : OptHelperBase(), optref_(optref) { }
    virtual bool processValue(const char*);
  private:
    ErrOptRef<T>& optref_;
  };
  
  class BoolHelper : public OptHelperBase{
  public:
    BoolHelper( ErrOptRef<bool>& optref, bool negated )
      : OptHelperBase(), optref_(optref), negated_(negated) { }
    virtual bool processValue(const char*);
  private:
    // need to fix when Standard iostreams bool extraction is available  FIXME
    static bool getbool(const std::string&, bool&);

    ErrOptRef<bool>& optref_;
    bool negated_;
  };

  // The nested classes above need to be made friends so that they can use
  // the "setPresent" door into the private interface of ErrOpt.  Note
  // that this is not appropriate to do through the OptHelperBase class,
  // because not all possible subclasses of it might concern themselves
  // with ErrOpt objects at all.
  template <class T> friend class OptHelper;
  friend class BoolHelper;

  static void setPresent( ErrOpt& eo, bool b ) { eo.setPresent(b); }


private:
  ErrOptParser(const ErrOptParser&);            // prevent copying
  ErrOptParser& operator=(const ErrOptParser&);

  typedef std::map<std::string, OptHelperBase*> MapType;
  MapType optmap_;
};
  
#endif