fixup! implementing decoder interface

Author: andreagilardoni

src/cbor/CborDecoder.cpp

@@ -9,10 +9,7 @@
 */
 #include "CborDecoder.h"
 
-static CBORMessageDecoderClass* singleton = nullptr;
-CBORMessageDecoderClass& CBORMessageDecoder = CBORMessageDecoderClass::getInstance();
-
-Decoder::Status CBORMessageDecoderClass::decode(Message* msg, const uint8_t* const buf, size_t &len) { // TODO do we need to propagate the maximum length?
+Decoder::Status CBORMessageDecoderSingleton::decode(Message* msg, const uint8_t* const buf, size_t &len) { // TODO do we need to propagate the maximum length?
   // prepare cbor structure
   CborValue iter;
   CborTag tag;
@@ -49,17 +46,16 @@ Decoder::Status CBORMessageDecoderClass::decode(Message* msg, const uint8_t* con
   return Decoder::Status::Complete;
 }
 
-CBORMessageDecoderClass& CBORMessageDecoderClass::getInstance() {
-  if(singleton == nullptr) {
-    singleton = new CBORMessageDecoderClass();
-  }
-  return *singleton;
+CBORMessageDecoderSingleton& CBORMessageDecoderSingleton::getInstance() {
+  static CBORMessageDecoderSingleton singleton;
+
+  return singleton;
 }
 
 CBORMessageDecoderInterface::CBORMessageDecoderInterface(const CBORTag tag, const MessageId id)
 : tag(tag), id(id) {
   // call singleton/global variable and insert this encoder
-  CBORMessageDecoderClass::getInstance().append(tag, this);
+  CBORMessageDecoderSingleton::getInstance().append(tag, this);
 }
 
 Decoder::Status CBORMessageDecoderInterface::_decode(CborValue* iter, Message *msg) {

src/cbor/CborDecoder.h

@@ -15,13 +15,12 @@
 #include "../interfaces/message.h"
 #include "./tinycbor/cbor-lib.h"
 
-class CBORMessageDecoderClass;
+class CBORMessageDecoderSingleton;
 
 // 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 CBORMessageDecoderInterface {
 public:
   CBORMessageDecoderInterface(const CBORTag tag, const MessageId id);
@@ -34,25 +33,31 @@ class CBORMessageDecoderInterface {
   const CBORTag tag;
   const MessageId id;
 
-  friend CBORMessageDecoderClass;
+  friend CBORMessageDecoderSingleton;
 
   // wrapper for encode function that for the time being only writes the tag in the buffer
   Decoder::Status _decode(CborValue* iter, Message *msg);
 };
 
-// TODO make a private constructor?
-class CBORMessageDecoderClass: public Decoder {
+class CBORMessageDecoderSingleton: public Decoder {
 public:
-  CBORMessageDecoderClass() {}
-  static CBORMessageDecoderClass& getInstance();
+  static CBORMessageDecoderSingleton& getInstance();
 
   void append(CBORTag id, CBORMessageDecoderInterface* encoder) {
     decoders[id] = encoder;
   }
 
   Decoder::Status decode(Message* msg, const uint8_t* const buf, size_t &len);
 private:
+  CBORMessageDecoderSingleton() {}
+
+  static CBORMessageDecoderSingleton singleton;
   std::map<CBORTag, CBORMessageDecoderInterface*> decoders;
 };
 
-extern CBORMessageDecoderClass& CBORMessageDecoder;
+class CBORMessageDecoder: public Decoder {
+public:
+  inline Decoder::Status decode(Message* msg, const uint8_t* const buf, size_t &len) {
+    return CBORMessageDecoderSingleton::getInstance().decode(msg, buf, len);
+  }
+};