GNEAttributeCarrier.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-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
/****************************************************************************/
// Abstract Base class for gui objects which carry attributes
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/foxtools/fxheader.h>
#include <netedit/GNEReferenceCounter.h>
 
#include "GNETagProperties.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class GNENet;
class GNEUndoList;
class GUIGlObject;
class GNEHierarchicalElement;
class GNELane;
class GNEEdge;
 
// ===========================================================================
// class definitions
// ===========================================================================
class GNEAttributeCarrier : public GNEReferenceCounter {
 
    friend class GNEChange_Attribute;
    friend class GNEChange_ToggleAttribute;
    friend class GNEFrameAttributeModules;
    friend class GNEAttributesCreatorRow;
    friend class GNEFlowEditor;
 
public:
 
    GNEAttributeCarrier(const SumoXMLTag tag, GNENet* net);
 
    virtual ~GNEAttributeCarrier();
 
    const std::string getID() const;
 
    GNENet* getNet() const;
 
    void selectAttributeCarrier();
 
    void unselectAttributeCarrier();
 
    bool isAttributeCarrierSelected() const;
 
    bool drawUsingSelectColor() const;
 
 
    void markForDrawingFront();
 
    void unmarkForDrawingFront();
 
    bool isMarkedForDrawingFront() const;
 
    void drawInLayer(const double typeOrLayer, const double extraOffset = 0) const;
 
 
    virtual GNEHierarchicalElement* getHierarchicalElement() = 0;
 
    void setInGrid(bool value);
 
    bool inGrid() const;
 
 
    virtual GUIGlObject* getGUIGlObject() = 0;
 
    virtual const GUIGlObject* getGUIGlObject() const = 0;
 
    virtual void updateGeometry() = 0;
 
 
 
    bool checkDrawInspectContour() const;
 
    bool checkDrawFrontContour() const;
 
    virtual bool checkDrawFromContour() const = 0;
 
    virtual bool checkDrawToContour() const = 0;
 
    virtual bool checkDrawRelatedContour() const = 0;
 
    virtual bool checkDrawOverContour() const = 0;
 
    virtual bool checkDrawDeleteContour() const = 0;
 
    virtual bool checkDrawSelectContour() const = 0;
 
    virtual bool checkDrawMoveContour() const = 0;
 
 
    void resetDefaultValues();
 
