1 files changed, 77 insertions, 82 deletions

diff --git a/src/Common/XmlPacket.cpp b/src/Common/XmlPacket.cpp
index 6e3d007..8e612a9 100644
--- a/src/Common/XmlPacket.cpp
+++ b/src/Common/XmlPacket.cpp
@@ -24,58 +24,71 @@
 #include <cstdlib>
 #include <cstring>
 
+#include <iostream>
+
 namespace Mad {
 namespace Common {
 
-XmlPacket::Entry XmlPacket::Element::nilEntry(0);
-XmlPacket::Element XmlPacket::Entry::nilElement(0);
-
 void XmlPacket::Element::updateStr() {
-  if(type == NONE || type == LIST)
-    return;
+  std::string typeStr;
 
-  if(type == BINARY) {
-    str = Base64Encoder::encode(std::vector<boost::uint8_t>((boost::uint8_t*)binData, ((boost::uint8_t*)binData)+value.var_size));
+  if(type == NONE) {
+    str = "";
+  }
+  else if(type == BINARY) {
+    str = Base64Encoder::encode(boost::get<std::vector<boost::uint8_t> >(value));
+    typeStr = "binary";
   }
   else if(type != STRING) {
     std::ostringstream buf;
 
     switch(type) {
       case INT:
-        buf << value.var_int;
+        buf << boost::get<long>(value);
+        typeStr = "int";
         break;
       case UINT:
-        buf << value.var_uint;
+        buf << boost::get<unsigned long>(value);
+        typeStr = "uint";
         break;
       case INT64:
-        buf << value.var_int64;
+        buf << boost::get<long long>(value);
+        typeStr = "int64";
         break;
       case UINT64:
-        buf << value.var_uint64;
+        buf << boost::get<unsigned long long>(value);
+        typeStr = "uint64";
         break;
       case FLOAT:
-        buf << value.var_float;
+        buf << boost::get<float>(value);
+        typeStr = "float";
         break;
       case DOUBLE:
-        buf << value.var_double;
+        buf << boost::get<double>(value);
+        typeStr = "double";
         break;
       case LONGDOUBLE:
-        buf << value.var_ldouble;
+        buf << boost::get<long double>(value);
+        typeStr = "longdouble";
       default:
         break;
     }
 
     str = buf.str();
   }
+  else
+    typeStr = "string";
 
   xmlNodePtr newNode = xmlNewText((xmlChar*)str.c_str());
   xmlNodePtr oldNode = elementNode->children;
 
   xmlReplaceNode(oldNode, newNode);
   xmlFreeNode(oldNode);
+
+  xmlSetProp(elementNode, (xmlChar*)"type", (xmlChar*)typeStr.c_str());
 }
 
-XmlPacket::Element::Element(xmlNodePtr node) : elementNode(node), binData(0), type(NONE) {
+XmlPacket::Element::Element(xmlNodePtr node) : elementNode(node), type(NONE) {
   if(!node)
     return;
 
@@ -94,39 +107,35 @@ XmlPacket::Element::Element(xmlNodePtr node) : elementNode(node), binData(0), ty
   if(!xmlStrcmp(typestr, (xmlChar*)"binary")) {
     type = BINARY;
 
-    std::vector<boost::uint8_t> v = Base64Encoder::decode(str);
-
-    value.var_size = v.size();
-    binData = std::malloc(value.var_size);
-    std::memcpy(binData, v.data(), value.var_size);
+    value = Base64Encoder::decode(str);
   }
   else if(!xmlStrcmp(typestr, (xmlChar*)"int")) {
     type = INT;
-    value.var_int = std::strtol((char*)content, 0, 10);
+    value = std::strtol((char*)content, 0, 10);
   }
   else if(!xmlStrcmp(typestr, (xmlChar*)"uint")) {
     type = UINT;
-    value.var_uint = std::strtoul((char*)content, 0, 10);
+    value = std::strtoul((char*)content, 0, 10);
   }
   else if(!xmlStrcmp(typestr, (xmlChar*)"int64")) {
     type = INT64;
-    value.var_int64 = std::strtoll((char*)content, 0, 10);
+    value = std::strtoll((char*)content, 0, 10);
   }
   else if(!xmlStrcmp(typestr, (xmlChar*)"uint64")) {
     type = UINT64;
-    value.var_uint64 = std::strtoull((char*)content, 0, 10);
+    value = std::strtoull((char*)content, 0, 10);
   }
   else if(!xmlStrcmp(typestr, (xmlChar*)"float")) {
     type = FLOAT;
-    value.var_float = std::strtof((char*)content, 0);
+    value = std::strtof((char*)content, 0);
   }
   else if(!xmlStrcmp(typestr, (xmlChar*)"double")) {
     type = DOUBLE;
-    value.var_double = std::strtod((char*)content, 0);
+    value = std::strtod((char*)content, 0);
   }
   else if(!xmlStrcmp(typestr, (xmlChar*)"longdouble")) {
     type = LONGDOUBLE;
-    value.var_ldouble = std::strtold((char*)content, 0);
+    value = std::strtold((char*)content, 0);
   }
   else if(!xmlStrcmp(typestr, (xmlChar*)"string")) {
     type = STRING;
@@ -135,25 +144,8 @@ XmlPacket::Element::Element(xmlNodePtr node) : elementNode(node), binData(0), ty
   xmlFree(typestr);
   xmlFree(content);
 
-  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();
+  if(type != NONE)
+    updateStr();
 }
 
 XmlPacket::Entry::Entry(xmlNodePtr node) : entryNode(node) {
@@ -175,51 +167,59 @@ XmlPacket::Entry::Entry(xmlNodePtr node) : entryNode(node) {
   }
 }
 
-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);
-  if(it != elements.end())
-    return *it->second;
 
-  std::map<std::string, List*>::iterator it2 = lists.find(name);
-  if(it2 != lists.end())
-    return *it2->second;
+template <>
+std::string XmlPacket::Entry::get<std::string>(const std::string &name) const {
+  Element *element = getElement(name);
+  if(!element)
+    return std::string();
 
-  return nilElement;
+  return element->str;
 }
 
-const XmlPacket::Element& XmlPacket::Entry::operator[](const std::string &name) const {
-  std::map<std::string, Element*>::const_iterator it = elements.find(name);
-  if(it != elements.end())
-    return *it->second;
+template <>
+const std::string& XmlPacket::Entry::get<const std::string&>(const std::string &name) const {
+  static std::string empty;
 
-  std::map<std::string, List*>::const_iterator it2 = lists.find(name);
-  if(it2 != lists.end())
-    return *it2->second;
+  Element *element = getElement(name);
+  if(!element)
+    return empty;
 
-  return nilElement;
+  return element->str;
 }
 
-bool XmlPacket::Entry::addBinary(const std::string &name, const void *data, size_t size) {
-  if(!entryNode)
-    return false;
+template <>
+std::vector<boost::uint8_t> XmlPacket::Entry::get<std::vector<unsigned char> >(const std::string &name) const {
+  Element *element = getElement(name);
+  if(!element)
+    return std::vector<boost::uint8_t>();
+
+    switch(element->type) {
+      case Element::BINARY:
+        return boost::get<std::vector<boost::uint8_t> >(element->value);
+      default:
+        return std::vector<boost::uint8_t>();
+    }
+}
 
-  if(elements.find(name) != elements.end() || lists.find(name) != lists.end())
-    return false;
+template <>
+const std::vector<boost::uint8_t>& XmlPacket::Entry::get<const std::vector<unsigned char>&>(const std::string &name) const {
+  static std::vector<boost::uint8_t> empty;
 
-  std::string base64Data = Base64Encoder::encode(std::vector<boost::uint8_t>((boost::uint8_t*)data, ((boost::uint8_t*)data)+size));;
+  Element *element = getElement(name);
+  if(!element)
+    return empty;
 
-  return add(name, base64Data, "binary");
+    switch(element->type) {
+      case Element::BINARY:
+        return boost::get<std::vector<boost::uint8_t> >(element->value);
+      default:
+        return empty;
+    }
 }
 
-XmlPacket::List::List(xmlNodePtr node) : Element(node, LIST) {
+XmlPacket::List::List(xmlNodePtr node) : elementNode(node) {
   for(xmlNodePtr entry = node->children; entry != 0; entry = entry->next) {
     if(entry->type != XML_ELEMENT_NODE || xmlStrcmp(entry->name, (xmlChar*)"entry"))
       continue;
@@ -228,11 +228,6 @@ XmlPacket::List::List(xmlNodePtr node) : Element(node, LIST) {
   }
 }
 
-XmlPacket::List::~List() {
-  for(std::vector<Entry*>::iterator entry = entries.begin(); entry != entries.end(); ++entry)
-    delete *entry;
-}
-
 XmlPacket::XmlPacket() {
   doc = xmlNewDoc((xmlChar*)"1.0");