GNEAttributeCarrier.h

Go to the documentation of this file.

/****************************************************************************/
// Abstract Base class for gui objects which carry attributes
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO 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 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef GNEAttributeCarrier_h
#define GNEAttributeCarrier_h


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

#include <string>
#include <vector>
#include <map>
#include <utils/xml/SUMOSAXHandler.h>
#include <utils/xml/SUMOXMLDefinitions.h>
#include <utils/common/MsgHandler.h>
#include <utils/common/RGBColor.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/ToString.h>
#include <utils/common/TplConvert.h>
#include <utils/gui/images/GUIIcons.h>
#include "GNEReferenceCounter.h"


// ===========================================================================
// class declarations
// ===========================================================================
class GNENet;
class GNEUndoList;

// ===========================================================================
// class definitions
// ===========================================================================
class GNEAttributeCarrier : public GNEReferenceCounter {
    friend class GNEChange_Attribute;

public:
    GNEAttributeCarrier(SumoXMLTag tag, GUIIcon icon);

    virtual ~GNEAttributeCarrier() {};

    /* @brief method for getting the Attribute of an XML key
     * @param[in] key The attribute key
     * @return string with the value associated to key
     */
    virtual std::string getAttribute(SumoXMLAttr key) const = 0;

    /* @brief method for setting the attribute and letting the object perform additional changes
     * @param[in] key The attribute key
     * @param[in] value The new value
     * @param[in] undoList The undoList on which to register changes
     * @param[in] net optionally the GNENet to inform about gui updates
     */
    virtual void setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) = 0;

    /* @brief method for setting the attribute and letting the object perform additional changes
    * @param[in] key The attribute key
    * @param[in] value The new value
    * @param[in] undoList The undoList on which to register changes
    */
    virtual bool isValid(SumoXMLAttr key, const std::string& value) = 0;

    virtual std::string getAttributeForSelection(SumoXMLAttr key) const;

    SumoXMLTag getTag() const;

    FXIcon* getIcon() const;

    GUIIcon getGUIIcon() const;

    std::vector<SumoXMLAttr> getAttrs() const;

    const std::string getID() const;

    static std::string getAttributeType(SumoXMLTag tag, SumoXMLAttr attr);

    static const std::vector<std::pair<SumoXMLAttr, std::string> >& allowedAttributes(SumoXMLTag tag);

    static std::vector<SumoXMLTag> allowedTags();

    static const std::vector<SumoXMLTag>& allowedNetElementsTags();

    static const std::vector<SumoXMLTag>& allowedAdditionalTags();

    static const std::vector<SumoXMLTag>& allowedShapeTags();

    static bool canBlockMovement(SumoXMLTag tag);

    static bool canBlockShape(SumoXMLTag tag);

    static bool isNumerical(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isInt(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isFloat(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isTime(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isBool(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isColor(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isString(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isList(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isUnique(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isDiscrete(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isPositive(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isProbability(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isFilename(SumoXMLTag tag, SumoXMLAttr attr);

    static bool isNonEditable(SumoXMLTag tag, SumoXMLAttr attr);

    static bool hasAttribute(SumoXMLTag tag, SumoXMLAttr attr);

    static bool hasDefaultValue(SumoXMLTag tag, SumoXMLAttr attr);

    static const std::vector<std::string>& discreteChoices(SumoXMLTag tag, SumoXMLAttr attr);

    static bool discreteCombinableChoices(SumoXMLTag tag, SumoXMLAttr attr);

    static std::string getDefinition(SumoXMLTag tag, SumoXMLAttr attr);

    static int getHigherNumberOfAttributes();

    template<typename T>
    static T getDefaultValue(SumoXMLTag tag, SumoXMLAttr attr);

    template<typename T>
    static bool canParse(const std::string& string) {
        try {
            parse<T>(string);
        } catch (NumberFormatException&) {
            return false;
        } catch (EmptyData&) {
            return false;
        } catch (BoolFormatException&) {
            return false;
        }
        return true;
    }

    template<typename T>
    static T parse(const std::string& string);

    template<typename T>
    static bool isPositive(const std::string& string) {
        return canParse<T>(string) && parse<T>(string) > 0;
    }

    static bool isValidID(const std::string& value);

    static bool isValidFilename(const std::string& value);

    static const std::string LOADED;

    static const std::string GUESSED;

    static const std::string MODIFIED;

    static const std::string APPROVED;

    static const double INVALID_POSITION;

    template <typename T>
    static T parseAttributeFromXML(const SUMOSAXAttributes& attrs, const char* objectid, const SumoXMLTag tag, const SumoXMLAttr attribute, bool& abort, bool report = true) {
        bool ok = true;
        std::string parsedAttribute = "0";
        // only show one warning for every error/warning loading additional
        if (!abort) {
            // set additionalOfWarningMessage
            std::string additionalOfWarningMessage;
            if (objectid) {
                additionalOfWarningMessage = toString(tag) + " with ID '" + toString(objectid) + "'";
            } else {
                additionalOfWarningMessage = toString(tag);
            }
            // first check that attribute exists
            if (attrs.hasAttribute(attribute)) {
                // Parse attribute as string
                parsedAttribute = attrs.get<std::string>(attribute, objectid, ok, false);
                // check that parsed attribute can be converted to type T
                if (ok && !canParse<T>(parsedAttribute)) {
                    ok = false;
                }
                std::string errorFormat;
                // Set extra checks for int values
                if (isInt(tag, attribute)) {
                    if (canParse<int>(parsedAttribute)) {
                        // parse to int and check if can be negative
                        int parsedIntAttribute = parse<int>(parsedAttribute);
                        if (isPositive(tag, attribute) && parsedIntAttribute < 0) {
                            errorFormat = "Cannot be negative; ";
                            ok = false;
                        }
                    } else {
                        errorFormat = "Cannot be parsed to int; ";
                        ok = false;
                    }
                }
                // Set extra checks for float(double) values
                if (isFloat(tag, attribute)) {
                    if (canParse<double>(parsedAttribute)) {
                        // parse to double and check if can be negative
                        double parsedSumoRealAttribute = parse<double>(parsedAttribute);
                        if (isPositive(tag, attribute) && parsedSumoRealAttribute < 0) {
                            errorFormat = "Cannot be negative; ";
                            ok = false;
                        }
                    } else {
                        errorFormat = "Cannot be parsed to float; ";
                        ok = false;
                    }
                }
                // set extra check for time(double) values
                if (isTime(tag, attribute)) {
                    if (canParse<double>(parsedAttribute)) {
                        // parse to SUMO Real and check if is negative
                        double parsedSumoRealAttribute = parse<double>(parsedAttribute);
                        if (parsedSumoRealAttribute < 0) {
                            errorFormat = "Time cannot be negative; ";
                            ok = false;
                        }
                    } else {
                        errorFormat = "Cannot be parsed to time; ";
                        ok = false;
                    }
                }
                // set extra check for color values
                if (isColor(tag, attribute) && !canParse<RGBColor>(parsedAttribute)) {
                    errorFormat = "Invalid RGB format or named color; ";
                    ok = false;
                }
                // set extra check for filename values
                if (isFilename(tag, attribute) && (isValidFilename(parsedAttribute) == false)) {
                    errorFormat = "Filename contains invalid characters; ";
                    ok = false;
                }
                // set extra check for Vehicle Classes
                if ((!ok) && (attribute == SUMO_ATTR_VCLASS)) {
                    errorFormat = "Is not a part of defined set of Vehicle Classes; ";
                }
                // set extra check for Vehicle Classes
                if ((!ok) && (attribute == SUMO_ATTR_GUISHAPE)) {
                    errorFormat = "Is not a part of defined set of Gui Vehicle Shapes; ";
                }
                // If attribute has an invalid format
                if (!ok) {
                    // if attribute has a default value, take it as string. In other case, abort.
                    if (hasDefaultValue(tag, attribute)) {
                        parsedAttribute = toString(getDefaultValue<T>(tag, attribute));
                        // report warning of default value
                        if (report) {
                            WRITE_WARNING("Format of optional " + getAttributeType(tag, attribute) + " attribute '" + toString(attribute) + "' of " +
                                          additionalOfWarningMessage + " is invalid; " + errorFormat + "Default value '" + toString(parsedAttribute) + "' will be used.");
                        }
                    } else {
                        WRITE_WARNING("Format of essential " + getAttributeType(tag, attribute) + " attribute '" + toString(attribute) + "' of " +
                                      additionalOfWarningMessage +  " is invalid; " + errorFormat + "" + toString(tag) + " cannot be created");
                        // set default value of parsedAttribute (to avoid exceptions during conversions)
                        parsedAttribute = "0";
                        abort = true;
                    }
                }
            } else {
                // if attribute has a default value, take it. In other case, abort.
                if (hasDefaultValue(tag, attribute)) {
                    parsedAttribute = toString(getDefaultValue<T>(tag, attribute));
                    // report warning of default value
                    if (report) {
                        WRITE_WARNING("Optional " + getAttributeType(tag, attribute) + " attribute '" + toString(attribute) + "' of " +
                                      additionalOfWarningMessage + " is missing; Default value '" + toString(parsedAttribute) + "' will be used.");
                    }
                } else {
                    WRITE_WARNING("Essential " + getAttributeType(tag, attribute) + " attribute '" + toString(attribute) + "' of " +
                                  additionalOfWarningMessage +  " is missing; " + toString(tag) + " cannot be created");
                    abort = true;
                }
            }
        }
        // return parsed attribute
        return parse<T>(parsedAttribute);
    }


private:
    virtual void setAttribute(SumoXMLAttr key, const std::string& value) = 0;

    const SumoXMLTag myTag;

    GUIIcon myIcon;

    static std::map<SumoXMLTag, std::vector<std::pair <SumoXMLAttr, std::string> > > _allowedAttributes;

    static std::vector<SumoXMLTag> myAllowedNetElementTags;

    static std::vector<SumoXMLTag> myAllowedAdditionalTags;

    static std::vector<SumoXMLTag> myAllowedShapeTags;

    static std::vector<SumoXMLTag> myBlockMovementTags;

    static std::vector<SumoXMLTag> myBlockShapeTags;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myNumericalIntAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myNumericalFloatAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myTimeAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myBoolAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myColorAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myListAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myUniqueAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myNonEditableAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myPositiveAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myProbabilityAttrs;

    static std::map<SumoXMLTag, std::set<SumoXMLAttr> > myFileAttrs;

    static std::map<SumoXMLTag, SumoXMLTag> myAllowedAdditionalWithParentTags;

    static std::map<SumoXMLTag, std::map<SumoXMLAttr, std::vector<std::string> > > myDiscreteChoices;

    static std::map<SumoXMLTag, std::map<SumoXMLAttr, std::string> > myAttrDefinitions;

    static int myMaxNumAttribute;

    GNEAttributeCarrier& operator=(const GNEAttributeCarrier& src) = delete;
};

#endif

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