Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2009-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    TraCIServerAPI_InductionLoop.cpp
      15             : /// @author  Daniel Krajzewicz
      16             : /// @author  Laura Bieker
      17             : /// @author  Michael Behrisch
      18             : /// @author  Jakob Erdmann
      19             : /// @date    07.05.2009
      20             : ///
      21             : // APIs for getting/setting induction loop values via TraCI
      22             : /****************************************************************************/
      23             : #include <config.h>
      24             : 
      25             : #include <microsim/MSNet.h>
      26             : #include <microsim/output/MSDetectorControl.h>
      27             : #include <libsumo/InductionLoop.h>
      28             : #include <libsumo/TraCIConstants.h>
      29             : #include <libsumo/StorageHelper.h>
      30             : #include "TraCIServerAPI_InductionLoop.h"
      31             : 
      32             : 
      33             : // ===========================================================================
      34             : // method definitions
      35             : // ===========================================================================
      36             : bool
      37       59703 : TraCIServerAPI_InductionLoop::processGet(TraCIServer& server, tcpip::Storage& inputStorage,
      38             :         tcpip::Storage& outputStorage) {
      39       59703 :     const int variable = inputStorage.readUnsignedByte();
      40       59703 :     const std::string id = inputStorage.readString();
      41       59703 :     server.initWrapper(libsumo::RESPONSE_GET_INDUCTIONLOOP_VARIABLE, variable, id);
      42             :     try {
      43       59703 :         if (!libsumo::InductionLoop::handleVariable(id, variable, &server, &inputStorage)) {
      44       49513 :             switch (variable) {
      45       49512 :                 case libsumo::LAST_STEP_VEHICLE_DATA: {
      46       49512 :                     std::vector<libsumo::TraCIVehicleData> vd = libsumo::InductionLoop::getVehicleData(id);
      47       49512 :                     tcpip::Storage tempContent;
      48             :                     int cnt = 0;
      49       49512 :                     StoHelp::writeTypedInt(tempContent, (int)vd.size());
      50             :                     ++cnt;
      51       58012 :                     for (const libsumo::TraCIVehicleData& svd : vd) {
      52        8500 :                         StoHelp::writeTypedString(tempContent, svd.id);
      53             :                         ++cnt;
      54        8500 :                         StoHelp::writeTypedDouble(tempContent, svd.length);
      55             :                         ++cnt;
      56        8500 :                         StoHelp::writeTypedDouble(tempContent, svd.entryTime);
      57             :                         ++cnt;
      58        8500 :                         StoHelp::writeTypedDouble(tempContent, svd.leaveTime);
      59             :                         ++cnt;
      60        8500 :                         StoHelp::writeTypedString(tempContent, svd.typeID);
      61        8500 :                         ++cnt;
      62             :                     }
      63       49512 :                     StoHelp::writeCompound(server.getWrapperStorage(), cnt);
      64       49512 :                     server.getWrapperStorage().writeStorage(tempContent);
      65             :                     break;
      66       49512 :                 }
      67           1 :                 default:
      68           1 :                     return server.writeErrorStatusCmd(libsumo::CMD_GET_INDUCTIONLOOP_VARIABLE,
      69           2 :                                                       "Get Induction Loop Variable: unsupported variable " + toHex(variable, 2)
      70           2 :                                                       + " specified", outputStorage);
      71             :             }
      72             :         }
      73           5 :     } catch (libsumo::TraCIException& e) {
      74           5 :         return server.writeErrorStatusCmd(libsumo::CMD_GET_INDUCTIONLOOP_VARIABLE, e.what(), outputStorage);
      75           5 :     }
      76       59697 :     server.writeStatusCmd(libsumo::CMD_GET_INDUCTIONLOOP_VARIABLE, libsumo::RTYPE_OK, "", outputStorage);
      77       59697 :     server.writeResponseWithLength(outputStorage, server.getWrapperStorage());
      78             :     return true;
      79             : }
      80             : 
      81             : 
      82             : bool
      83          27 : TraCIServerAPI_InductionLoop::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
      84             :         tcpip::Storage& outputStorage) {
      85          27 :     std::string warning = ""; // additional description for response
      86             :     // variable
      87          27 :     int variable = inputStorage.readUnsignedByte();
      88          27 :     if (variable != libsumo::VAR_PARAMETER
      89          27 :             && variable != libsumo::VAR_VIRTUAL_DETECTION
      90             :        ) {
      91           0 :         return server.writeErrorStatusCmd(libsumo::CMD_SET_INDUCTIONLOOP_VARIABLE, "Set Induction Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
      92             :     }
      93             :     // id
      94          27 :     std::string id = inputStorage.readString();
      95             :     // process
      96             :     try {
      97          27 :         switch (variable) {
      98          15 :             case libsumo::VAR_VIRTUAL_DETECTION: {
      99          15 :                 double time = -1;
     100          15 :                 if (!server.readTypeCheckingDouble(inputStorage, time)) {
     101           0 :                     return server.writeErrorStatusCmd(libsumo::CMD_SET_INDUCTIONLOOP_VARIABLE, "Setting time since last detection requires a double.", outputStorage);
     102             :                 }
     103          15 :                 libsumo::InductionLoop::overrideTimeSinceDetection(id, time);
     104          15 :                 break;
     105             :             }
     106             :             case libsumo::VAR_PARAMETER: {
     107          12 :                 StoHelp::readCompound(inputStorage, 2, "A compound object of size 2 is needed for setting a parameter.");
     108          12 :                 const std::string name = StoHelp::readTypedString(inputStorage, "The name of the parameter must be given as a string.");
     109          12 :                 const std::string value = StoHelp::readTypedString(inputStorage, "The value of the parameter must be given as a string.");
     110          12 :                 libsumo::InductionLoop::setParameter(id, name, value);
     111             :                 break;
     112             :             }
     113             :             default:
     114             :                 break;
     115             :         }
     116           0 :     } catch (libsumo::TraCIException& e) {
     117           0 :         return server.writeErrorStatusCmd(libsumo::CMD_SET_INDUCTIONLOOP_VARIABLE, e.what(), outputStorage);
     118           0 :     }
     119          27 :     server.writeStatusCmd(libsumo::CMD_SET_INDUCTIONLOOP_VARIABLE, libsumo::RTYPE_OK, warning, outputStorage);
     120             :     return true;
     121             : }
     122             : 
     123             : 
     124             : /****************************************************************************/