From 262ef86c7ef317698d56a2fde83ea63b54254893 Mon Sep 17 00:00:00 2001
From: Matthias Schiffer <matthias@gamezock.de>
Date: Mon, 2 Mar 2009 17:24:23 +0100
Subject: Binaerdaten in XmlPacket

---
 src/Common/XmlPacket.cpp | 96 ++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 81 insertions(+), 15 deletions(-)

(limited to 'src/Common/XmlPacket.cpp')

diff --git a/src/Common/XmlPacket.cpp b/src/Common/XmlPacket.cpp
index 672d092..87045a8 100644
--- a/src/Common/XmlPacket.cpp
+++ b/src/Common/XmlPacket.cpp
@@ -17,8 +17,15 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <config.h>
+
 #include "XmlPacket.h"
 #include <cstdlib>
+#include <cstring>
+
+extern "C" {
+#include "base64.h"
+}
 
 namespace Mad {
 namespace Common {
@@ -30,7 +37,13 @@ void XmlPacket::Element::updateStr() {
   if(type == NONE || type == LIST)
     return;
 
-  if(type != STRING) {
+  if(type == BINARY) {
+    char *base64Data;
+    base64_encode_alloc((char*)binData, value.var_size, &base64Data);
+    str = base64Data;
+    std::free(base64Data);
+  }
+  else if(type != STRING) {
     std::ostringstream buf;
 
     switch(type) {
@@ -56,7 +69,6 @@ void XmlPacket::Element::updateStr() {
         buf << value.var_ldouble;
       default:
         break;
-
     }
 
     str = buf.str();
@@ -69,7 +81,7 @@ void XmlPacket::Element::updateStr() {
   xmlFreeNode(oldNode);
 }
 
-XmlPacket::Element::Element(xmlNodePtr node) : elementNode(node), type(NONE) {
+XmlPacket::Element::Element(xmlNodePtr node) : elementNode(node), binData(0), type(NONE) {
   if(!node)
     return;
 
@@ -85,7 +97,11 @@ XmlPacket::Element::Element(xmlNodePtr node) : elementNode(node), type(NONE) {
 
   str = (char*)content;
 
-  if(!xmlStrcmp(typestr, (xmlChar*)"int")) {
+  if(!xmlStrcmp(typestr, (xmlChar*)"binary")) {
+    type = BINARY;
+    base64_decode_alloc((char*)content, xmlStrlen(content), (char**)&binData, &value.var_size);
+  }
+  else if(!xmlStrcmp(typestr, (xmlChar*)"int")) {
     type = INT;
     value.var_int = std::strtol((char*)content, 0, 10);
   }
@@ -123,6 +139,24 @@ XmlPacket::Element::Element(xmlNodePtr node) : elementNode(node), type(NONE) {
   updateStr();
 }
 
+XmlPacket::Element::~Element() {
+  if(binData)
+    std::free(binData);
+}
+
+void XmlPacket::Element::setBinaryData(const void *data, size_t size) {
+  if(type != BINARY)
+    return;
+
+  if(binData)
+    std::free(binData);
+
+  binData = std::malloc(size);
+  std::memcpy(binData, data, size);
+
+  updateStr();
+}
+
 XmlPacket::Entry::Entry(xmlNodePtr node) : entryNode(node) {
   if(!node)
     return;
@@ -134,47 +168,79 @@ XmlPacket::Entry::Entry(xmlNodePtr node) : entryNode(node) {
     xmlChar *name = xmlGetProp(element, (xmlChar*)"name");
 
     if(!xmlStrcmp(element->name, (xmlChar*)"list"))
-      lists.insert(std::make_pair(std::string((char*)name), List(element)));
+      lists.insert(std::make_pair(std::string((char*)name), new List(element)));
     else if(!xmlStrcmp(element->name, (xmlChar*)"value"))
-      elements.insert(std::make_pair(std::string((char*)name), Element(element)));
+      elements.insert(std::make_pair(std::string((char*)name), new Element(element)));
 
     xmlFree(name);
   }
 }
 
+XmlPacket::Entry::~Entry() {
+  for(std::map<std::string, Element*>::iterator element = elements.begin(); element != elements.end(); ++element)
+    delete element->second;
+
+  for(std::map<std::string, List*>::iterator list = lists.begin(); list != lists.end(); ++list)
+    delete list->second;
+}
+
 XmlPacket::Element& XmlPacket::Entry::operator[](const std::string &name) {
-  std::map<std::string, Element>::iterator it = elements.find(name);
+  std::map<std::string, Element*>::iterator it = elements.find(name);
   if(it != elements.end())
-    return it->second;
+    return *it->second;
 
-  std::map<std::string, List>::iterator it2 = lists.find(name);
+  std::map<std::string, List*>::iterator it2 = lists.find(name);
   if(it2 != lists.end())
-    return it2->second;
+    return *it2->second;
 
   return nilElement;
 }
 
 const XmlPacket::Element& XmlPacket::Entry::operator[](const std::string &name) const {
-  std::map<std::string, Element>::const_iterator it = elements.find(name);
+  std::map<std::string, Element*>::const_iterator it = elements.find(name);
   if(it != elements.end())
-    return it->second;
+    return *it->second;
 
-  std::map<std::string, List>::const_iterator it2 = lists.find(name);
+  std::map<std::string, List*>::const_iterator it2 = lists.find(name);
   if(it2 != lists.end())
-    return it2->second;
+    return *it2->second;
 
   return nilElement;
 }
 
+bool XmlPacket::Entry::addBinary(const std::string &name, const void *data, size_t size) {
+  if(!entryNode)
+    return false;
+
+  if(elements.find(name) != elements.end() || lists.find(name) != lists.end())
+    return false;
+
+  char *base64Data;
+
+  base64_encode_alloc((const char*)data, size, &base64Data);
+  if(!base64Data)
+    return false;
+
+  bool ret = add(name, std::string(base64Data), "binary");
+
+  std::free(base64Data);
+
+  return ret;
+}
+
 XmlPacket::List::List(xmlNodePtr node) : Element(node, LIST) {
   for(xmlNodePtr entry = node->children; entry != 0; entry = entry->next) {
     if(entry->type != XML_ELEMENT_NODE || xmlStrcmp(entry->name, (xmlChar*)"entry"))
       continue;
 
-    entries.push_back(Entry(entry));
+    entries.push_back(new Entry(entry));
   }
 }
 
+XmlPacket::List::~List() {
+  for(std::vector<Entry*>::iterator entry = entries.begin(); entry != entries.end(); ++entry)
+    delete *entry;
+}
 
 XmlPacket::XmlPacket() {
   doc = xmlNewDoc((xmlChar*)"1.0");
-- 
cgit v1.2.3