network.h

Go to the documentation of this file.

/*****************************************************************************************
 * SGCT                                                                                  *
 * Simple Graphics Cluster Toolkit                                                       *
 *                                                                                       *
 * Copyright (c) 2012-2026                                                               *
 * For conditions of distribution and use, see copyright notice in LICENSE.md            *
 ****************************************************************************************/
 
#ifndef __SGCT__NETWORK__H__
#define __SGCT__NETWORK__H__
 
#include <sgct/sgctexports.h>
 
#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
#ifdef WIN32
using SGCT_SOCKET = size_t;
#else // ^^^^ WIN32 // !WIN32 vvvv
using SGCT_SOCKET = int;
#endif // WIN32
 
namespace sgct {

class SGCT_EXPORT Network {
public:
    // ASCII device control chars = 17, 18, 19 & 20
    static constexpr char DefaultId = 0;
    static constexpr char Ack = 6;
    static constexpr char DataId = 17;
    static constexpr char ConnectedId = 18;
    static constexpr char DisconnectId = 19;
 
    enum class ConnectionType { SyncConnection, DataTransfer };
 
    static constexpr size_t HeaderSize = 13;

    static int lastError();

    Network(int port, const std::string& address, bool isServer, ConnectionType t);
    ~Network();
 
    void initialize();
    void closeNetwork(bool forced);
    void initShutdown();
 
    void setDecodeFunction(std::function<void(const char*, int)> fn);
    void setPackageDecodeFunction(std::function<void(void*, int, int, int)> fn);
    void setUpdateFunction(std::function<void(Network&)> fn);
    void setConnectedFunction(std::function<void (void)> fn);
    void setAcknowledgeFunction(std::function<void(int, int)> fn);
 
    void setConnectedStatus(bool state);
    void closeSocket(SGCT_SOCKET lSocket);
 
    ConnectionType type() const;
    int id() const;
    bool isServer() const;
    bool isConnected() const;
 
    int sendFrameCurrent() const;
    int recvFrameCurrent() const;
    int recvFramePrevious() const;

    double loopTime() const;

    bool isUpdated() const;
    void sendData(const void* data, int length) const;

    int iterateFrameCounter();

    void pushClientMessage();

    int port() const;
 
    std::condition_variable& startConnectionConditionVar();
 
private:
    Network(const Network&) = delete;
    Network(Network&&) = delete;
    Network& operator=(const Network&) = delete;
    Network& operator=(Network&&) = delete;
 
    void setRecvFrame(int i);
    void updateBuffer(std::vector<char>& buffer, uint32_t reqSize, uint32_t& currSize);
    int readSyncMessage(char* header, int32_t& syncFrame, uint32_t& dataSize,
        uint32_t& uncompressedDataSize);
    int readDataTransferMessage(char* header, int32_t& packageId, uint32_t& dataSize,
        uint32_t& uncompressedDataSize);
    int readExternalMessage();
 
    void communicationHandler();
    void connectionHandler();
 
    SGCT_SOCKET _socket;
    SGCT_SOCKET _listenSocket;
 
    const ConnectionType _connectionType = ConnectionType::SyncConnection;
    std::atomic_bool _isServer;
    std::atomic_bool _isConnected = false;
    std::atomic_bool _isUpdated = false;
    std::atomic<int32_t> _currentSendFrame = 0;
    std::atomic<int32_t> _previousSendFrame = 0;
    std::atomic<int32_t> _currentRecvFrame = 0;
    std::atomic<int32_t> _previousRecvFrame = -1;
    std::atomic_bool _shouldTerminate = false; // set to true upon exit
 
    mutable std::mutex _connectionMutex;
    std::unique_ptr<std::thread> _commThread;
    std::unique_ptr<std::thread> _mainThread;
 
    double _timeStampSend = 0.0;
    std::atomic<double> _timeStampTotal = 0.0;
    int _id;
    uint32_t _bufferSize = 1024;
    uint32_t _uncompressedBufferSize = _bufferSize;
    std::atomic<uint32_t> _requestedSize = _bufferSize;
    const int _port = -1;
 
    std::vector<char> _recvBuffer;
    std::vector<char> _uncompressBuffer;
    char _headerId = 0;
 
    std::condition_variable _startConnectionCond;
 
    std::function<void(const char*, int)> decoderCallback;
    std::function<void(void*, int, int, int)> _packageDecoderCallback;
    std::function<void(Network&)> _updateCallback;
    std::function<void(void)> _connectedCallback;
    std::function<void(int, int)> _acknowledgeCallback;
};
 
} // namespace sgct
 
#endif // __SGCT__NETWORK__H__