anctranslator.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/ancdetails.h>
#include <promeki/ancformat.h>
#include <promeki/ancpacket.h>
#include <promeki/anctranslateconfig.h>
#include <promeki/enums_anc.h>
#include <promeki/framesyncdisposition.h>
#include <promeki/list.h>
#include <promeki/result.h>
#include <promeki/string.h>
#include <promeki/variant.h>
#include <promeki/util.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AncTranslator {
        public:
                // -- Return-type aliases --------------------------------------
 
                using ParseResult = Result<Variant>;
 
                using PacketsResult = Result<AncPacket::List>;
 
                // -- Handler signatures ---------------------------------------
 
                using ParserFn = ParseResult (*)(const AncPacket &, const AncTranslateConfig &);
 
                using MultiParserFn = ParseResult (*)(const AncPacket::List &,
                                                       const AncTranslateConfig &);
 
                using BuilderFn = PacketsResult (*)(const Variant &, const AncTranslateConfig &);
 
                using TranslatorFn = PacketsResult (*)(const AncPacket &, AncTransport,
                                                        const AncTranslateConfig &);
 
                using SyncPolicyFn = PacketsResult (*)(const AncPacket &,
                                                        FrameSyncDisposition,
                                                        uint8_t repeatIndex,
                                                        const AncTranslateConfig &);
 
                using DetailerFn = AncDetails (*)(const AncPacket &, const AncTranslateConfig &);
 
                // -- Construction --------------------------------------------
 
                AncTranslator() = default;
 
                explicit AncTranslator(AncTranslateConfig cfg) : _cfg(std::move(cfg)) {}
 
                const AncTranslateConfig &config() const { return _cfg; }
 
                void setConfig(AncTranslateConfig cfg) { _cfg = std::move(cfg); }
 
                // -- Dispatch -------------------------------------------------
 
                ParseResult parse(const AncPacket &pkt) const;
 
                String describe(const AncPacket &pkt, Error *err = nullptr) const;
 
                AncDetails details(const AncPacket &pkt) const;
 
                ParseResult parseGroup(const AncPacket::List &pkts) const;
 
                PacketsResult build(const Variant &v, const AncFormat &fmt,
                                     const AncTransport &target) const;
 
                PacketsResult translate(const AncPacket &pkt, const AncTransport &target) const;
 
                PacketsResult applySyncPolicy(const AncPacket     &pkt,
                                               FrameSyncDisposition disposition,
                                               uint8_t              repeatIndex) const;
 
                // -- Static registration -------------------------------------
 
                static void registerParser(AncFormat::ID format, const AncTransport &src, ParserFn fn);
 
                static void registerMultiParser(AncFormat::ID format, const AncTransport &src,
                                                 MultiParserFn fn);
 
                static void registerBuilder(AncFormat::ID format, const AncTransport &dst, BuilderFn fn);
 
                static void registerTranslator(AncFormat::ID format, const AncTransport &src,
                                                const AncTransport &dst, TranslatorFn fn);
 
                static void registerSyncPolicy(AncFormat::ID format, SyncPolicyFn fn);
 
                static void registerDetailer(AncFormat::ID format, const AncTransport &src, DetailerFn fn);
 
                // -- Static capability queries -------------------------------
 
                static bool hasParser(const AncFormat &format, const AncTransport &src);
 
                static bool hasMultiParser(const AncFormat &format, const AncTransport &src);
 
                static bool hasBuilder(const AncFormat &format, const AncTransport &dst);
 
                static bool hasDirectTranslator(const AncFormat &format, const AncTransport &src,
                                                 const AncTransport &dst);
 
                static bool hasSyncPolicy(const AncFormat &format);
 
                static bool hasDetailer(const AncFormat &format, const AncTransport &src);
 
                static bool canTranslate(const AncFormat &format, const AncTransport &src,
                                          const AncTransport &dst);
 
                static List<AncTransport> registeredParserTransports(const AncFormat &format);
 
                static List<AncTransport> registeredBuilderTransports(const AncFormat &format);
 
        private:
                AncTranslateConfig _cfg;
};
 
