Connection.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2012-2024 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
/****************************************************************************/
// C++ TraCI client API implementation
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <map>
#include <limits>
#include <string>
#include <sstream>
#include <iomanip>
#include <thread>
#include <mutex>
#include <foreign/tcpip/socket.h>
#include <libsumo/Subscription.h>
 
 
// ===========================================================================
// global definitions
// ===========================================================================
#define PRECISION 2
 
 
// ===========================================================================
// class definitions
// ===========================================================================
namespace libtraci {
class Connection {
public:
    static void connect(const std::string& host, int port, int numRetries, const std::string& label, FILE* const pipe) {
        myConnections[label] = new Connection(host, port, numRetries, label, pipe);
    }
 
    static Connection& getActive() {
        if (myActive == nullptr) {
            throw libsumo::FatalTraCIError("Not connected.");
        }
        return *myActive;
    }
 
    static bool isActive() {
        return myActive != nullptr;
    }
 
    static void switchCon(const std::string& label) {
        myActive = myConnections.find(label)->second;
    }
 
    const std::string& getLabel() const {
        return myLabel;
    }
 
    std::mutex& getMutex() const {
        return myMutex;
    }
 
    void close();
 
    libsumo::SubscriptionResults& getAllSubscriptionResults(const int domain) {
        return mySubscriptionResults[domain];
    }
 
    libsumo::ContextSubscriptionResults& getAllContextSubscriptionResults(const int domain) {
        return myContextSubscriptionResults[domain];
    }
 
 
    void simulationStep(double time);
 
 
    void setOrder(int order);
 
    void createCommand(int cmdID, int varID, const std::string* const objID, tcpip::Storage* add = nullptr) const;
 
 
    void subscribe(int domID, const std::string& objID, double beginTime, double endTime,
                   int domain, double range, const std::vector<int>& vars, const libsumo::TraCIResults& params);
 
 
    tcpip::Storage& doCommand(int command, int var = -1, const std::string& id = "", tcpip::Storage* add = nullptr, int expectedType = -1);
    void addFilter(int var, tcpip::Storage* add = nullptr);
 
    void readVariableSubscription(int responseID, tcpip::Storage& inMsg);
    void readContextSubscription(int responseID, tcpip::Storage& inMsg);
    void readVariables(tcpip::Storage& inMsg, const std::string& objectID, int variableCount, libsumo::SubscriptionResults& into);
 
private:
    void check_resultState(tcpip::Storage& inMsg, int command, bool ignoreCommandId = false, std::string* acknowledgement = 0);
 
    int check_commandGetResult(tcpip::Storage& inMsg, int command, int expectedType = -1, bool ignoreCommandId = false) const;
 
    template <class T>
    static inline std::string toString(const T& t, std::streamsize accuracy = PRECISION) {
        std::ostringstream oss;
        oss.setf(std::ios::fixed, std::ios::floatfield);
        oss << std::setprecision(accuracy);
        oss << t;
        return oss.str();
    }
 
    template<typename T>
    inline std::string toHex(const T i, std::streamsize numDigits = 2) {
        // inspired by http://stackoverflow.com/questions/5100718/int-to-hex-string-in-c
        std::stringstream stream;
        stream << "0x" << std::setfill('0') << std::setw(numDigits == 0 ? sizeof(T) * 2 : numDigits) << std::hex << i;
        return stream.str();
    }
 
    void readOutput();
 
    Connection(const std::string& host, int port, int numRetries, const std::string& label, FILE* const pipe);
 
private:
    const std::string myLabel;
    FILE* const myProcessPipe;
    std::thread* myProcessReader;
    tcpip::Socket mySocket;
    mutable tcpip::Storage myOutput;
    mutable tcpip::Storage myInput;
 
    mutable std::mutex myMutex;
 
    std::map<int, libsumo::SubscriptionResults> mySubscriptionResults;
    std::map<int, libsumo::ContextSubscriptionResults> myContextSubscriptionResults;
 
    static Connection* myActive;
    static std::map<const std::string, Connection*> myConnections;
 
private:
    Connection& operator=(const Connection&);
 
};
 
}