GNEAttributeCarrier.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// Abstract Base class for gui objects which carry attributes
/****************************************************************************/
#ifndef GNEAttributeCarrier_h
#define GNEAttributeCarrier_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <fx.h>
#include <string>
#include <vector>
#include <map>
#include <utils/gui/settings/GUIVisualizationSettings.h>
#include <utils/xml/SUMOSAXHandler.h>
#include <utils/xml/SUMOXMLDefinitions.h>
#include <utils/common/UtilExceptions.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 GNEEdge;
class GNELane;
class GNEUndoList;
class GUIGlObject;

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

public:
    enum AttrProperty {
        ATTRPROPERTY_INT =          1 << 0,     // Attribute is an integer (Including Zero)
        ATTRPROPERTY_FLOAT =        1 << 1,     // Attribute is a float
        ATTRPROPERTY_BOOL =         1 << 2,     // Attribute is boolean (0/1, true/false)
        ATTRPROPERTY_STRING =       1 << 3,     // Attribute is a string
        ATTRPROPERTY_POSITION =     1 << 4,     // Attribute is a position defined by doubles (x,y or x,y,z)
        ATTRPROPERTY_COLOR =        1 << 5,     // Attribute is a color defined by a specifically word (Red, green) or by a special format (XXX,YYY,ZZZ)
        ATTRPROPERTY_VCLASS =       1 << 6,     // Attribute is a VClass (passenger, bus, motorcicle...)
        ATTRPROPERTY_POSITIVE =     1 << 7,     // Attribute is positive (Including Zero)
        ATTRPROPERTY_NOTZERO =      1 << 8,     // Attribute cannot be 0 (only for numerical attributes)
        ATTRPROPERTY_UNIQUE =       1 << 9,     // Attribute is unique (cannot be edited in a selection of similar elements (ID, Position...)
        ATTRPROPERTY_FILENAME =     1 << 10,    // Attribute is a filename (string that cannot contains certain characters)
        ATTRPROPERTY_NONEDITABLE =  1 << 11,    // Attribute is non editable (index of a lane)
        ATTRPROPERTY_DISCRETE =     1 << 12,    // Attribute is discrete (only certain values are allowed)
        ATTRPROPERTY_PROBABILITY =  1 << 13,    // Attribute is probability (only allowed values between 0 and 1, including both)
        ATTRPROPERTY_TIME =         1 << 14,    // Attribute is a Time (float positive)
        ATTRPROPERTY_ANGLE =        1 << 15,    // Attribute is an angle (only takes values between 0 and 360, including both, another value will be automatically reduced
        ATTRPROPERTY_LIST =         1 << 16,    // Attribute is a list of other elements separated by spaces
        ATTRPROPERTY_OPTIONAL =     1 << 17,    // Attribute is optional
        ATTRPROPERTY_DEFAULTVALUE = 1 << 18,    // Attribute owns a default value
        ATTRPROPERTY_COMBINABLE =   1 << 19,    // Attribute is combinable with other Attribute
        ATTRPROPERTY_SYNONYM =      1 << 20,    // Element will be written with a different name in der XML
    };

    class AttributeValues {
    public:
        AttributeValues();

        AttributeValues(int attributeProperty, int positionListed, const std::string& definition, const std::string& defaultValue, const std::vector<std::string>& discreteValues, SumoXMLAttr synonym);

        int getPositionListed() const;

        const std::string& getDefinition() const;

        const std::string& getDefaultValue() const;

        std::string getDescription() const;

        const std::vector<std::string>& getDiscreteValues() const;

        SumoXMLAttr getAttrSynonym() const;

        bool hasDefaultValue() const;

        bool hasAttrSynonym() const;

        bool isInt() const;

        bool isFloat() const;

        bool isBool() const;

        bool isString() const;

        bool isProbability() const;

        bool isNumerical() const;

        bool isTime() const;

        bool isPositive() const;

        bool isntZero() const;

        bool isColor() const;

        bool isFilename() const;

        bool isVClass() const;

        bool isSVCPermission() const;

        bool isList() const;

        bool isUnique() const;

        bool isOptional() const;

        bool isDiscrete() const;

        bool isCombinable() const;

        bool isNonEditable() const;

    private:
        int myAttributeProperty;

        int myPositionListed;

        std::string myDefinition;

        std::string myDefaultValue;

        std::vector<std::string> myDiscreteValues;

        SumoXMLAttr myAttrSynonym;
    };

    enum TAGProperty {
        TAGPROPERTY_NETELEMENT =          1 << 0,   // Edges, Junctions, Lanes...
        TAGPROPERTY_ADDITIONAL =          1 << 1,   // Bus Stops, Charging Stations, Detectors...
        TAGPROPERTY_SHAPE =               1 << 2,   // POIs, Polygons
        TAGPROPERTY_STOPPINGPLACE =       1 << 3,   // StoppingPlaces (BusStops, ChargingStations...)
        TAGPROPERTY_DETECTOR =            1 << 4,   // Detectors (E1, E2...)
        TAGPROPERTY_ROUTEELEMENT =        1 << 5,   // VTypes, Vehicles, Flows...
        TAGPROPERTY_DRAWABLE =            1 << 6,   // Element can be drawed in view
        TAGPROPERTY_BLOCKMOVEMENT =       1 << 7,   // Element can block their movement
        TAGPROPERTY_BLOCKSHAPE =          1 << 8,   // Element can block their shape
        TAGPROPERTY_CLOSESHAPE =          1 << 9,   // Element can close their shape
        TAGPROPERTY_GEOPOSITION =         1 << 10,  // Element's position can be defined using a GEO position
        TAGPROPERTY_GEOSHAPE =            1 << 11,  // Element's shape acn be defined using a GEO Shape
        TAGPROPERTY_DIALOG =              1 << 12,  // Element can be edited using a dialog (GNECalibratorDialog, GNERerouterDialog...)
        TAGPROPERTY_PARENT =              1 << 13,  // Element will be writed in XML as child of another element (E3Entry -> E3Detector...)
        TAGPROPERTY_MINIMUMCHILDS =       1 << 14,  // Element will be only writed in XML if has a minimum number of childs
        TAGPROPERTY_REPARENT =            1 << 15,  // Element can be reparent
        TAGPROPERTY_SYNONYM =             1 << 16,  // Element will be written with a different name in der XML
        TAGPROPERTY_AUTOMATICSORTING =    1 << 17,  // Element sort automatic their Childs (used by Additionals)
        TAGPROPERTY_SELECTABLE =          1 << 18,  // Element is selectable
        TAGPROPERTY_WRITECHILDSSEPARATE = 1 << 19,  // Element writes their childs in a separated filename
    };

    class TagValues {
    public:
        TagValues();

        TagValues(int tagProperty, int positionListed, GUIIcon icon, SumoXMLTag tagParent = SUMO_TAG_NOTHING, SumoXMLTag tagSynonym = SUMO_TAG_NOTHING);

        void addAttribute(SumoXMLAttr attr, int attributeProperty, const std::string& definition, const std::string& defaultValue, std::vector<std::string> discreteValues = std::vector<std::string>(), SumoXMLAttr synonym = SUMO_ATTR_NOTHING);

        void addAttribute(SumoXMLAttr attr, int attributeProperty, const std::string& definition, const std::string& defaultValue, SumoXMLAttr synonym);

        void addDeprecatedAttribute(SumoXMLAttr attr);

        const AttributeValues& getAttribute(SumoXMLAttr attr) const;

        std::map<SumoXMLAttr, AttributeValues>::const_iterator begin() const;

        std::map<SumoXMLAttr, AttributeValues>::const_iterator end() const;

        int getNumberOfAttributes() const;

        const std::string& getDefaultValue(SumoXMLAttr attr) const;

        GUIIcon getGUIIcon() const;

        int getPositionListed() const;

        SumoXMLTag getParentTag() const;

        SumoXMLTag getTagSynonym() const;

        bool hasAttribute(SumoXMLAttr attr) const;

        bool isNetElement() const;

        bool isAdditional() const;

        bool isShape() const;

        bool isStoppingPlace() const;

        bool isDetector() const;

        bool isDrawable() const;

        bool isSelectable() const;

        bool canBlockMovement() const;

        bool canBlockShape() const;

        bool canCloseShape() const;

        bool hasGEOPosition() const;

        bool hasGEOShape() const;

        bool hasParent() const;

        bool hasTagSynonym() const;

        bool hasDialog() const;

        bool hasMinimumNumberOfChilds() const;

        bool canBeReparent() const;

        bool canAutomaticSortChilds() const;

        bool canWriteChildsSeparate() const;

        bool isAttributeDeprecated(SumoXMLAttr attr) const;

    private:
        int myTagProperty;

        std::map<SumoXMLAttr, AttributeValues> myAttributeValues;

        GUIIcon myIcon;

        int myPositionListed;

        SumoXMLTag myParentTag;

        SumoXMLTag myTagSynonym;

        std::vector<SumoXMLAttr> myDeprecatedAttributes;
    };

    GNEAttributeCarrier(SumoXMLTag tag);

    virtual ~GNEAttributeCarrier() {};

    virtual void selectAttributeCarrier(bool changeFlag = true) = 0;

    virtual void unselectAttributeCarrier(bool changeFlag = true) = 0;

    virtual bool isAttributeCarrierSelected() const = 0;

    /* @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 getPopUpID() const = 0;

    virtual std::string getHierarchyName() const = 0;

    static const std::string FEATURE_LOADED;

    static const std::string FEATURE_GUESSED;

    static const std::string FEATURE_MODIFIED;

    static const std::string FEATURE_APPROVED;

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

    SumoXMLTag getTag() const;

    FXIcon* getIcon() const;

    const std::string getID() const;

    static const TagValues& getTagProperties(SumoXMLTag tag);

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

    static std::vector<SumoXMLTag> allowedNetElementsTags(bool onlyDrawables);

    static std::vector<SumoXMLTag> allowedAdditionalTags(bool onlyDrawables);

    static std::vector<SumoXMLTag> allowedShapeTags(bool onlyDrawables);

    static int getHigherNumberOfAttributes();


    virtual bool addGenericParameter(const std::string& key, const std::string& value) = 0;

    virtual bool removeGenericParameter(const std::string& key) = 0;

    virtual bool updateGenericParameter(const std::string& oldKey, const std::string& newKey) = 0;

    virtual bool updateGenericParameterValue(const std::string& key, const std::string& newValue) = 0;

    virtual std::string getGenericParametersStr() const = 0;

    virtual std::vector<std::pair<std::string, std::string> > getGenericParameters() const = 0;

    virtual void setGenericParametersStr(const std::string& value) = 0;


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

    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 canParse(GNENet* net, const std::string& value, bool report) {
        try {
            parse<T>(net, value);
        } catch (FormatException& exception) {
            if (report) {
                WRITE_WARNING(exception.what())
            }
            return false;
        }
        return true;
    }

    template<typename T>
    static T parse(GNENet* net, const std::string& value);

    template<typename T>
    static std::string parseIDs(const std::vector<T>& ACs);

    static bool parseStringToANDBool(const std::string& string);

    static const double INVALID_POSITION;

    template <typename T>
    static T parseAttributeFromXML(const SUMOSAXAttributes& attrs, const std::string& objectID, const SumoXMLTag tag, const SumoXMLAttr attribute, bool& abort) {
        bool parsedOk = true;
        // obtain tag properties
        const auto& tagProperties = getTagProperties(tag);
        // first check if attribute is deprecated
        if (tagProperties.isAttributeDeprecated(attribute)) {
            // show warning if deprecateda ttribute is in the SUMOSAXAttributes
            if (attrs.hasAttribute(attribute)) {
                WRITE_WARNING("Attribute " + toString(attribute) + "' of " + toString(tag) + " is deprecated and will not be loaded.");
            }
            return parse<T>("");
        }
        std::string defaultValue, parsedAttribute;
        // obtain attribute properties (Only for improving efficiency)
        const auto& attrProperties = tagProperties.getAttribute(attribute);
        // set additionalOfWarningMessage
        std::string additionalOfWarningMessage;
        if (objectID != "") {
            additionalOfWarningMessage = toString(tag) + " with ID '" + objectID + "'";
        } else {
            additionalOfWarningMessage = toString(tag);
        }
        // set a special default value for numerical and boolean attributes (To avoid errors parsing)
        if (attrProperties.isNumerical() || attrProperties.isBool()) {
            defaultValue = "0";
        }
        // first check that attribute exists in XML
        if (attrs.hasAttribute(attribute)) {
            // First check if attribute can be parsed to string
            parsedAttribute = attrs.get<std::string>(attribute, objectID.c_str(), parsedOk, false);
            // check that sucesfully parsed attribute can be converted to type T
            if (parsedOk && !canParse<T>(parsedAttribute)) {
                parsedOk = false;
                // only set default value if this isn't a SVCPermission
                if (!attrProperties.isVClass()) {
                    parsedAttribute = defaultValue;
                }
            }
            // declare a string for details about error formats
            std::string errorFormat;
            // set extra check for ID Values
            if (attribute == SUMO_ATTR_ID) {
                if (parsedAttribute.empty()) {
                    errorFormat = "ID cannot be empty; ";
                    parsedOk = false;
                } else if (SUMOXMLDefinitions::isValidNetID(parsedAttribute) == false) {
                    errorFormat = "'" + parsedAttribute + "' contains invalid characters; ";
                    parsedOk = false;
                }
            }
            // Set extra checks for int values
            if (attrProperties.isInt()) {
                if (canParse<int>(parsedAttribute)) {
                    // obtain int value
                    int parsedIntAttribute = parse<int>(parsedAttribute);
                    // check if attribute can be negative or zero
                    if (attrProperties.isPositive() && (parsedIntAttribute < 0)) {
                        errorFormat = "Cannot be negative; ";
                        parsedOk = false;
                    } else if (attrProperties.isntZero() && (parsedIntAttribute == 0)) {
                        errorFormat = "Cannot be zero; ";
                        parsedOk = false;
                    }
                } else if (canParse<double>(parsedAttribute)) {
                    errorFormat = "Float cannot be reinterpreted as int; ";
                    parsedOk = false;
                } else {
                    errorFormat = "Cannot be parsed to int; ";
                    parsedOk = false;
                }
            }
            // Set extra checks for float(double) values
            if (attrProperties.isFloat()) {
                if (canParse<double>(parsedAttribute)) {
                    // obtain double value
                    double parsedDoubleAttribute = parse<double>(parsedAttribute);
                    //check if can be negative and Zero
                    if (attrProperties.isPositive() && (parsedDoubleAttribute < 0)) {
                        errorFormat = "Cannot be negative; ";
                        parsedOk = false;
                    } else if (attrProperties.isntZero() && (parsedDoubleAttribute == 0)) {
                        errorFormat = "Cannot be zero; ";
                        parsedOk = false;
                    }
                } else {
                    errorFormat = "Cannot be parsed to float; ";
                    parsedOk = false;
                }
            }
            // set extra check for time(double) values
            if (attrProperties.isTime()) {
                if (canParse<double>(parsedAttribute)) {
                    // parse to SUMO Real and check if is negative
                    if (parse<double>(parsedAttribute) < 0) {
                        errorFormat = "Time cannot be negative; ";
                        parsedOk = false;
                    }
                } else {
                    errorFormat = "Cannot be parsed to time; ";
                    parsedOk = false;
                }
            }
            // set extra check for probability values
            if (attrProperties.isProbability()) {
                if (canParse<double>(parsedAttribute)) {
                    // parse to SUMO Real and check if is negative
                    if (parse<double>(parsedAttribute) < 0) {
                        errorFormat = "Probability cannot be smaller than 0; ";
                        parsedOk = false;
                    } else if (parse<double>(parsedAttribute) > 1) {
                        errorFormat = "Probability cannot be greather than 1; ";
                        parsedOk = false;
                    }
                } else {
                    errorFormat = "Cannot be parsed to probability; ";
                    parsedOk = false;
                }
            }
            // set extra check for discrete values
            if (attrProperties.isDiscrete()) {
                // search value in the list of discretes values of attribute properties
                auto finder = std::find(attrProperties.getDiscreteValues().begin(), attrProperties.getDiscreteValues().end(), parsedAttribute);
                // check if attribute is valid
                if (finder == attrProperties.getDiscreteValues().end()) {
                    errorFormat = "value is not within the set of allowed values for attribute '" + toString(attribute) + "'";
                    parsedOk = false;
                }
            }
            // set extra check for color values
            if (attrProperties.isColor() && !canParse<RGBColor>(parsedAttribute)) {
                errorFormat = "Invalid RGB format or named color; ";
                parsedOk = false;
            }
            // set extra check for filename values
            if (attrProperties.isFilename()) {
                if (SUMOXMLDefinitions::isValidFilename(parsedAttribute) == false) {
                    errorFormat = "Filename contains invalid characters; ";
                    parsedOk = false;
                } else if (parsedAttribute.empty()) {
                    errorFormat = "Filename cannot be empty; ";
                    parsedOk = false;
                }
            }
            // set extra check for name values
            if ((attribute == SUMO_ATTR_NAME) && !SUMOXMLDefinitions::isValidAttribute(parsedAttribute)) {
                errorFormat = "name contains invalid characters; ";
                parsedOk = false;
            }
            // set extra check for SVCPermissions values
            if (attrProperties.isVClass()) {
                if (!canParseVehicleClasses(parsedAttribute)) {
                    errorFormat = "List of VClasses isn't valid; ";
                    parsedAttribute = defaultValue;
                    parsedOk = false;
                }
            }
            // set extra check for Vehicle Classes
            if ((!parsedOk) && (attribute == SUMO_ATTR_VCLASS)) {
                errorFormat = "Is not a part of defined set of Vehicle Classes; ";
            }
            // set extra check for Vehicle Classes
            if ((!parsedOk) && (attribute == SUMO_ATTR_GUISHAPE)) {
                errorFormat = "Is not a part of defined set of Gui Vehicle Shapes; ";
            }
            // set extra check for RouteProbes
            if ((attribute == SUMO_ATTR_ROUTEPROBE) && !SUMOXMLDefinitions::isValidNetID(parsedAttribute)) {
                errorFormat = "RouteProbe ID contains invalid characters; ";
                parsedOk = false;
            }
            // set extra check for list of edges
            if ((attribute == SUMO_ATTR_EDGES) && parsedAttribute.empty()) {
                errorFormat = "List of edges cannot be empty; ";
                parsedOk = false;
            }
            // set extra check for list of lanes
            if ((attribute == SUMO_ATTR_LANES) && parsedAttribute.empty()) {
                errorFormat = "List of lanes cannot be empty; ";
                parsedOk = false;
            }
            // If attribute has an invalid format
            if (!parsedOk) {
                // if attribute is optional and has a default value, obtain it as string. In other case, abort.
                if (attrProperties.isOptional() && attrProperties.hasDefaultValue()) {
                    parsedAttribute = attrProperties.getDefaultValue();
                } else {
                    WRITE_WARNING("Format of essential " + attrProperties.getDescription() + " attribute '" + toString(attribute) + "' of " +
                                  additionalOfWarningMessage +  " is invalid; " + errorFormat + toString(tag) + " cannot be created");
                    // abort parsing (and creation) of element
                    abort = true;
                    // set default value (To avoid errors in parse<T>(parsedAttribute))
                    parsedAttribute = defaultValue;
                }
            }
        } else {
            // if attribute is optional and has a default value, obtain it. In other case, abort.
            if (attrProperties.isOptional() && attrProperties.hasDefaultValue()) {
                parsedAttribute = attrProperties.getDefaultValue();
            } else {
                WRITE_WARNING("Essential " + attrProperties.getDescription() + " attribute '" + toString(attribute) + "' of " +
                              additionalOfWarningMessage +  " is missing; " + toString(tag) + " cannot be created");
                // abort parsing (and creation) of element
                abort = true;
                // set default value (To avoid errors in parse<T>(parsedAttribute))
                parsedAttribute = defaultValue;
            }
        }
        // return parsed attribute
        return parse<T>(parsedAttribute);
    }

    static int getCircleResolution(const GUIVisualizationSettings& settings);

protected:
    bool mySelected;

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

    virtual void mouseOverObject(const GUIVisualizationSettings& s) const = 0;

    static void fillAttributeCarriers();

    const SumoXMLTag myTag;

    static std::map<SumoXMLTag, TagValues> myAllowedTags;

    GNEAttributeCarrier(const GNEAttributeCarrier&) = delete;

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

#endif

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