Basic structure figured out

main.cpp

@@ -0,0 +1,199 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <array>
+#include <memory>
+#include <stdint.h>
+
+
+class IFrame
+{
+public:
+    using FieldKey = int;
+
+    virtual bool read(const std::vector<uint8_t> &data) = 0;
+    virtual bool write(std::vector<uint8_t> &data) const = 0;
+    virtual bool set(const FieldKey key, int index, T value) = 0;
+    bool set(const FieldKey key, T value)
+};
+
+/*
+class Codec
+{
+public:
+    virtual bool encode() = 0
+};*/
+
+class TextFrame : public IFrame
+{
+public:
+    std::string text;
+
+    TextFrame(const std::string &text) : text(text) {}
+
+    virtual bool read(const std::vector<uint8_t> &data) override {
+        text = std::string(data.begin(), data.end());
+        return true;
+    }
+    virtual bool write(std::vector<uint8_t> &data) const override {
+        data = std::vector<uint8_t>(text.begin(), text.end());
+        return true;
+    }
+};
+
+class ComplexFrame : public IFrame
+{
+    uint32_t from;
+    uint32_t to;
+    uint8_t flags;
+    std::vector<uint8_t> data;
+};
+
+class BaseCodec
+{
+
+};
+
+template<class T>
+class Codec
+{
+public:
+    using FrameType = T;
+    using DecodeSignal = Signal<void(const FrameType &frame)>;
+    using EncodeSignal = Signal<void(const std::vector<uint8_t> &data)>;
+
+    DecodeSignal decoded;
+    EncodeSignal encoded;
+
+    bool encode(const FrameType &input, std::vector<uint8_t> &output) {
+        auto success = doEncode(input, output);
+        if (success) encoded.emit(output);
+        return success;
+    }
+
+    bool decode(const std::vector<uint8_t> &input, FrameType &output) {
+        auto success = doDecode(input, output);
+        if (success) decoded.emit(output);
+        return success;
+    }
+
+    bool input(const std::vector<uint8_t> &decodable) {
+        FrameType _;
+        return decode(decodable, _);
+    }
+
+    bool output(const FrameType &encodable) {
+        std::vector<uint8_t> _;
+        return encode(encodable, _);
+    }
+
+protected:
+    virtual bool doEncode(const FrameType &input, std::vector<uint8_t> &output) = 0;
+    virtual bool doDecode(const std::vector<uint8_t> &input, FrameType &output) = 0;
+};
+
+class MorseCodec : public Codec<TextFrame>
+{
+private:
+    static constexpr std::array<const char*, 128> ENCODE_LUT = []{
+        std::array<const char*, 128> lut{};
+        lut['A'] = ".-";
+        lut['B'] = "-...";
+        lut['C'] = "-.-.";
+        lut['D'] = "-..";
+        lut['E'] = ".";
+        lut['F'] = "..-.";
+        lut['G'] = "--.";
+        lut['H'] = "....";
+        lut['I'] = "..";
+        lut['J'] = ".---";
+        lut['K'] = "-.-";
+        lut['L'] = ".-..";
+        lut['M'] = "--";
+        lut['N'] = "-.";
+        lut['O'] = "---";
+        lut['P'] = ".--.";
+        lut['Q'] = "--.-";
+        lut['R'] = ".-.";
+        lut['S'] = "...";
+        lut['T'] = "-";
+        lut['U'] = "..-";
+        lut['V'] = "...-";
+        lut['W'] = ".--";
+        lut['X'] = "-..-";
+        lut['Y'] = "-.--";
+        lut['Z'] = "--..";
+        lut['0'] = "-----";
+        lut['1'] = ".----";
+        lut['2'] = "..---";
+        lut['3'] = "...--";
+        lut['4'] = "....-";
+        lut['5'] = ".....";
+        lut['6'] = "-....";
+        lut['7'] = "--...";
+        lut['8'] = "---..";
+        lut['9'] = "----.";
+        return lut;
+    }();
+public:
+    bool encode(const IFrame &input, std::vector<uint8_t> &data) {
+        bool succ = true;
+        std::vector<uint8_t> bytes;
+        data.clear();
+        input.write(bytes);
+        for (const auto b : bytes) {
+            auto i = static_cast<size_t>(b);
+            auto morse = ENCODE_LUT[std::toupper(i)];
+            if (morse) {
+                for (const auto c : std::string(morse)) {
+                    data.push_back(static_cast<uint8_t>(c));
+                }
+                data.push_back(' ');
+            } else {
+                succ = false;
+            }
+        }
+        return succ;
+    }
+
+    bool decode(const std::vector<uint8_t> &data, std::shared_ptr<IFrame> &frame)
+    {
+        return false;
+    }
+};
+
+
+int main()
+{
+    MorseCodec morse;
+    std::string message = "Welcome back 1848.";
+
+    std::cout << "Encoding \"" << message << "\"" << std::endl;
+    std::shared_ptr<IFrame> input = std::make_shared<TextFrame>(message);
+    std::vector<uint8_t> coded;
+    bool ok = morse.encode(*input, coded);
+
+    std::cout << "Encoded: " << std::string(coded.begin(), coded.end()) << std::endl;
+
+
+    /*
+    MultiCodec codec{std::make_shared<MorseCodec>(), std::make_shared<ComplexCodec>()};
+
+    std::shared_ptr<IFrame> output;
+    if (codec.decode(coded, output)) {
+        // That's certainly one way to do it, but that's whack.
+        output.get(ComplexFrame.FROM, )
+    }*/
+
+    auto morsey = std::make_shared<MorseCodec>();
+    auto complex = std::make_shared<ComplexCodec>();
+
+    MultiDecoder decoder{morsey, complex};
+
+    // That's the way to do it, put the lambda on the P T R
+    morsey.decoded.connect([](std::shared_ptr<TextFrame> frame) {
+       std::cout << "Decoded morse: " << frame.text << std::endl;
+    });
+
+}
+