Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
       4             : // This program and the accompanying materials are made available under the
       5             : // terms of the Eclipse Public License 2.0 which is available at
       6             : // https://www.eclipse.org/legal/epl-2.0/
       7             : // This Source Code may also be made available under the following Secondary
       8             : // Licenses when the conditions for such availability set forth in the Eclipse
       9             : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10             : // or later which is available at
      11             : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12             : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13             : /****************************************************************************/
      14             : /// @file    GUIGlObjectStorage.cpp
      15             : /// @author  Daniel Krajzewicz
      16             : /// @author  Jakob Erdmann
      17             : /// @author  Michael Behrisch
      18             : /// @date    Sept 2002
      19             : ///
      20             : // A storage for displayed objects via their numerical id
      21             : /****************************************************************************/
      22             : #include <config.h>
      23             : 
      24             : #include <cassert>
      25             : #include <utils/foxtools/fxheader.h>
      26             : #include "GUIGlObject.h"
      27             : #include "GUIGlObjectStorage.h"
      28             : 
      29             : 
      30             : // ===========================================================================
      31             : // static variables (instances in this case)
      32             : // ===========================================================================
      33             : GUIGlObjectStorage GUIGlObjectStorage::gIDStorage;
      34             : 
      35             : 
      36             : // ===========================================================================
      37             : // method definitions
      38             : // ===========================================================================
      39        7792 : GUIGlObjectStorage::GUIGlObjectStorage() :
      40        7792 :     myNextID(1),
      41        7792 :     myLock(true) {
      42        7792 :     myObjects.push_back(nullptr);
      43        7792 : }
      44             : 
      45             : 
      46        7792 : GUIGlObjectStorage::~GUIGlObjectStorage() {}
      47             : 
      48             : 
      49             : GUIGlID
      50     1447564 : GUIGlObjectStorage::registerObject(GUIGlObject* object) {
      51     1447564 :     FXMutexLock locker(myLock);
      52     1447564 :     const GUIGlID id = myNextID;
      53     1447564 :     if (id == myObjects.size()) {
      54     1000507 :         myObjects.push_back(object);
      55             :     } else {
      56      447057 :         myObjects[id] = object;
      57             :     }
      58    34183190 :     while (myNextID < myObjects.size() && myObjects[myNextID] != nullptr) {
      59    32735626 :         myNextID++;
      60             :     }
      61     1447564 :     return id;
      62             : }
      63             : 
      64             : 
      65             : void
      66     1447564 : GUIGlObjectStorage::changeName(GUIGlObject* object, const std::string& fullName) {
      67     1447564 :     FXMutexLock locker(myLock);
      68             :     myFullNameMap.erase(object->getFullName());
      69     1447564 :     myFullNameMap[fullName] = object;
      70     1447564 : }
      71             : 
      72             : 
      73             : GUIGlObject*
      74         638 : GUIGlObjectStorage::getObjectBlocking(GUIGlID id) const {
      75         638 :     FXMutexLock locker(myLock);
      76         638 :     if (id < myObjects.size() && myObjects[id] != nullptr) {
      77             :         GUIGlObject* const o = myObjects[id];
      78             :         o->setBlocked();
      79         638 :         return o;
      80             :     }
      81             :     return nullptr;
      82             : }
      83             : 
      84             : 
      85             : GUIGlObject*
      86       46515 : GUIGlObjectStorage::getObjectBlocking(const std::string& fullName) const {
      87       46515 :     FXMutexLock locker(myLock);
      88             :     auto findIt = myFullNameMap.find(fullName);
      89       46515 :     if (findIt != myFullNameMap.end()) {
      90       20621 :         GUIGlObject* const o = findIt->second;
      91             :         o->setBlocked();
      92       20621 :         return o;
      93             :     }
      94             :     return nullptr;
      95             : }
      96             : 
      97             : 
      98             : bool
      99     1445987 : GUIGlObjectStorage::remove(GUIGlID id) {
     100     1445987 :     FXMutexLock locker(myLock);
     101             :     assert(id < myObjects.size() && myObjects[id] != nullptr);
     102     1445987 :     myFullNameMap.erase(myObjects[id]->getFullName());
     103     1445987 :     const bool wasBlocked = myObjects[id]->isBlocked();
     104     1445987 :     myObjects[id] = nullptr;
     105     1445987 :     if (id < myNextID) {
     106      295253 :         myNextID = id;
     107             :     }
     108     1445987 :     return !wasBlocked;
     109             : }
     110             : 
     111             : 
     112             : void
     113       35765 : GUIGlObjectStorage::clear() {
     114       35765 :     FXMutexLock locker(myLock);
     115       35765 :     myObjects.clear();
     116       35765 :     myObjects.push_back(nullptr);
     117             :     myFullNameMap.clear();
     118       35765 :     myNextID = 1;
     119       35765 : }
     120             : 
     121             : 
     122             : void
     123       21238 : GUIGlObjectStorage::unblockObject(GUIGlID id) {
     124       21238 :     FXMutexLock locker(myLock);
     125       21238 :     if (id < myObjects.size() && myObjects[id] != nullptr) {
     126             :         myObjects[id]->setBlocked(false);
     127             :     }
     128       21238 : }
     129             : 
     130             : 
     131             : const std::vector<GUIGlObject*>&
     132           0 : GUIGlObjectStorage::getAllGLObjects() const {
     133           0 :     return myObjects;
     134             : }
     135             : 
     136             : /****************************************************************************/