Adding a new example and including libraries

Author: juanjo

Cbor/CborDecoder.cpp

@@ -443,35 +443,59 @@ void CborReader::Run() {
 
 
 
-  void CborExampleListener::OnInteger(int value) {
-    printf("integer: %d\n", value);
-  }
+// TEST HANDLERS
 
-  void CborExampleListener::OnBytes(unsigned char *data, int size) {
-    printf("bytes with size: %d", size);
-  }
+void CborDebugListener::OnInteger(int value) {
+	Serial.print("integer:");
+	Serial.println(value);
+}
+
+void CborDebugListener::OnBytes(unsigned char *data, int size) {
+	Serial.println("bytes with size" + size);
+}
 
-  void CborExampleListener::OnString(String &str) {
-    printf("string: '%.*s'\n", (int)str.size(), str.c_str());
-  }
+void CborDebugListener::OnString(String &str) {
+	Serial.print("string:");
+	int lastStringLength = str.length();
+	//Serial.print(lastStringLength);
+	Serial.println(str);
+}
 
-  void CborExampleListener::OnArray(int size) {
-    printf("array: %d\n", size);
-  }
+void CborDebugListener::OnArray(int size) {
+	Serial.println("array:" + size);
+}
 
-  void CborExampleListener::OnMap(int size) {
-    printf("map: %d\n", size);
-  }
+void CborDebugListener::OnMap(int size) {
+	Serial.println("map:" + size);
+}
 
-  void CborExampleListener::OnTag(unsigned int tag) {
-    printf("tag: %d\n", tag);
-  }
+void CborDebugListener::OnTag(unsigned int tag) {
+	Serial.println("tag:" + tag);
+}
 
-  void CborExampleListener::OnSpecial(int code) {
-    printf("special: %d\n", code);
-  }
+void CborDebugListener::OnSpecial(unsigned int code) {
+	Serial.println("special" + code);
+}
 
-  void CborExampleListener::OnError(const char *error) {
-    printf("error: %s\n", error);
-  }
+void CborDebugListener::OnError(const char *error) {
+	Serial.print("error:");
 
+	Serial.println(error);
+}
+
+void CborDebugListener::OnExtraInteger(unsigned long long value, int sign) {
+    if(sign >= 0) {
+        Serial.println("extra integer: %llu\n" + value);
+    } else {
+        Serial.println("extra integer: -%llu\n" + value);
+    }
+}
+
+void CborDebugListener::OnExtraTag(unsigned long long tag) {
+    Serial.println("extra tag: %llu\n" + tag);
+}
+
+void CborDebugListener::OnExtraSpecial(unsigned long long tag) {
+    Serial.println("extra special: %llu\n" + tag);
+    
+}

Cbor/CborEncoder.cpp

@@ -52,6 +52,54 @@ unsigned int CborStaticOutput::getSize() {
 }
 
 
+CborDynamicOutput::CborDynamicOutput() {
+    init(256);
+}
+
+CborDynamicOutput::CborDynamicOutput(unsigned int initalCapacity) {
+    init(initalCapacity);
+}
+
+CborDynamicOutput::~CborDynamicOutput() {
+    delete buffer;
+}
+
+void CborDynamicOutput::init(unsigned int initalCapacity) {
+    this->capacity = initalCapacity;
+    this->buffer = new unsigned char[initalCapacity];
+    this->offset = 0;
+}
+
+
+unsigned char *CborDynamicOutput::getData() {
+    return buffer;
+}
+
+unsigned int CborDynamicOutput::getSize() {
+    return offset;
+}
+
+void CborDynamicOutput::putByte(unsigned char value) {
+    if(offset < capacity) {
+        buffer[offset++] = value;
+    } else {
+        capacity *= 2;
+        buffer = (unsigned char *) realloc(buffer, capacity);
+        buffer[offset++] = value;
+    }
+}
+
+void CborDynamicOutput::putBytes(const unsigned char *data, int size) {
+    while(offset + size > capacity) {
+        capacity *= 2;
+        buffer = (unsigned char *) realloc(buffer, capacity);
+    }
+
+    memcpy(buffer + offset, data, size);
+    offset += size;
+}
+
+
 
 void CborWriter::writeTypeAndValue(int majorType, unsigned int value) {
 	majorType <<= 5;

Cbor/CborEncoder.h

@@ -45,6 +45,24 @@ class CborStaticOutput : public CborOutput {
 };
 
 
+class CborDynamicOutput : public CborOutput {
+public:
+    CborDynamicOutput();
+    CborDynamicOutput(unsigned int initalCapacity);
+    ~CborDynamicOutput();
+
+
+    virtual unsigned char *getData();
+    virtual unsigned int getSize();
+    virtual void putByte(unsigned char value);
+    virtual void putBytes(const unsigned char *data, int size);
+private:
+    void init(unsigned int initalCapacity);
+    unsigned char *buffer;
+    unsigned int capacity;
+    unsigned int offset;
+};
+
 class CborWriter {
 public:
 	CborWriter(CborOutput &output);