PROMEKI_NAMESPACE_END
 
// ============================================================================
// Static-init registration macros
// ============================================================================
 
#define PROMEKI_REGISTER_ANC_PARSER(Tag, Format, Transport, Fn)                                                        \
        namespace {                                                                                                    \
                struct AncParserRegistrar_##Tag {                                                                      \
                                AncParserRegistrar_##Tag() {                                                           \
                                        ::promeki::AncTranslator::registerParser(::promeki::AncFormat::Format,         \
                                                                                  Transport, Fn);                      \
                                }                                                                                      \
                };                                                                                                     \
                static AncParserRegistrar_##Tag s_anc_parser_registrar_##Tag;                                          \
        }
 
#define PROMEKI_REGISTER_ANC_MULTI_PARSER(Tag, Format, Transport, Fn)                                                  \
        namespace {                                                                                                    \
                struct AncMultiParserRegistrar_##Tag {                                                                 \
                                AncMultiParserRegistrar_##Tag() {                                                      \
                                        ::promeki::AncTranslator::registerMultiParser(                                 \
                                                ::promeki::AncFormat::Format, Transport, Fn);                          \
                                }                                                                                      \
                };                                                                                                     \
                static AncMultiParserRegistrar_##Tag s_anc_multi_parser_registrar_##Tag;                               \
        }
 
#define PROMEKI_REGISTER_ANC_BUILDER(Tag, Format, Transport, Fn)                                                       \
        namespace {                                                                                                    \
                struct AncBuilderRegistrar_##Tag {                                                                     \
                                AncBuilderRegistrar_##Tag() {                                                          \
                                        ::promeki::AncTranslator::registerBuilder(::promeki::AncFormat::Format,        \
                                                                                   Transport, Fn);                     \
                                }                                                                                      \
                };                                                                                                     \
                static AncBuilderRegistrar_##Tag s_anc_builder_registrar_##Tag;                                        \
        }
 
#define PROMEKI_REGISTER_ANC_TRANSLATOR(Tag, Format, Src, Dst, Fn)                                                     \
        namespace {                                                                                                    \
                struct AncTranslatorRegistrar_##Tag {                                                                  \
                                AncTranslatorRegistrar_##Tag() {                                                       \
                                        ::promeki::AncTranslator::registerTranslator(::promeki::AncFormat::Format,     \
                                                                                      Src, Dst, Fn);                   \
                                }                                                                                      \
                };                                                                                                     \
                static AncTranslatorRegistrar_##Tag s_anc_translator_registrar_##Tag;                                  \
        }
 
#define PROMEKI_REGISTER_ANC_SYNC_POLICY(Tag, Format, Fn)                                                              \
        namespace {                                                                                                    \
                struct AncSyncPolicyRegistrar_##Tag {                                                                  \
                                AncSyncPolicyRegistrar_##Tag() {                                                       \
                                        ::promeki::AncTranslator::registerSyncPolicy(::promeki::AncFormat::Format,     \
                                                                                      Fn);                             \
                                }                                                                                      \
                };                                                                                                     \
                static AncSyncPolicyRegistrar_##Tag s_anc_sync_policy_registrar_##Tag;                                 \
        }
 
#define PROMEKI_REGISTER_ANC_DETAILER(Tag, Format, Transport, Fn)                                                       \
        namespace {                                                                                                    \
                struct AncDetailerRegistrar_##Tag {                                                                    \
                                AncDetailerRegistrar_##Tag() {                                                         \
                                        ::promeki::AncTranslator::registerDetailer(::promeki::AncFormat::Format,        \
                                                                                    Transport, Fn);                     \
                                }                                                                                      \
                };                                                                                                     \
                static AncDetailerRegistrar_##Tag s_anc_detailer_registrar_##Tag;                                      \
        }
 
#endif // PROMEKI_ENABLE_PROAV