mudpiProcessingError.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_REUSABLECOMPONENT_TELREPUB_MUDPIPROCESSORERROR_HPP
#define RTCTK_REUSABLECOMPONENT_TELREPUB_MUDPIPROCESSORERROR_HPP
 
#include <optional>
#include <string>
#include <system_error>
#include <variant>
 
#include <fmt/format.h>
#include <fmt/ostream.h>
 
#include "mudpi.h"
 
namespace rtctk::telRepub {
 
template <class ErrorStruct>
struct ErrorCode {
    ErrorCode() = default;
 
    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 {
        mudpi::int32_t topic_id;
        uint32_t sample_id;
        uint16_t frame_id;
        uint16_t num_frames;
        inline std::string What() const {
            return fmt::format(
                "Topic [{}] SampleId: {} FrameId: {:2}. FrameId out of range (1..{}).",
                topic_id,
                sample_id,
                frame_id,
                num_frames);
        }
    };
 
    struct UnexpectedSampleId {
        mudpi::int32_t topic_id;
        uint32_t sample_id;
        uint16_t frame_id;
        uint32_t expected_sample_id;
        inline std::string What() const {
            return fmt::format(
                "Topic [{}] SampleId: {} FrameId: {:2} Expected SampleId {}. Unexpected SampleId, "
                "frame rejected.",
                topic_id,
                sample_id,
                frame_id,
                expected_sample_id);
        }
    };
 
    struct UnexpectedFrameId {
        mudpi::int32_t topic_id;
        uint32_t sample_id;
        uint16_t frame_id;
        uint32_t expected_frame_id;
        inline std::string What() const {
            return fmt::format(
                "Topic [{}] SampleId: {} FrameId: {:2} Expected FrameId {:2}. Unexpected FrameId, "
                "frame rejected.",
                topic_id,
                sample_id,
                frame_id,
                expected_frame_id);
        }
    };
 
    struct TopicTooLong {
        mudpi::int32_t topic_id;
        uint32_t sample_id;
        uint32_t max_size;
        size_t actual_size;
        inline std::string What() const {
            return fmt::format(
                "Topic [{}] SampleId: {}. Topic size exceeded. Max topic size: {}, Topic size: {}.",
                topic_id,
                sample_id,
                max_size,
                actual_size);
        }
    };
 
    struct Synchronising {
        mudpi::int32_t topic_id;
        uint32_t sample_id;
        uint16_t frame_id;
        inline std::string What() const {
            return fmt::format(
                "Topic [{}] SampleId: {} FrameId: {:2}. Synchronising: frame rejected.",
                topic_id,
                sample_id,
                frame_id);
        }
    };
 
    struct WranglerError {
        mudpi::int32_t topic_id;
        uint32_t sample_id;
        std::error_code error;
        inline std::string What() const {
            return fmt::format("Topic [{}] SampleId: {}. Wrangler Error: {}",
                               topic_id,
                               sample_id,
                               error.message());
        }
    };
 
    struct PacketSizeError {
        mudpi::int32_t topic_id;
        uint32_t sample_id;
        uint16_t frame_id;
        size_t actual_packet_size;
        size_t expected_packet_size;
        inline std::string What() const {
            return fmt::format(
                "Topic [{}] SampleId: {} FrameId: {:2}. Packet Size mismatch: actual size {} "
                "expected size {}",
                topic_id,
                sample_id,
                frame_id,
                actual_packet_size,
                expected_packet_size);
        }
    };
 
    struct ChecksumError {
        mudpi::int32_t topic_id;
        uint32_t sample_id;
        uint16_t frame_id;
        uint16_t actual_checksum;
        uint16_t expected_checksum;
        inline std::string What() const {
            return fmt::format(
                "Topic [{}] SampleId: {} FrameId: {:2}. Wrong MUDPI Checksum: {} should be: {}",
                topic_id,
                sample_id,
                frame_id,
                actual_checksum,
                expected_checksum);
        }
    };
 
    using VariantType = std::variant<FrameIdOutOfRange,
                                     UnexpectedSampleId,
                                     UnexpectedFrameId,
                                     TopicTooLong,
                                     Synchronising,
                                     WranglerError,
                                     PacketSizeError,
                                     ChecksumError>;
};
 
}  // namespace rtctk::telRepub
 
#endif  // RTCTK_REUSABLECOMPONENT_TELREPUB_MUDPIPROCESSORERROR_HPP