eoParser.h

/* (c) Marc Schoenauer, Maarten Keijzer, GeNeura Team, Thales group

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
Authors:
    todos@geneura.ugr.es, http://geneura.ugr.es
    Marc.Schoenauer@polytechnique.fr
    mkeijzer@dhi.dk
    Johann Dréo <johann.dreo@thalesgroup.com>
*/


#ifndef EO_PARSER_H
#define EO_PARSER_H

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

#include "eoParam.h"
#include "eoObject.h"
#include "eoPersistent.h"
#include "eoExceptions.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; }


    std::string get( const std::string & name) const;


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


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


    template<class ValueType>
    ValueType valueOf(const std::string& _name) const
    {
        eoParam* param = getParam(_name);

        // Note: eoParam is the polymorphic base class of eoValueParam, thus we can do a dynamix cast
        eoValueParam<ValueType>* vparam = dynamic_cast< eoValueParam<ValueType>* >(param);

        if( vparam == NULL ) {
            // if the dynamic cast has failed, chances are that ValueType 
            // is not the same than the one used at declaration.
            throw eoWrongParamTypeException( _name );
        } else {
            return vparam->value();
        }
    }



    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;
            } else {
                // 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);

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

  void updateParameters();

  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;

  // flag that marks if the user need to know that there was a problem
  // used to display the message about "-h" only once
  bool needHelpMessage;

  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: