SUMOSAXAttributes.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2007-2024 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
/****************************************************************************/
// Encapsulated SAX-Attributes
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <set>
 
#include <utils/common/StringUtils.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/ToString.h>
#include <utils/common/UtilExceptions.h>
#include "SUMOXMLDefinitions.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class Position;
class PositionVector;
class Boundary;
class RGBColor;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class SUMOSAXAttributes {
public:
    /* @brief Constructor
     * @param[in] tagName The name of the parsed object type; used for error message generation
     */
    SUMOSAXAttributes(const std::string& objectType);
 
 
    virtual ~SUMOSAXAttributes() { }
 
 
    template <typename T>
    T get(int attr, const char* objectid, bool& ok, bool report = true) const;
 
 
    template <typename T>
    T getOpt(int attr, const char* objectid, bool& ok, T defaultValue = T(), bool report = true) const;
 
 
    SUMOTime getSUMOTimeReporting(int attr, const char* objectid, bool& ok,
                                  bool report = true) const;
 
 
    SUMOTime getPeriod(const char* objectid, bool& ok, bool report = true) const;
 
 
    SUMOTime getOptSUMOTimeReporting(int attr, const char* objectid, bool& ok,
                                     SUMOTime defaultValue, bool report = true) const;
 
 
    SUMOTime getOptPeriod(const char* objectid, bool& ok, SUMOTime defaultValue, bool report = true) const;
 
 
 
 
    virtual bool hasAttribute(int id) const = 0;
 
 
    virtual bool hasAttribute(const std::string& id) const = 0;
 
 
    inline bool getBool(int id) const {
        return StringUtils::toBool(getString(id));
    }
 
    inline int getInt(int id) const {
        return StringUtils::toInt(getString(id));
    }
 
 
    virtual long long int getLong(int id) const {
        return StringUtils::toLong(getString(id));
    }
 
 
    virtual std::string getString(int id, bool* isPresent = nullptr) const = 0;
 
 
    virtual std::string getStringSecure(int id, const std::string& def) const = 0;
 
 
    inline double getFloat(int id) const {
        return StringUtils::toDouble(getString(id));
    }
 
 
    virtual double getFloat(const std::string& id) const = 0;
 
 
    virtual std::string getStringSecure(const std::string& id,
                                        const std::string& def) const = 0;
    //}
 
 
    virtual std::string getName(int attr) const = 0;
 
    virtual void serialize(std::ostream& os) const = 0;
 
    virtual std::vector<std::string> getAttributeNames() const = 0;
 
    const std::string& getObjectType() const {
        return myObjectType;
    }
 
    friend std::ostream& operator<<(std::ostream& os, const SUMOSAXAttributes& src);
 
    virtual SUMOSAXAttributes* clone() const = 0;
 
    static const std::string ENCODING;
 
 
protected:
    template <typename T> T fromString(const std::string& value) const;
    void emitUngivenError(const std::string& attrname, const char* objectid) const;
    void emitEmptyError(const std::string& attrname, const char* objectid) const;
    void emitFormatError(const std::string& attrname, const std::string& type, const char* objectid) const;
 
private:
    SUMOSAXAttributes(const SUMOSAXAttributes& src) = delete;
 
    SUMOSAXAttributes& operator=(const SUMOSAXAttributes& src) = delete;
 
    std::string myObjectType;
 
};
 
 
inline std::ostream& operator<<(std::ostream& os, const SUMOSAXAttributes& src) {
    src.serialize(os);
    return os;
}
 
 
template<typename X> struct invalid_return {
    static const X value;
};
 
#define INVALID_RETURN(TYPE) \
template<> struct invalid_return<TYPE> { \
    static const TYPE value; \
}
INVALID_RETURN(std::string);
INVALID_RETURN(int);
INVALID_RETURN(long long int);
INVALID_RETURN(double);
INVALID_RETURN(bool);
INVALID_RETURN(RGBColor);
INVALID_RETURN(Position);
INVALID_RETURN(PositionVector);
INVALID_RETURN(Boundary);
INVALID_RETURN(SumoXMLEdgeFunc);
INVALID_RETURN(SumoXMLNodeType);
INVALID_RETURN(RightOfWay);
INVALID_RETURN(FringeType);
INVALID_RETURN(ParkingType);
INVALID_RETURN(std::vector<std::string>);
INVALID_RETURN(std::vector<int>);
INVALID_RETURN(std::vector<double>);
 
 
template <typename T>
T SUMOSAXAttributes::get(int attr, const char* objectid,
                         bool& ok, bool report) const {
    try {
        bool isPresent = true;
        const std::string& strAttr = getString(attr, &isPresent);
        if (isPresent) {
            return fromString<T>(strAttr);
        }
        if (report) {
            emitUngivenError(getName(attr), objectid);
        }
    } catch (const FormatException& e) {
        if (report) {
            emitFormatError(getName(attr), e.what(), objectid);
        }
    } catch (EmptyData&) {
        if (report) {
            emitEmptyError(getName(attr), objectid);
        }
    }
    ok = false;
    return invalid_return<T>::value;
}
 
 
template <typename T>
T SUMOSAXAttributes::getOpt(int attr, const char* objectid,
                            bool& ok, T defaultValue, bool report) const {
    try {
        bool isPresent = true;
        const std::string& strAttr = getString(attr, &isPresent);
        if (isPresent) {
            return fromString<T>(strAttr);
        }
        return defaultValue;
    } catch (const FormatException& e) {
        if (report) {
            emitFormatError(getName(attr), e.what(), objectid);
        }
    } catch (EmptyData&) {
        if (report) {
            emitEmptyError(getName(attr), objectid);
        }
    }
    ok = false;
    return invalid_return<T>::value;
}