    /* @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
     */
    virtual void setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) = 0;
 
    /* @brief method for check if new value for certain attribute is valid
     * @param[in] key The attribute key
     * @param[in] value The new value
     */
    virtual bool isValid(SumoXMLAttr key, const std::string& value) = 0;
 
    /* @brief method for enable attribute
     * @param[in] key The attribute key
     * @param[in] undoList The undoList on which to register changes
     * @note certain attributes can be only enabled, and can produce the disabling of other attributes
     */
    virtual void enableAttribute(SumoXMLAttr key, GNEUndoList* undoList);
 
    /* @brief method for disable attribute
     * @param[in] key The attribute key
     * @param[in] undoList The undoList on which to register changes
     * @note certain attributes can be only enabled, and can produce the disabling of other attributes
     */
    virtual void disableAttribute(SumoXMLAttr key, GNEUndoList* undoList);
 
    /* @brief method for check if the value for certain attribute is set
     * @param[in] key The attribute key
     */
    virtual bool isAttributeEnabled(SumoXMLAttr key) const;
 
    /* @brief method for check if the value for certain attribute is computed (for example, due a network recomputing)
     * @param[in] key The attribute key
     */
    virtual bool isAttributeComputed(SumoXMLAttr key) const;
 
    /* @brief method for check if the value for certain attribute is set
     * @param[in] key The attribute key
     */
    bool hasAttribute(SumoXMLAttr key) const {
        return myTagProperty.hasAttribute(key);
    }
 
    virtual std::string getPopUpID() const = 0;
 
    virtual std::string getHierarchyName() const = 0;
 
 
    virtual const Parameterised::Map& getACParametersMap() const = 0;
 
    template<typename T>
    T getACParameters() const;
 
    void setACParameters(const std::string& parameters, GNEUndoList* undoList);
 
    void setACParameters(const std::vector<std::pair<std::string, std::string> >& parameters, GNEUndoList* undoList);
 
    void setACParameters(const Parameterised::Map& parameters, GNEUndoList* undoList);
 
    void addACParameters(const std::string& key, const std::string& attribute, GNEUndoList* undoList);
 
    void removeACParametersKeys(const std::vector<std::string>& keepKeys, GNEUndoList* undoList);
 
 
    /* @brief method for return an alternative value for disabled attributes. Used only in GNEFrames
     * @param[in] key The attribute key
     */
    std::string getAlternativeValueForDisabledAttributes(SumoXMLAttr key) const;
 
    virtual std::string getAttributeForSelection(SumoXMLAttr key) const;
 
    const std::string& getTagStr() const;
 
    FXIcon* getACIcon() const;
 
    bool isTemplate() const;
 
    const GNETagProperties& getTagProperty() const;
 
    static const GNETagProperties& getTagProperty(SumoXMLTag tag);
 
    static const std::vector<GNETagProperties> getTagPropertiesByType(const int tagPropertyCategory, const bool mergeCommonPlans);
 
    static const std::vector<GNETagProperties> getTagPropertiesByMergingTag(SumoXMLTag mergingTag);
 
    template<typename T>
    static bool canParse(const std::string& string) {
        try {
            GNEAttributeCarrier::parse<T>(string);
        } catch (EmptyData&) {
            // general
            return false;
        } catch (FormatException&) {
            // numbers, time, boolean, colors
            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 lanesConsecutives(const std::vector<GNELane*>& lanes);
 
    static void writeAttributeHelp();
 
 
    static const std::string FEATURE_LOADED;
 
    static const std::string FEATURE_GUESSED;
 
    static const std::string FEATURE_MODIFIED;
 
    static const std::string FEATURE_APPROVED;
 
 
    static int maxNumberOfEditableAttributes;
 
    static int maxNumberOfGeoAttributes;
 
    static int maxNumberOfFlowAttributes;
 
    static int maxNumberOfNeteditAttributes;
 
    static const Parameterised::Map PARAMETERS_EMPTY;
 
    static const std::string True;
 
    static const std::string False;
 
protected:
    const GNETagProperties& myTagProperty;
 
    GNENet* myNet = nullptr;
 
    bool mySelected = false;
 
    bool myDrawInFront = false;
 
    bool myInGrid = false;
 
    bool myIsTemplate = false;
 
    virtual void toggleAttribute(SumoXMLAttr key, const bool value);
 
    /* @brief method for getting the common attribute of an XML key
     * @param[in] key The attribute key
     * @return string with the value associated to key
     */
    std::string getCommonAttribute(SumoXMLAttr key) const;
 
    /* @brief method for setting the common 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
     */
    void setCommonAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList);
 
    /* @brief method for check if new value for certain common attribute is valid
     * @param[in] key The attribute key
     * @param[in] value The new value
     */
    bool isCommonValid(SumoXMLAttr key, const std::string& value);
 
    void setCommonAttribute(SumoXMLAttr key, const std::string& value);
 
 
private:
    virtual void setAttribute(SumoXMLAttr key, const std::string& value) = 0;
 
    void resetAttributes();
 
    static void fillAttributeCarriers();
 
    static void fillNetworkElements();
 
    static void fillAdditionalElements();
 
    static void fillShapeElements();
 
    static void fillTAZElements();
 
    static void fillWireElements();
 
    static void fillJuPedSimElements();
 
    static void fillDemandElements();
 
    static void fillVehicleElements();
 
    static void fillStopElements();
 
    static void fillWaypointElements();
 
    static void fillPersonElements();
 
    static void fillPersonPlanTrips();
 
    static void fillPersonPlanWalks();
 
    static void fillPersonPlanRides();
 
    static void fillPersonStopElements();
 
    static void fillContainerElements();
 
    static void fillContainerTransportElements();
 
    static void fillContainerTranshipElements();
 
    static void fillContainerStopElements();
 
    static void fillCommonAttributes(GNETagProperties& tagProperties);
 
    static void fillPOIAttributes(GNETagProperties& tagProperties);
 
    static void fillCommonVehicleAttributes(GNETagProperties& tagProperties);
 
    static void fillCommonFlowAttributes(GNETagProperties& tagProperties, SumoXMLAttr perHour);
 
    static void fillCarFollowingModelAttributes(GNETagProperties& tagProperties);
 
    static void fillJunctionModelAttributes(GNETagProperties& tagProperties);
 
    static void fillLaneChangingModelAttributes(GNETagProperties& tagProperties);
 
    static void fillCommonPersonAttributes(GNETagProperties& tagProperties);
 
    static void fillCommonContainerAttributes(GNETagProperties& tagProperties);
 
    static void fillCommonStopAttributes(GNETagProperties& tagProperties, const bool waypoint);
 
    static void fillPlanParentAttributes(GNETagProperties& tagProperties);
 
    static void fillPersonTripCommonAttributes(GNETagProperties& tagProperties);
 
    static void fillWalkCommonAttributes(GNETagProperties& tagProperties);
 
    static void fillRideCommonAttributes(GNETagProperties& tagProperties);
 
    static void fillTransportCommonAttributes(GNETagProperties& tagProperties);
 
    static void fillTranshipCommonAttributes(GNETagProperties& tagProperties);
 
    static void fillPlanStopCommonAttributes(GNETagProperties& tagProperties);
 
    static void fillDataElements();
 
    static void fillCommonMeanDataAttributes(GNETagProperties& tagProperties);
 
    static void updateMaxNumberOfAttributes();
 
    static std::map<SumoXMLTag, GNETagProperties> myTagProperties;
 
    static std::map<SumoXMLTag, GNETagProperties> myMergedPlanTagProperties;
 
    GNEAttributeCarrier(const GNEAttributeCarrier&) = delete;
 
    GNEAttributeCarrier& operator=(const GNEAttributeCarrier& src) = delete;
};