mudpiProcessingError.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_REUSABLECOMPONENT_TELREPUB_MUDPIPROCESSORERROR_HPP
#define RTCTK_REUSABLECOMPONENT_TELREPUB_MUDPIPROCESSORERROR_HPP
 
#include "llnetio/mudpi/mudpi.hpp"
#include <cstdint>
#include <optional>
#include <string>
#include <system_error>
#include <variant>
 
#include <fmt/format.h>
#include <fmt/ostream.h>
 
namespace rtctk::telRepub {
 
template <class ErrorStruct>
struct ErrorCode {
    ErrorCode() = default;
 
    // We want the implicit conversion. The thing stored inside the class is what is being passed
    // as the argument to the constructor. Therefore it is OK to have the implicit constructor in
    // this case.
    // cppcheck-suppress noExplicitConstructor
    ErrorCode(typename ErrorStruct::VariantType err) : m_error_info(err) {
    }
 
    bool HasError() const {
        return m_error_info.has_value();
    }
 
    template <typename E>
    bool HasError() const {
        return HasError() and std::holds_alternative<E>(*m_error_info);
    }
 
    template <typename E>
    E GetError() const {
        if (not HasError<E>()) {
            throw std::logic_error("bad error access");
        }
        return std::get<E>(*m_error_info);
    }
 
    std::string What() const {
        if (not HasError()) {
            throw std::logic_error("bad error access");
        }
        std::string msg;
        std::visit([&](auto&& arg) { msg = arg.What(); }, *m_error_info);
        return msg;
    }
 
private:
    std::optional<typename ErrorStruct::VariantType> m_error_info;
};
 
struct MudpiProcessorError {
    struct FrameIdOutOfRange {
        std::string_view dds_topic;
        llnetio::mudpi::TopicId topic_id;
        llnetio::mudpi::SampleId sample_id;
        llnetio::mudpi::FrameId frame_id;
        llnetio::mudpi::NumFrames num_frames;
        inline std::string What() const {
            return fmt::format(
                "DDS Topic: \"{}\" MUDPI Topic [{}] SampleId: {} FrameId: {:2}. FrameId out of "
                "range (1..{}).",
                dds_topic,
                topic_id,
                sample_id,
                frame_id,
                num_frames);
        }
    };
 
    struct UnexpectedSampleId {
        std::string_view dds_topic;
        llnetio::mudpi::TopicId topic_id;
        llnetio::mudpi::SampleId sample_id;
        llnetio::mudpi::FrameId frame_id;
        llnetio::mudpi::SampleId expected_sample_id;
        inline std::string What() const {
            return fmt::format(
                "DDS Topic: \"{}\" MUDPI Topic [{}] SampleId: {} FrameId: {:2} Expected SampleId "
                "{}. Unexpected SampleId, frame rejected.",
                dds_topic,
                topic_id,
                sample_id,
                frame_id,
                expected_sample_id);
        }
    };
 
    struct UnexpectedFrameId {
        std::string_view dds_topic;
        llnetio::mudpi::TopicId topic_id;
        llnetio::mudpi::SampleId sample_id;
        llnetio::mudpi::FrameId frame_id;
        llnetio::mudpi::FrameId expected_frame_id;
        inline std::string What() const {
            return fmt::format(
                "DDS Topic: \"{}\" MUDPI Topic [{}] SampleId: {} FrameId: {:2} Expected FrameId "
                "{:2}. Unexpected FrameId, frame rejected.",
                dds_topic,
                topic_id,
                sample_id,
                frame_id,
                expected_frame_id);
        }
    };
 
    struct Synchronising {
        std::string_view dds_topic;
        llnetio::mudpi::TopicId topic_id;
        llnetio::mudpi::SampleId sample_id;
        llnetio::mudpi::FrameId frame_id;
        inline std::string What() const {
            return fmt::format(
                "DDS Topic: \"{}\" MUDPI Topic [{}] SampleId: {} FrameId: {:2}. Synchronising: "
                "frame rejected.",
                dds_topic,
                topic_id,
                sample_id,
                frame_id);
        }
    };
 
    struct WranglerError {
        std::string_view dds_topic;
        llnetio::mudpi::TopicId topic_id;
        llnetio::mudpi::SampleId sample_id;
        std::error_code error;
        inline std::string What() const {
            return fmt::format(
                "DDS Topic: \"{}\" MUDPI Topic [{}] SampleId: {}. Wrangler Error: {}",
                dds_topic,
                topic_id,
                sample_id,
                error.message());
        }
    };
 
    struct PacketSizeError {
        std::string_view dds_topic;
        llnetio::mudpi::TopicId topic_id;
        llnetio::mudpi::SampleId sample_id;
        llnetio::mudpi::FrameId frame_id;
        size_t actual_packet_size;
        size_t expected_packet_size;
        inline std::string What() const {
            return fmt::format(
                "DDS Topic: \"{}\" MUDPI Topic [{}] SampleId: {} FrameId: {:2}. Packet Size "
                "mismatch: actual size {} expected size {}",
                dds_topic,
                topic_id,
                sample_id,
                frame_id,
                actual_packet_size,
                expected_packet_size);
        }
    };
 
    struct ChecksumError {
        std::string_view dds_topic;
        llnetio::mudpi::TopicId topic_id;
        llnetio::mudpi::SampleId sample_id;
        llnetio::mudpi::FrameId frame_id;
        uint16_t actual_checksum;
        uint16_t expected_checksum;
        inline std::string What() const {
            return fmt::format(
                "DDS Topic: \"{}\" MUDPI Topic [{}] SampleId: {} FrameId: {:2}. Wrong MUDPI "
                "Checksum: {} should be: {}",
                dds_topic,
                topic_id,
                sample_id,
                frame_id,
                actual_checksum,
                expected_checksum);
        }
    };
 
    using VariantType = std::variant<FrameIdOutOfRange,
                                     UnexpectedSampleId,
                                     UnexpectedFrameId,
                                     Synchronising,
                                     WranglerError,
                                     PacketSizeError,
                                     ChecksumError>;
};
 
}  // namespace rtctk::telRepub
 
#endif  // RTCTK_REUSABLECOMPONENT_TELREPUB_MUDPIPROCESSORERROR_HPP