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    MSEventControl.cpp
      15              : /// @author  Christian Roessel
      16              : /// @author  Daniel Krajzewicz
      17              : /// @author  Jakob Erdmann
      18              : /// @author  Michael Behrisch
      19              : /// @author  Matthias Heppner
      20              : /// @date    Mon, 12 Mar 2001
      21              : ///
      22              : // Stores time-dependant events and executes them at the proper time
      23              : /****************************************************************************/
      24              : #include <config.h>
      25              : 
      26              : #include <cassert>
      27              : #include "MSEventControl.h"
      28              : #include <utils/common/MsgHandler.h>
      29              : #include <utils/common/Command.h>
      30              : #include "MSNet.h"
      31              : 
      32              : 
      33              : // ===========================================================================
      34              : // member definitions
      35              : // ===========================================================================
      36       128986 : MSEventControl::MSEventControl() :
      37       128986 :     myEvents() {}
      38              : 
      39              : 
      40       217609 : MSEventControl::~MSEventControl() {
      41              :     // delete the events
      42       292858 :     for (const Event& e : myEvents) {
      43       172785 :         delete e.first;
      44              :     }
      45       217609 : }
      46              : 
      47              : 
      48              : void
      49     48916644 : MSEventControl::addEvent(Command* operation, SUMOTime execTimeStep) {
      50     48916644 :     myEvents.emplace_back(Event(operation, execTimeStep));
      51     48916644 :     std::push_heap(myEvents.begin(), myEvents.end(), MSEventControl::eventCompare);
      52     48916644 : }
      53              : 
      54              : 
      55              : void
      56    275315556 : MSEventControl::execute(SUMOTime execTime) {
      57              :     // Execute all events that are scheduled for execTime.
      58    324058458 :     while (!myEvents.empty()) {
      59     99548150 :         Event currEvent = myEvents.front();
      60     99548150 :         if (currEvent.second < 0) {
      61              :             currEvent.second = execTime;
      62              :         }
      63     99548150 :         if (currEvent.second < execTime + DELTA_T) {
      64              :             Command* command = currEvent.first;
      65              :             std::pop_heap(myEvents.begin(), myEvents.end(), eventCompare);
      66              :             myEvents.pop_back();
      67              :             SUMOTime time = 0;
      68              :             try {
      69     48743013 :                 time = command->execute(execTime);
      70          111 :             } catch (...) {
      71          111 :                 delete command;
      72          111 :                 throw;
      73          111 :             }
      74              : 
      75              :             // Delete nonrecurring events, reinsert recurring ones
      76              :             // with new execution time = execTime + returned offset.
      77     48742902 :             if (time <= 0) {
      78      1687795 :                 if (time < 0) {
      79            0 :                     WRITE_WARNING("Command returned negative repeat number; will be deleted.");
      80              :                 }
      81      1687795 :                 delete currEvent.first;
      82              :             } else {
      83     47055107 :                 addEvent(currEvent.first, currEvent.second + time);
      84              :             }
      85              :         } else {
      86              :             break;
      87              :         }
      88              :     }
      89    275315445 : }
      90              : 
      91              : 
      92              : bool
      93            0 : MSEventControl::isEmpty() {
      94            0 :     return myEvents.empty();
      95              : }
      96              : 
      97              : bool
      98    242233516 : MSEventControl::eventCompare(const Event& e1, const Event& e2) {
      99    242233516 :     return e1.second == e2.second ? e1.first->priority < e2.first->priority : e1.second > e2.second;
     100              : }
     101              : 
     102              : void
     103          531 : MSEventControl::clearState(SUMOTime currentTime, SUMOTime newTime) {
     104         1651 :     for (auto eventIt = myEvents.begin(); eventIt != myEvents.end();) {
     105         1120 :         eventIt->second = eventIt->first->shiftTime(currentTime, eventIt->second, newTime);
     106         1120 :         if (eventIt->second >= 0) {
     107              :             ++eventIt;
     108              :         } else {
     109          112 :             delete eventIt->first;
     110              :             eventIt = myEvents.erase(eventIt);
     111              :         }
     112              :     }
     113          531 :     std::make_heap(myEvents.begin(), myEvents.end(), eventCompare);
     114          531 : }
     115              : 
     116              : 
     117              : /****************************************************************************/