Option.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Classes representing a single program option (with different types)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <exception>
#include <utils/common/UtilExceptions.h>
 
// ===========================================================================
// class definitions
// ===========================================================================
 
typedef std::vector<int> IntVector;
 
typedef std::vector<std::string> StringVector;
 
#define CLONEABLE(Type) virtual Type* clone() const { return new Type(*this); }
 
/* -------------------------------------------------------------------------
 * Option
 * ----------------------------------------------------------------------- */
class Option {
 
public:
    virtual ~Option();
 
    bool isSet() const;
 
    virtual double getFloat() const;
 
    virtual int getInt() const;
 
    virtual std::string getString() const;
 
    virtual bool getBool() const;
 
    virtual const IntVector& getIntVector() const;
 
    virtual const StringVector& getStringVector() const;
 
    virtual bool set(const std::string& v, const std::string& orig, const bool append) = 0;
 
    const std::string& getValueString() const;
 
    virtual bool isDefault() const;
 
    virtual bool isInteger() const;
 
    virtual bool isFloat() const;
 
    virtual bool isBool() const;
 
    virtual bool isFileName() const;
 
    virtual bool isNetwork() const;
 
    virtual bool isAdditional() const;
 
    virtual bool isRoute() const;
 
    virtual bool isData() const;
 
    virtual bool isSumoConfig() const;
 
    virtual bool isEdge() const;
 
    virtual bool isEdgeVector() const;
 
    bool isWriteable() const;
 
    void resetWritable();
 
    void resetDefault();
 
    const std::string& getDescription() const;
 
    void setDescription(const std::string& desc);
 
    bool isRequired() const;
 
    void setRequired();
 
    bool isPositional() const;
 
    void setPositional();
 
    bool isEditable() const;
 
    void setEditable(const bool value);
 
    const std::string& getListSeparator() const;
 
    void setListSeparator(const std::string& listSep);
 
    const std::string& getSubTopic() const;
 
    void setSubtopic(const std::string& subtopic);
 
    virtual const std::string& getTypeName() const;
 
    virtual Option* clone() const = 0;
 
protected:
    bool markSet(const std::string& orig);
 
    Option(bool set = false);
 
    std::string myTypeName;
 
    std::string myValueString;
 
private:
    bool myAmSet;
 
    bool myHaveTheDefaultValue = true;
 
    bool myAmWritable = true;
 
    std::string myDescription;
 
    bool myRequired = false;
 
    bool myPositional = false;
 
    bool myEditable = true;
 
    std::string myListSeparator = "";
 
    std::string mySubTopic;
};
 
// -------------------------------------------------------------------------
// Option_Integer
// -------------------------------------------------------------------------
 
class Option_Integer : public Option {
 
public:
    Option_Integer(int value);
 
    int getInt() const;
 
    bool set(const std::string& v, const std::string& orig, const bool append);
 
    bool isInteger() const;
 
    CLONEABLE(Option_Integer)
 
private:
    int myValue;
};
 
// -------------------------------------------------------------------------
// Option_String
// -------------------------------------------------------------------------
 
class Option_String : public Option {
 
public:
    Option_String();
 
    Option_String(const std::string& value, std::string typeName = "STR");
 
    std::string getString() const;
 
    bool set(const std::string& v, const std::string& orig, const bool append);
 
    CLONEABLE(Option_String)
 
protected:
    std::string myValue;
};
 
// -------------------------------------------------------------------------
// Option_Float
// -------------------------------------------------------------------------
 
class Option_Float : public Option {
 
public:
    Option_Float(double value);
 
    double getFloat() const;
 
    bool set(const std::string& v, const std::string& orig, const bool append);
 
    bool isFloat() const;
 
    CLONEABLE(Option_Float)
 
private:
    double myValue;
};
 
// -------------------------------------------------------------------------
// Option_Bool
// -------------------------------------------------------------------------
 
