implementing encoder interface

Author: andreagilardoni

src/cbor/CborEncoder.cpp

@@ -0,0 +1,46 @@
+#include "CborEncoder.h"
+
+CBORMessageEncoderClass& CBORMessageEncoder = CBORMessageEncoderClass::getInstance();
+
+Encoder::Status CBORMessageEncoderClass::encode(Message* message, uint8_t * data, size_t& len) { // TODO do we need to propagate the maximum length?
+  // prepare cbor structure
+  CborEncoder encoder;
+
+  cbor_encoder_init(&encoder, data, len, 0);
+
+  auto encoder_it = encoders.find(message->id);
+
+  // check if message.id exists on the encoders list or return error
+  if(encoder_it == encoders.end()) {
+    return Encoder::Status::Error;
+  }
+
+  // encode the message
+  if(encoder_it->second->_encode(&encoder, message) == Encoder::Status::Error) {
+    return Encoder::Status::Error;
+  }
+
+  len = cbor_encoder_get_buffer_size(&encoder, data);
+
+  return Encoder::Status::Complete;
+}
+
+CBORMessageEncoderInterface::CBORMessageEncoderInterface(const CBORTag tag, const MessageId id)
+: tag(tag), id(id) {
+  // call singleton/global variable and insert this encoder
+  CBORMessageEncoderClass::getInstance().append(id, this);
+}
+
+Encoder::Status CBORMessageEncoderInterface::_encode(CborEncoder* encoder, Message *msg) {
+  // this must always be true, it could mean that there are issues in the map of encoders
+  assert(msg->id == id);
+
+  if (tag == cbor::tag::CBORUnknownCmdTag16b ||
+      tag == cbor::tag::CBORUnknownCmdTag32b ||
+      tag == cbor::tag::CBORUnknownCmdTag64b ||
+      cbor_encode_tag(encoder, tag) != CborNoError) {
+    return Encoder::Status::Error;
+  }
+
+  return this->encode(encoder, msg);
+}

src/cbor/CborEncoder.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <map>
+#include "../interfaces/Encoder.h"
+#include "CBOR.h"
+#include "../interfaces/message.h"
+#include "./tinycbor/cbor-lib.h"
+
+class CBORMessageEncoderClass;
+
+
+// TODO find a better name
+// TODO maybe a template<CBORTag tag, MessageId id> ?
+// TODO maybe template<resultStruct> that is also the parameter of encode
+// TODO in order to make this more extensible we should not pass Message* as a parameter, templated function may be better (or void*)
+// providing both id and tag gives the ability to convert and avoid using a conversion function
+class CBORMessageEncoderInterface {
+public:
+  CBORMessageEncoderInterface(const CBORTag tag, const MessageId id);
+  virtual ~CBORMessageEncoderInterface() {}
+
+protected:
+  virtual Encoder::Status encode(CborEncoder* encoder, Message *msg) = 0;
+
+private:
+  const CBORTag tag;
+  const MessageId id;
+
+  friend CBORMessageEncoderClass;
+
+  // wrapper for encode function that for the time being only writes the tag in the buffer
+  Encoder::Status _encode(CborEncoder* encoder, Message *msg);
+};
+
+// TODO make a private constructor?
+class CBORMessageEncoderClass: public Encoder {
+public:
+  static CBORMessageEncoderClass& getInstance() {
+    static CBORMessageEncoderClass singleton;
+
+    return singleton;
+  }
+
+  void append(CBORTag id, CBORMessageEncoderInterface* encoder) {
+    // auto pair = encoders.try_emplace(id, encoder);
+    encoders[id] = encoder;
+  }
+
+  Encoder::Status encode(Message* message, uint8_t * data, size_t& len);
+private:
+  std::map<MessageId, CBORMessageEncoderInterface*> encoders;
+};
+
+extern CBORMessageEncoderClass& CBORMessageEncoder;