Option.h

Go to the documentation of this file.

/****************************************************************************/
// Classes representing a single program option (with different types)
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef Option_h
#define Option_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <string>
#include <vector>
#include <exception>
#include <utils/common/UtilExceptions.h>


// ===========================================================================
// class definitions
// ===========================================================================
typedef std::vector<int> IntVector;


/* -------------------------------------------------------------------------
 * Option
 * ----------------------------------------------------------------------- */
class Option {
public:
    virtual ~Option() throw();


    bool isSet() const throw();


    virtual SUMOReal getFloat() const throw(InvalidArgument);


    virtual int getInt() const throw(InvalidArgument);


    virtual std::string getString() const throw(InvalidArgument);


    virtual bool getBool() const throw(InvalidArgument);


    virtual const IntVector &getIntVector() const throw(InvalidArgument);


    virtual bool set(const std::string &v) throw(InvalidArgument);


    virtual bool set(bool v) throw(InvalidArgument);


    virtual std::string getValueString() const throw(InvalidArgument);


    virtual bool isBool() const throw();


    virtual bool isDefault() const throw();


    virtual bool isFileName() const throw();


    bool isWriteable() const throw();


    friend class OptionsCont;


    const std::string &getDescription() const throw();


    virtual const std::string &getTypeName() const throw();


protected:
    bool markSet() throw();


protected:
    Option(bool set=false) throw();


    Option(const Option &s) throw();


    virtual Option &operator=(const Option &s) throw();


protected:
    std::string myTypeName;


private:
    bool myAmSet;

    bool myHaveTheDefaultValue;

    bool myAmWritable;

    std::string myDescription;

};


/* -------------------------------------------------------------------------
 * Option_Integer
 * ----------------------------------------------------------------------- */
class Option_Integer : public Option {
public:
    Option_Integer() throw();


    Option_Integer(int value) throw();


    Option_Integer(const Option_Integer &s) throw();


    ~Option_Integer() throw();


    Option_Integer &operator=(const Option_Integer &s) throw();


    int getInt() const throw(InvalidArgument);


    bool set(const std::string &v) throw(InvalidArgument);


    std::string getValueString() const throw(InvalidArgument);


private:
    int      myValue;

};


/* -------------------------------------------------------------------------
 * Option_String
 * ----------------------------------------------------------------------- */
class Option_String : public Option {
public:
    Option_String() throw();


    Option_String(const std::string &value, std::string typeName="STR") throw();


    Option_String(const Option_String &s) throw();


    virtual ~Option_String() throw();


    Option_String &operator=(const Option_String &s) throw();


    std::string getString() const throw(InvalidArgument);


    bool set(const std::string &v) throw(InvalidArgument);


    std::string getValueString() const throw(InvalidArgument);


protected:
    std::string      myValue;

};


/* -------------------------------------------------------------------------
 * Option_Float
 * ----------------------------------------------------------------------- */
class Option_Float : public Option {
public:
    Option_Float() throw();


    Option_Float(SUMOReal value) throw();


    Option_Float(const Option_Float &s) throw();


    ~Option_Float() throw();


    Option_Float &operator=(const Option_Float &s) throw();


    SUMOReal getFloat() const throw(InvalidArgument);


    bool set(const std::string &v) throw(InvalidArgument);


    std::string getValueString() const throw(InvalidArgument);


private:
    SUMOReal       myValue;

};


/* -------------------------------------------------------------------------
 * Option_Bool
 * ----------------------------------------------------------------------- */
class Option_Bool : public Option {
public:
    Option_Bool() throw();


    Option_Bool(bool value) throw();


    Option_Bool(const Option_Bool &s) throw();


    ~Option_Bool() throw();


    Option_Bool &operator=(const Option_Bool &s) throw();


    bool getBool() const throw(InvalidArgument);

    bool set(bool v) throw(InvalidArgument);


    std::string getValueString() const throw(InvalidArgument);


    bool isBool() const throw();


private:
    bool        myValue;

};


/* -------------------------------------------------------------------------
 * Option_FileName
 * ----------------------------------------------------------------------- */
class Option_FileName : public Option_String {
public:
    Option_FileName() throw();


    Option_FileName(const std::string &value) throw();


    Option_FileName(const Option_String &s) throw();


    virtual ~Option_FileName() throw();

    Option_FileName &operator=(const Option_FileName &s) throw();


    bool isFileName() const throw();

};


/* -------------------------------------------------------------------------
 * Option_IntVector
 * ----------------------------------------------------------------------- */
class Option_IntVector : public Option {
public:
    Option_IntVector() throw();


    Option_IntVector(const IntVector &value) throw();


    Option_IntVector(const Option_IntVector &s) throw();


    virtual ~Option_IntVector() throw();


    Option_IntVector &operator=(const Option_IntVector &s) throw();


    const IntVector &getIntVector() const throw(InvalidArgument);


    bool set(const std::string &v) throw(InvalidArgument);


    std::string getValueString() const throw(InvalidArgument);


private:
    IntVector myValue;
};


#endif

/****************************************************************************/