class Option_Bool : public Option {
 
public:
    Option_Bool(bool value);
 
    bool getBool() const;
 
    bool set(const std::string& v, const std::string& orig, const bool append);
 
    bool isBool() const;
 
    CLONEABLE(Option_Bool)
 
protected:
    bool myValue;
};
 
// -------------------------------------------------------------------------
// Option_BoolExtended
// -------------------------------------------------------------------------
 
class Option_BoolExtended : public Option_Bool {
 
public:
    Option_BoolExtended(bool value);
 
    bool set(const std::string& v, const std::string& orig, const bool append);
 
    CLONEABLE(Option_BoolExtended)
};
 
// -------------------------------------------------------------------------
// Option_IntVector
// -------------------------------------------------------------------------
 
class Option_IntVector : public Option {
 
public:
    Option_IntVector();
 
    Option_IntVector(const IntVector& value);
 
    const IntVector& getIntVector() const;
 
    bool set(const std::string& v, const std::string& orig, const bool append);
 
    CLONEABLE(Option_IntVector)
 
private:
    IntVector myValue;
};
 
// -------------------------------------------------------------------------
// Option_StringVector
// -------------------------------------------------------------------------
 
class Option_StringVector : public Option {
 
public:
    Option_StringVector();
 
    Option_StringVector(const StringVector& value);
 
    const StringVector& getStringVector() const;
 
    bool set(const std::string& v, const std::string& orig, const bool append);
 
    CLONEABLE(Option_StringVector)
 
private:
    StringVector myValue;
};
 
// -------------------------------------------------------------------------
// Option_FileName
// -------------------------------------------------------------------------
 
class Option_FileName : public Option_StringVector {
 
public:
    Option_FileName();
 
    Option_FileName(const StringVector& value);
 
    bool isFileName() const;
 
    std::string getString() const;
 
    CLONEABLE(Option_FileName)
};
 
// -------------------------------------------------------------------------
// Option_Network
// -------------------------------------------------------------------------
 
class Option_Network : public Option_String {
 
public:
    Option_Network(const std::string& value);
 
    bool isNetwork() const;
 
    CLONEABLE(Option_Network)
};
 
// -------------------------------------------------------------------------
// Option_Additional
// -------------------------------------------------------------------------
 
class Option_Additional : public Option_String {
 
public:
    Option_Additional(const std::string& value);
 
    bool isAdditional() const;
 
    CLONEABLE(Option_Additional)
};
 
// -------------------------------------------------------------------------
// Option_Route
// -------------------------------------------------------------------------
 
class Option_Route : public Option_String {
 
public:
    Option_Route(const std::string& value);
 
    bool isRoute() const;
 
    CLONEABLE(Option_Route)
};
 
// -------------------------------------------------------------------------
// Option_Data
// -------------------------------------------------------------------------
 
class Option_Data : public Option_String {
 
public:
    Option_Data(const std::string& value);
 
    bool isData() const;
 
    CLONEABLE(Option_Data)
};
 
// -------------------------------------------------------------------------
// Option_SumoConfig
// -------------------------------------------------------------------------
 
class Option_SumoConfig : public Option_String {
 
public:
    Option_SumoConfig(const std::string& value);
 
    bool isSumoConfig() const;
 
    CLONEABLE(Option_SumoConfig)
};
 
// -------------------------------------------------------------------------
// Option_Edge
// -------------------------------------------------------------------------
 
class Option_Edge : public Option_String {
 
public:
    Option_Edge(const std::string& value);
 
    bool isEdge() const;
 
    CLONEABLE(Option_Edge)
};
 
// -------------------------------------------------------------------------
// Option_EdgeVector
// -------------------------------------------------------------------------
 
class Option_EdgeVector : public Option_String {
 
public:
    Option_EdgeVector(const std::string& value);
 
    bool isEdgeVector() const;
 
    CLONEABLE(Option_EdgeVector)
};