GNEAttributeProperties.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
/****************************************************************************/
// Abstract Base class for attribute properties used in GNEAttributeCarrier
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/geom/Position.h>
#include <utils/xml/SUMOSAXAttributes.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
 
class GNETagProperties;
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNEAttributeProperties {
 
public:
 
    enum class Property : int {
        INT =               1 << 0,     // Attribute is an integer (Including Zero)
        FLOAT =             1 << 1,     // Attribute is a float
        SUMOTIME =          1 << 2,     // Attribute is a SUMOTime
        BOOL =              1 << 3,     // Attribute is boolean (0/1, true/false)
        STRING =            1 << 4,     // Attribute is a string
        POSITION =          1 << 5,     // Attribute is a position defined by doubles (x,y or x,y,z)
        COLOR =             1 << 6,     // Attribute is a color defined by a specifically word (Red, green) or by a special format (XXX,YYY,ZZZ)
        VTYPE =             1 << 7,     // Attribute corresponds to a Vtype or VTypeDistribution
        VCLASS =            1 << 8,     // Attribute is a VClass (passenger, bus, motorcicle...)
        POSITIVE =          1 << 9,     // Attribute is positive (Including Zero)
        UNIQUE =            1 << 10,    // Attribute is unique (cannot be edited in a selection of similar elements (ID, Position...)
        FILEOPEN =          1 << 11,    // Attribute is a filename that opens an existent file
        FILESAVE =          1 << 12,    // Attribute is a filename that can create a new file
        DISCRETE =          1 << 13,    // Attribute is discrete (only certain values are allowed)
        PROBABILITY =       1 << 14,    // Attribute is probability (only allowed values between 0 and 1, including both)
        ANGLE =             1 << 15,    // Attribute is an angle (only takes values between 0 and 360, including both, another value will be automatically reduced
        LIST =              1 << 16,    // Attribute is a list of other elements separated by spaces
        SECUENCIAL =        1 << 17,    // Attribute is a special sequence of elements (for example: secuencial lanes in Multi Lane E2 detectors)
        DEFAULTVALUE =      1 << 18,    // Attribute owns a static default value
        SYNONYM =           1 << 19,    // Attribute will be written with a different name in der XML
        RANGE =             1 << 20,    // Attribute only accept a range of elements (example: Probability [0,1])
        UPDATEGEOMETRY =    1 << 21,    // Attribute require update geometry at the end of function setAttribute(...)
        ACTIVATABLE =       1 << 22,    // Attribute can be switch on/off using a checkbox in frame
        FLOW =              1 << 23,    // Attribute is part of a flow definition (Number, vehsPerHour...)
        COPYABLE =          1 << 24,    // Attribute can be copied over other element with the same tagProperty (used for edge/lane templates)
        ALWAYSENABLED =     1 << 25,    // Attribute cannot be disabled
        NO_PROPERTY =       1 << 26,    // No property defined
    };
 
    enum class Edit : int {
        CREATEMODE =        1 << 0,    // Attribute can be modified in create mode
        EDITMODE =          1 << 1,    // Attribute can be modified in edit mode
        NETEDITEDITOR =     1 << 2,    // Attribute can be edited only in netedit editor
        EXTENDEDEDITOR =    1 << 3,    // Attribute cannot be edited in editor, but is editable in extended Dialog
        GEOEDITOR =         1 << 4,    // Attribute can be edited only in geo editor
        FLOWEDITOR =        1 << 5,    // Attribute can be edited only in flow editor
        NO_EDIT =           1 << 6,    // No edit property defined
    };
 
    GNEAttributeProperties(GNETagProperties* tagProperties, const SumoXMLAttr attribute, const Property attributeProperty,
                           const Edit editProperty, const std::string& definition);
 
    GNEAttributeProperties(GNETagProperties* tagProperties, const SumoXMLAttr attribute, const Property attributeProperty,
                           const Edit editProperty, const std::string& definition, const std::string& defaultValue);
 
    GNEAttributeProperties(GNETagProperties* tagProperties, const SumoXMLAttr attribute, const Property attributeProperty,
                           const Edit editProperty, const std::string& definition, const std::string& defaultValueMask,
                           const std::string& defaultValue);
 
    GNEAttributeProperties(GNETagProperties* tagProperties, const SumoXMLAttr attribute, const std::string& definition);
 
    ~GNEAttributeProperties();
 
    void checkAttributeIntegrity() const;
 
    void setDiscreteValues(const std::vector<std::string>& discreteValues);
 
    void setFilenameExtensions(const std::string& extensions);
 
    void setDefaultActivated(const bool value);
 
    void setSynonym(const SumoXMLAttr synonym);
 
    void setRange(const double minimum, const double maximum);
 
    void setTagPropertyParent(GNETagProperties* tagPropertyParent);
 
    void setAlternativeName(const std::string& alternativeName);
 
    SumoXMLAttr getAttr() const;
 
    const std::string& getAttrStr() const;
 
    const GNETagProperties* getTagPropertyParent() const;
 
    int getPositionListed() const;
 
    const std::string& getDefinition() const;
 
    const std::string& getDefaultStringValue() const;
 
    int getDefaultIntValue() const;
 
    double getDefaultDoubleValue() const;
 
    SUMOTime getDefaultTimeValue() const;
 
    bool getDefaultBoolValue() const;
 
    const RGBColor& getDefaultColorValue() const;
 
    const Position& getDefaultPositionValue() const;
 
    bool getDefaultActivated() const;
 
    std::string getCategory() const;
 
    std::string getDescription() const;
 
    const std::vector<std::string>& getDiscreteValues() const;
 
    const std::string& getFilenameExtensions() const;
 
    SumoXMLAttr getAttrSynonym() const;
 
    double getMinimumRange() const;
 
    double getMaximumRange() const;
 
    bool hasDefaultValue() const;
 
    bool hasAttrSynonym() const;
 
    bool hasAttrRange() const;
 
    bool isInt() const;
 
    bool isFloat() const;
 
    bool isSUMOTime() const;
 
    bool isBool() const;
 
    bool isString() const;
 
    bool isPosition() const;
 
    bool isProbability() const;
 
    bool isAngle() const;
 
    bool isNumerical() const;
 
    bool isPositive() const;
 
    bool isColor() const;
 
    bool isVType() const;
 
    bool isFileOpen() const;
 
    bool isFileSave() const;
 
    bool isVClass() const;
 
    bool isSVCPermission() const;
 
    bool isList() const;
 
    bool isSecuential() const;
 
    bool isUnique() const;
 
    bool isDiscrete() const;
 
    bool requireUpdateGeometry() const;
 
    bool isActivatable() const;
 
    bool isFlow() const;
 
    bool isCopyable() const;
 
    bool isAlwaysEnabled() const;
 
 
    bool isBasicEditor() const;
 
    bool isExtendedEditor() const;
 
    bool isGeoEditor() const;
 
    bool isFlowEditor() const;
 
    bool isNeteditEditor() const;
 
    bool isCreateMode() const;
 
    bool isEditMode() const;
 
 
private:
    const GNETagProperties* myTagPropertyParent;
 
    SumoXMLAttr myAttribute = SUMO_ATTR_NOTHING;
 
    std::string myAttrStr;
 
    Property myAttributeProperty = Property::NO_PROPERTY;
 
    Edit myEditProperty = Edit::NO_EDIT;
 
    std::string myDefinition;
 
    std::string myDefaultStringValue;
 
    int myDefaultIntValue = 0;
 
    double myDefaultDoubleValue = 0;
 
    SUMOTime myDefaultTimeValue = 0;
 
    bool myDefaultBoolValue = false;
 
    RGBColor myDefaultColorValue = RGBColor::INVISIBLE;
 
    Position myDefaultPositionValue = Position::INVALID;
 
    bool myDefaultActivated = false;
 
    std::vector<std::string> myDiscreteValues;
 
    std::string myFilenameExtensions;
 
    SumoXMLAttr myAttrSynonym = SUMO_ATTR_NOTHING;
 
    double myMinimumRange = 0;
 
    double myMaximumRange = 0;
 
    void checkBuildConstraints() const;
 
    void parseDefaultValues(const std::string& defaultValue, const bool overWritteDefaultString);
 
    GNEAttributeProperties() = delete;
 
    GNEAttributeProperties(const GNEAttributeProperties&) = delete;
 
    GNEAttributeProperties& operator=(const GNEAttributeProperties& src) = delete;
};
 
constexpr GNEAttributeProperties::Property operator|(GNEAttributeProperties::Property a, GNEAttributeProperties::Property b) {
    return static_cast<GNEAttributeProperties::Property>(static_cast<int>(a) | static_cast<int>(b));
}
 
constexpr bool operator&(GNEAttributeProperties::Property a, GNEAttributeProperties::Property b) {
    return (static_cast<int>(a) & static_cast<int>(b)) != 0;
}
 
constexpr GNEAttributeProperties::Edit operator|(GNEAttributeProperties::Edit a, GNEAttributeProperties::Edit b) {
    return static_cast<GNEAttributeProperties::Edit>(static_cast<int>(a) | static_cast<int>(b));
}
 
constexpr bool operator&(GNEAttributeProperties::Edit a, GNEAttributeProperties::Edit b) {
    return (static_cast<int>(a) & static_cast<int>(b)) != 0;
}
 
/****************************************************************************/