GNEChange.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
/****************************************************************************/
// The reification of a netedit editing operation (see command pattern)
// inherits from FXCommand and is used to for undo/redo
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <netbuild/NBEdge.h>
#include <netbuild/NBNode.h>
#include <netedit/GNEViewNet.h>
#include <netedit/elements/GNEHierarchicalStructureParents.h>
#include <netedit/elements/additional/GNETAZSourceSink.h>
#include <netedit/elements/data/GNEGenericData.h>
#include <netedit/elements/demand/GNEDemandElement.h>
#include <netedit/elements/network/GNEEdge.h>
#include <netedit/elements/network/GNEJunction.h>
#include <netedit/elements/network/GNELane.h>
#include <utils/foxtools/fxheader.h>
#include <utils/geom/PositionVector.h>
#include <utils/xml/SUMOXMLDefinitions.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
class GNEHierarchicalElement;
class GNEAttributeCarrier;
class GNEDataSet;
class GNEDataInterval;
class GNEMeanData;
class GNENet;
class GNEViewNet;
 
// ===========================================================================
// class definitions
// ===========================================================================
class GNEChange : public FXObject {
    FXDECLARE_ABSTRACT(GNEChange)
 
public:
    friend class GNEChangeGroup;
    friend class GNEUndoList;
 
    GNEChange(Supermode supermode, bool forward, const bool selectedElement);
 
    GNEChange(Supermode supermode, GNEHierarchicalElement* element, bool forward, const bool selectedElement);
 
    ~GNEChange();
 
    virtual void undo() = 0;
 
    virtual void redo() = 0;
 
    virtual std::string undoName() const = 0;
 
    virtual std::string redoName() const = 0;
 
    virtual int size() const;
 
    Supermode getSupermode() const;
 
    bool canMerge() const;
 
    bool mergeWith(GNEChange* command);
 
protected:
    GNEChange();
 
    template<typename T>
    void addElementInParentsAndChildren(T* element) {
        // add element in children
        for (const auto& junction : myParents.get<GNEJunction*>()) {
            GNEHierarchicalElement::insertChild(junction, element);
        }
        for (const auto& edge : myParents.get<GNEEdge*>()) {
            GNEHierarchicalElement::insertChild(edge, element);
        }
        for (const auto& lane : myParents.get<GNELane*>()) {
            GNEHierarchicalElement::insertChild(lane, element);
        }
        for (const auto& additional : myParents.get<GNEAdditional*>()) {
            GNEHierarchicalElement::insertChild(additional, element);
        }
        for (const auto& sourceSink : myParents.get<GNETAZSourceSink*>()) {
            GNEHierarchicalElement::insertChild(sourceSink, element);
        }
        for (const auto& demandElement : myParents.get<GNEDemandElement*>()) {
            GNEHierarchicalElement::insertChild(demandElement, element);
        }
        for (const auto& genericData : myParents.get<GNEGenericData*>()) {
            GNEHierarchicalElement::insertChild(genericData, element);
        }
    }
 
    template<typename T>
    void removeElementFromParentsAndChildren(T* element) {
        // Remove element from parents
        for (const auto& junction : myParents.get<GNEJunction*>()) {
            GNEHierarchicalElement::removeChild(junction, element);
        }
        for (const auto& edge : myParents.get<GNEEdge*>()) {
            GNEHierarchicalElement::removeChild(edge, element);
        }
        for (const auto& lane : myParents.get<GNELane*>()) {
            GNEHierarchicalElement::removeChild(lane, element);
        }
        for (const auto& additional : myParents.get<GNEAdditional*>()) {
            GNEHierarchicalElement::removeChild(additional, element);
        }
        for (const auto& sourceSink : myParents.get<GNETAZSourceSink*>()) {
            GNEHierarchicalElement::removeChild(sourceSink, element);
        }
        for (const auto& demandElement : myParents.get<GNEDemandElement*>()) {
            GNEHierarchicalElement::removeChild(demandElement, element);
        }
        for (const auto& genericData : myParents.get<GNEGenericData*>()) {
            GNEHierarchicalElement::removeChild(genericData, element);
        }
    }
 
    const Supermode mySupermode;
 
    const GNEHierarchicalStructureParents myParents;
 
    bool myForward;
 
    const bool mySelectedElement;
 
private:
    // @brief next GNEChange (can be access by GNEChangeGroup and GNEUndoList)
    GNEChange* next;
 
    GNEChange(const GNEChange&) = delete;
 
    GNEChange& operator=(const GNEChange&) = delete;
};