GPSProtocolRuntime.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <span>
 
#include <QtCore/QString>
 
#include "GPSClock.h"
#include "GPSCommand.h"
#include "GPSCommandChannel.h"
#include "GPSDeadline.h"
#include "GPSFamilyProtocol.h"
#include "GPSProtocolEvent.h"
#include "GPSStreamDemux.h"
#include "GPSTransport.h"
 
struct GPSRuntimeIO
{
    std::function<GPSReadResult(std::span<uint8_t>, GPSDeadline)> read{};
    std::function<GPSWriteResult(std::span<const uint8_t>, GPSDeadline)> write{};
    std::function<GPSBaudStatus(unsigned)> setBaudrate{};
    GPSClock clock{};
    GPSCancelToken cancelToken{};
};
 
struct GPSRuntimeObserver
{
    std::function<void(const GPSEventBatch&)> decoded{};
    std::function<void(const GPSConfigurationEvidence&)> commandFinished{};
};
 
class GPSProtocolRuntime final : private GPSStreamDemux::Handler
{
public:
    GPSProtocolRuntime(const GPSReceiverFamily& family, GPSRuntimeIO io, GPSRuntimeObserver observer = {});
    GPSProtocolRuntime(const GPSReceiverFamily& family, std::unique_ptr<GPSFamilyProtocol> protocol, GPSRuntimeIO io,
                       GPSRuntimeObserver observer = {});
    ~GPSProtocolRuntime();
 
    Q_DISABLE_COPY(GPSProtocolRuntime)
 
    
    [[nodiscard]] bool configure(const GPSConfig& config, unsigned& baud);
 
    [[nodiscard]] bool probe(std::chrono::milliseconds budget);
 
    GPSReceiveUpdates receive(std::chrono::milliseconds timeout);
 
    [[nodiscard]] bool armDecodeOnly(const GPSConfig& config);
 
    bool armNavigationDecode(GPSNavigationDecode decode = {});
 
    [[nodiscard]] GPSEventBatch decode(std::span<const uint8_t> bytes);
 
    GPSReceiveUpdates consume(std::span<const uint8_t> bytes);
 
    GPSReceiveUpdates consumeFrame(const GPSFrame& frame);
 
    [[nodiscard]] bool receiverReady() const;
 
    [[nodiscard]] QString identity() const;
 
    [[nodiscard]] GPSProtocolError error() const { return _channel.error(); }
 
    [[nodiscard]] const QString& errorDetail() const { return _channel.errorDetail(); }
 
    [[nodiscard]] const GPSReceiverFamily& family() const { return _family; }
 
    [[nodiscard]] GPSFamilyProtocol& protocol() { return *_protocol; }
 
    [[nodiscard]] GPSStreamDemux& stream() { return _demux; }
 
    [[nodiscard]] GPSLogCategory logCategory() const;
 
private:
    friend class GPSCommandChannel;
 
    void frame(const GPSFrame& frame) override;
 
    [[nodiscard]] uint64_t nowUs() const { return _io.clock.nowUs(); }
 
    GPSReceiveUpdates _deliver(GPSEventBatch batch);
 
    void _commandFinished(const GPSConfigurationEvidence& result);
 
    const GPSReceiverFamily& _family;
    GPSRuntimeIO _io;
    GPSRuntimeObserver _observer;
    GPSStreamDemux _demux;
    std::unique_ptr<GPSFamilyProtocol> _protocol;
    GPSCommandChannel _channel;
    GPSDecodeContext _context;
};