eoParser.h

/* (c) Marc Schoenauer, Maarten Keijzer and GeNeura Team, 2000

This library is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option) any
later version.

This library 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this library; if not, write to the Free Software Foundation, Inc., 59
Temple Place, Suite 330, Boston, MA 02111-1307 USA

Contact: http://eodev.sourceforge.net
         todos@geneura.ugr.es, http://geneura.ugr.es
         Marc.Schoenauer@polytechnique.fr
         mkeijzer@dhi.dk
*/


#ifndef EO_PARSER_H
#define EO_PARSER_H

#include <map>
#include <sstream>
#include <string>

#include "eoParam.h"
#include "eoObject.h"
#include "eoPersistent.h"

class eoParameterLoader
{
public :

    virtual ~eoParameterLoader();

    virtual void processParam(eoParam& param, std::string section = "") = 0;

    virtual bool isItThere(eoParam& _param) const = 0;

    template <class ValueType>
    eoValueParam<ValueType>& createParam(ValueType _defaultValue,
                                         std::string _longName,
                                         std::string _description,
                                         char _shortHand = 0,
                                         std::string _section = "",
                                         bool _required = false)
        {
            eoValueParam<ValueType>* p = new eoValueParam<ValueType>(_defaultValue,
                                                                     _longName,
                                                                     _description,
                                                                     _shortHand,
                                                                     _required);
            ownedParams.push_back(p);
            processParam(*p, _section);
            return *p;
        }


private :

    std::vector<eoParam*> ownedParams;
};



class eoParser : public eoParameterLoader, public eoObject, public eoPersistent
{

public:

  eoParser ( unsigned _argc, char **_argv , std::string _programDescription = "",
           std::string _lFileParamName = "param-file", char _shortHand = 'p');

  void processParam(eoParam& param, std::string section = "");

  void readFrom(std::istream& is);

  void printOn(std::ostream& os) const;

  std::string className(void) const { return "Parser"; }

  bool userNeedsHelp(void);
  void printHelp(std::ostream& os);

  std::string ProgramName() { return programName; }

    virtual bool isItThere(eoParam& _param) const
        { return getValue(_param).first; }

    eoParam * getParamWithLongName(const std::string& _name) const;



    template <class ValueType>
    eoValueParam<ValueType>& getORcreateParam(ValueType _defaultValue,
                                              std::string _longName,
                                              std::string _description,
                                              char _shortHand = 0,
                                              std::string _section = "",
                                              bool _required = false)
        {
            eoParam* ptParam = getParamWithLongName(_longName);
            if (ptParam) {
                // found
                eoValueParam<ValueType>* ptTypedParam =
                    dynamic_cast<eoValueParam<ValueType>*>(ptParam);
                return *ptTypedParam;
            }
            // not found -> create it
            return createParam (_defaultValue, _longName, _description,
                                _shortHand, _section, _required);
        }



    template <class ValueType>
    eoValueParam<ValueType>& setORcreateParam(ValueType _defaultValue,
                                              std::string _longName,
                                              std::string _description,
                                              char _shortHand = 0,
                                              std::string _section = "",
                                              bool _required = false)
        {
            eoValueParam<ValueType>& param = createParam(_defaultValue, _longName, _description,
                                                         _shortHand, _section, _required);
            std::ostringstream os;
            os << _defaultValue;
            if(isItThere(param)) {
                param.setValue(os.str());
            } else {
                longNameMap[_longName] = os.str();
                shortNameMap[_shortHand] = os.str();
            }
            return param;
        }



    void setStopOnUnknownParam(bool _b) {stopOnUnknownParam.value()=_b;}
    bool getStopOnUnknownParam() {return stopOnUnknownParam.value();}

    void setPrefix(const std:: string & _prefix) {prefix = _prefix;}

  void resetPrefix() {prefix = "";}

  std::string getPrefix() {return prefix;}

private:

  void doRegisterParam(eoParam& param) const;

  std::pair<bool, std::string> getValue(eoParam& _param) const;

  void updateParameters() const;

  typedef std::multimap<std::string, eoParam*> MultiMapType;

  // used to store all parameters that are processed
  MultiMapType params;

  std::string programName;
  std::string programDescription;

  typedef std::map<char, std::string> ShortNameMapType;
  ShortNameMapType shortNameMap;

  typedef std::map<std::string, std::string> LongNameMapType;
  LongNameMapType longNameMap;

  eoValueParam<bool>   needHelp;
  eoValueParam<bool>   stopOnUnknownParam;

  mutable std::vector<std::string> messages;

  std::string prefix;   // used for all created params - in processParam

};



#endif //  EO_PARSER_H



// Local Variables:
// coding: iso-8859-1
// mode:C++
// c-file-style: "Stroustrup"
// comment-column: 35
// fill-column: 80
// End:

---