Emulator.h

Go to the documentation of this file.

 
#pragma once
 
 
 
#include "Emulator_helpers.h"
#include "JSON_helper.h"
 
class Emulator {
public:
 
    Emulator();
 
    ~Emulator();
 
    bool Begin(std::string scenarioPath, std::string loggerPath, int autoPause = -1, bool logOnly_ = false, bool rawOutput_ = false);
 
    inline bool Begin(std::string loggerPath, bool autoPause = true, bool logOnly_ = false, bool rawOutput_ = false) {
        return Begin("", loggerPath, autoPause, logOnly_, rawOutput_);
    }
 
    inline bool Begin(bool autoPause = true, bool logOnly_ = false, bool rawOutput_ = false) {
        return Begin("", "", autoPause, logOnly_, rawOutput_);
    }
 
    void End();
 
    inline bool SimulationStarted() {
        return beginCalled;
    }
 
    void Pause();
 
    inline bool isPaused() {
        return beginCalled && Paused;
    }
 
    bool AutoPause = false;
 
    void Resume();
 
    bool ResumeUntil(std::chrono::nanoseconds time);
 
    std::chrono::seconds SimulationLimit = std::chrono::seconds::zero();
 
    void Handle();
 
    bool InvokeNetScan(MeshMAC currentNodeAddress, uint32_t timeout);
 
    bool InvokeNetScan(int currentNodeIndex, uint32_t timeout);
 
    bool InvokeConnect(MeshMAC currentNodeAddress, MeshMAC networkBSSID);
 
    bool InvokeConnect(int currentNodeIndex, MeshMAC networkBSSID);
 
    bool InvokeDisconnect(MeshMAC currentNodeAddress);
 
    bool InvokeDisconnect(int currentNodeIndex);
 
    bool InvokeNodeDisconnectRequest(MeshMAC gatewayNodeAddress, MeshMAC nodeToDisconnect);
 
    bool InvokeNodeDisconnectRequest(int gatewayNodeIndex, MeshMAC nodeToDisconnect);
 
    bool InvokeNetworkDrop(MeshMAC gatewayNodeAddress, bool forced);
 
    bool InvokeNetworkDrop(int gatewayNodeInde, bool forced);
 
    bool InvokeSend(MeshMAC senderNodeAddress, MeshMAC destNodeAddress, const char* message, uint8_t size);
 
    bool InvokeSend(int senderNodeIndex, int destNodeIndex, const char* message, uint8_t size);
 
    bool InvokeSend(MeshMAC senderNodeAddress, MeshMAC destNodeAddress, const uint8_t* message, uint16_t messageLength);
 
    bool InvokeSend(int senderNodeIndex, int destNodeIndex, const uint8_t* message, uint16_t messageLength);
 
    bool InvokePing(MeshMAC senderNodeAddress, MeshMAC destNodeAddress, uint32_t timeout, int16_t testDataLength = 0);
 
    bool InvokePing(int senderNodeIndex, int destNodeIndex, uint32_t timeout, int16_t testDataLength = 0);
 
    bool TablePrint(MeshMAC nodeAddress, TableType table);
 
    bool TablePrint(int index, TableType table);
 
    int indexOfNode(MeshNet* node);
 
    int indexOfNode(RFInterface* nodeInterface);
 
    int indexOfNode(MeshMAC mac);
 
    int indexOfNode(uint8_t address, MeshMAC bssid);
 
    std::mutex Mutex;
 
    std::mutex StreamMutex;
 
    const static NodeConnections DefaultNodeConnections[9];
 
    inline int GetConnectionsCount() {
        return ConnectionsCount;
    }
 
    inline const NodeConnections* GetConnectionsPtr() {
        return Connections;
    }
    
    inline int GetNodesCount() {
        return NodesCount;
    }
 
    inline NodeSimulator* GetNodeSimulatorsPtr() {
        return nodeSimulators;
    }
 
    std::chrono::seconds GetElapsedTime();
 
    inline std::chrono::nanoseconds GetMinSimulationTime() {
        return minSimulationTime;
    }
 
    inline std::chrono::nanoseconds GetMaxSimulationTime() {
        return maxSimulationTime;
    }
 
    inline bool isRawOutput() {
        return RawOutput;
    }
 
    inline bool isLogOnly() {
        return logOnly;
    }
 
protected:
 
    int ConnectionsCount = 0;
 
    const NodeConnections* Connections = NULL;
 
    int NodesCount = 0;
 
    NodeSimulator* nodeSimulators = NULL;
 
    std::chrono::system_clock::time_point SimulationResumeTime;
 
    std::chrono::seconds ElapsedTimeUntilLastPause = std::chrono::seconds::zero();
 
    bool Paused = false;
 
    std::chrono::nanoseconds runUntil = std::chrono::nanoseconds::zero();
 
    std::chrono::nanoseconds minSimulationTime = std::chrono::nanoseconds::zero();
 
    std::chrono::nanoseconds maxSimulationTime = std::chrono::nanoseconds::zero();
 
    std::chrono::nanoseconds lastSentTime = std::chrono::nanoseconds::zero();
 
    bool RawOutput = false;
 
    bool logOnly = false;
 
    bool AbortThreads = false;
 
    JSONLogsWriter logger;
 
    JSONScenarioReader scenarioReader;
 
    friend NodeSimulator; //Friend class
    friend Simulation_RFI; //Friend class
 
private:
 
    bool beginCalled = false;
 
};