GPSCommand.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <span>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
#include <QtCore/QByteArray>
#include <QtCore/QByteArrayView>
 
#include "GPSStreamDemux.h"
 
enum class GPSProtocolError : uint8_t
{
    None,
    Cancelled,        
    Transport,        
    Protocol,         
    InvalidArgument,  
    ConsentRequired,  
};
 
enum class [[nodiscard]] GPSCommandOutcome
{
    Pending,
    Written,
    Acknowledged,
    ReadbackVerified,
    Rejected,
    TimedOut,
    Cancelled,
    TransportError,
};
 
struct [[nodiscard]] GPSConfigurationEvidence
{
    QByteArray command;
    GPSCommandOutcome outcome = GPSCommandOutcome::Pending;
    uint64_t startedAtUs = 0;
    int acceptedBytes = 0;
    int writtenBytes = 0;
    bool required = true;
 
    [[nodiscard]] bool succeeded() const
    {
        return outcome == GPSCommandOutcome::Acknowledged || outcome == GPSCommandOutcome::ReadbackVerified;
    }
};
 
struct GPSConfigurationStep
{
    QByteArray command;
    std::chrono::milliseconds timeout;
    bool required = true;
};
 
using GPSTextMatcher = std::function<GPSCommandOutcome(std::string_view reply)>;
using GPSFrameMatcher = std::function<GPSCommandOutcome(const GPSFrame& frame)>;
using GPSReplyPoll = std::function<GPSCommandOutcome()>;
 
class GPSRawAckMatcher
{
public:
    GPSRawAckMatcher(QByteArrayView accepted, QByteArrayView rejected)
        : _accepted(accepted)
        , _rejected(rejected)
    {}
 
    bool valid() const
    {
        return !_accepted.empty() && _accepted.size() <= _window.size() && _rejected.size() <= _window.size();
    }
 
    void append(std::span<const uint8_t> bytes)
    {
        if (!valid()) {
            return;
        }
        for (const uint8_t byte : bytes) {
            if (_size == _window.size()) {
                std::move(_window.begin() + 1, _window.end(), _window.begin());
                --_size;
            }
            _window[_size++] = static_cast<char>(byte);
            const std::string_view received(_window.data(), _size);
            if (!_rejected.empty() && received.ends_with(_rejected)) {
                _outcome = GPSCommandOutcome::Rejected;
            } else if (_outcome != GPSCommandOutcome::Rejected && received.ends_with(_accepted)) {
                _outcome = GPSCommandOutcome::Acknowledged;
            }
        }
    }
 
    GPSCommandOutcome outcome() const { return _outcome; }
 
private:
    std::string_view _accepted;
    std::string_view _rejected;
    std::array<char, 256> _window{};
    size_t _size = 0;
    GPSCommandOutcome _outcome = GPSCommandOutcome::Pending;
};
 
struct GPSCommandSequence
{
    struct RawReply
    {
        QByteArray accepted{};
        QByteArray rejected{};
    };
 
    struct Command
    {
        GPSConfigurationStep step{};
        QByteArray wire{};
        std::variant<GPSTextMatcher, RawReply> reply{};
        unsigned attempts = 1;
    };
 
    struct [[nodiscard]] Result
    {
        std::optional<size_t> failedStep = std::nullopt;
        QByteArray failedLabel{};
        GPSCommandOutcome outcome = GPSCommandOutcome::Pending;
 
        [[nodiscard]] bool succeeded() const { return !failedStep.has_value(); }
    };
 
    std::vector<Command> steps{};
};
 
struct GPSCommandOptions
{
    bool required = true;
    QByteArray label{};
};
 
[[nodiscard]] inline GPSCommandSequence::Command gpsCommand(
    QByteArray wire, std::chrono::milliseconds timeout,
    std::variant<GPSTextMatcher, GPSCommandSequence::RawReply> reply, GPSCommandOptions options = {})
{
    GPSConfigurationStep step{.command = options.label.isEmpty() ? wire.trimmed() : std::move(options.label),
                              .timeout = timeout,
                              .required = options.required};
    return {.step = std::move(step), .wire = std::move(wire), .reply = std::move(reply)};
}