path: root/src/Common/XmlPacket.h

/*
 * XmlProcessor.h
 *
 * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef MAD_COMMON_XMLPACKET_H_
#define MAD_COMMON_XMLPACKET_H_

#include <Net/Packet.h>

#include <map>
#include <string>
#include <sstream>
#include <vector>

#include <libxml/parser.h>

#include <boost/cstdint.hpp>
#include <boost/noncopyable.hpp>
#include <boost/variant/get.hpp>
#include <boost/variant/variant.hpp>
#include <boost/smart_ptr.hpp>

#include <iostream>

namespace Mad {
namespace Common {

class XmlPacket {
  public:
    class Entry;
    class List;

  private:
    xmlDocPtr doc;
    xmlNodePtr packetNode;
    Entry *entry;

    class Element : private boost::noncopyable {
      private:
        friend class Entry;

        enum Type {
          NONE, BINARY,
          INT, UINT, INT64, UINT64,
          FLOAT, DOUBLE, LONGDOUBLE, STRING
        };

        typedef boost::variant<long, unsigned long, long long, unsigned long long, float, double, long double, std::vector<boost::uint8_t> > Variant;

        xmlNodePtr elementNode;

        Type type;
        Variant value;

        std::string str;

        void updateStr();

        Element(xmlNodePtr node);

        template <typename T>
        void set(T val, Type type0) {
          type = type0;
          value = val;

          updateStr();
        }

        void set(int val) {
          set<long>(val, INT);
        }

        void set(unsigned int val) {
          set<unsigned long>(val, UINT);
        }

        void set(long val) {
          set(val, INT);
        }

        void set(unsigned long val) {
          set(val, UINT);
        }

        void set(long long val) {
          set(val, INT64);
        }

        void set(unsigned long long val) {
          set(val, UINT64);
        }

        void set(float val) {
          set(val, FLOAT);
        }

        void set(double val) {
          set(val, DOUBLE);
        }

        void set(long double val) {
          set(val, LONGDOUBLE);
        }

        void set(const std::string &val) {
          type = STRING;
          value = Element::Variant();
          str = val;
          updateStr();
        }

        void set(const std::vector<boost::uint8_t> &val) {
          set(val, BINARY);
        }
    };

  public:
    class Entry : private boost::noncopyable {
      private:
        friend class List;
        friend class XmlPacket;

        xmlNodePtr entryNode;

        std::map<std::string, Element*> elements;
        std::map<std::string, List*> lists;

        Element* getElement(const std::string &name) {
          std::map<std::string, Element*>::iterator element = elements.find(name);

          if(element != elements.end())
            return element->second;

          if(lists.find(name) != lists.end())
            return 0;

          xmlNodePtr newNode = xmlNewTextChild(entryNode, 0, (xmlChar*)"value", (xmlChar*)"");
          xmlSetProp(newNode, (xmlChar*)"name", (xmlChar*)name.c_str());
          xmlSetProp(newNode, (xmlChar*)"type", (xmlChar*)"");

          Element* newElement = new Element(newNode);

          elements.insert(std::make_pair(name, newElement));

          return newElement;
        }

        Element* getElement(const std::string &name) const {
          std::map<std::string, Element*>::const_iterator element = elements.find(name);

          if(element != elements.end())
            return element->second;
          else
            return 0;
        }

        Entry(xmlNodePtr node);
        ~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;
        }

      public:
        template <typename T>
        bool set(const std::string &name, T val) {
          Element *element = getElement(name);
          if(!element)
            return false;

          element->set(val);

          return true;
        }

        template <typename T>
        T get(const std::string &name) const {
          Element *element = getElement(name);
          if(!element)
            return T();

          switch(element->type) {
            case Element::INT:
              return static_cast<T>(boost::get<long>(element->value));
            case Element::UINT:
              return static_cast<T>(boost::get<unsigned long>(element->value));
            case Element::INT64:
              return static_cast<T>(boost::get<long long>(element->value));
            case Element::UINT64:
              return static_cast<T>(boost::get<unsigned long long>(element->value));
            case Element::FLOAT:
              return static_cast<T>(boost::get<float>(element->value));
            case Element::DOUBLE:
              return static_cast<T>(boost::get<double>(element->value));
            case Element::LONGDOUBLE:
              return static_cast<T>(boost::get<long double>(element->value));
            default:
              return static_cast<T>(0);
          }
        }

        List* createList(const std::string &name, bool unique = false) {
          std::map<std::string, List*>::iterator list = lists.find(name);

          if(list != lists.end())
            return unique ? 0 : list->second;

          if(elements.find(name) != elements.end())
            return 0;

          xmlNodePtr newNode = xmlNewChild(entryNode, 0, (xmlChar*)"list", 0);
          xmlSetProp(newNode, (xmlChar*)"name", (xmlChar*)name.c_str());

          List *newList = new List(newNode);

          lists.insert(std::make_pair(name, newList));

          return newList;
        }

        List* getList(const std::string &name) {
          std::map<std::string, List*>::iterator list = lists.find(name);

          if(list == lists.end())
            return 0;

          return list->second;
        }

        const List* getList(const std::string &name) const {
          std::map<std::string, List*>::const_iterator list = lists.find(name);

          if(list == lists.end())
            return 0;

          return list->second;
        }

        void unset(const std::string &name) {
          std::map<std::string, Element*>::iterator element = elements.find(name);

          if(element != elements.end()) {
            xmlUnlinkNode(element->second->elementNode);
            xmlFreeNode(element->second->elementNode);

            delete element->second;

            elements.erase(element);

            return;
          }

          std::map<std::string, List*>::iterator list = lists.find(name);

          if(list != lists.end()) {
            xmlUnlinkNode(list->second->elementNode);
            xmlFreeNode(list->second->elementNode);

            delete list->second;

            lists.erase(list);

            return;
          }

          return;
        }
    };

    class List : private boost::noncopyable {
      private:
        friend class Entry;

        xmlNodePtr elementNode;

        std::vector<Entry*> entries;

        template <typename Type, typename IteratorType>
        class iterator_base {
          public:
            friend class List;

            typedef Type value_type;

            typedef value_type &reference;
            typedef value_type *pointer;

            typedef ssize_t difference_type;

          private:
            IteratorType it;

            iterator_base(IteratorType it0) : it(it0) {}

          public:
            iterator_base() {}

            reference operator*() const {
              return **it;
            }

            iterator_base operator+(const difference_type &n) const {
              return iterator(it+n);
            }

            iterator_base operator++(int) {
              return iterator(it++);
            }

            iterator_base& operator++() {
              ++it;
              return *this;
            }

            iterator_base& operator+=(const difference_type &n) {
              it += n;
              return *this;
            }

            iterator_base operator-(const difference_type &n) const {
              return iterator(it-n);
            }

            iterator_base operator--(int) {
              return iterator(it--);
            }

            iterator_base& operator--() {
              --it;
              return *this;
            }

            iterator_base& operator-=(const difference_type &n) {
              it -= n;
              return *this;
            }

            bool operator==(const iterator_base &it2) {
              return it2.it == it;
            }

            bool operator!=(const iterator_base &it2) {
              return it2.it != it;
            }

            pointer operator->() const {
              return *it;
            }

            reference operator[](const difference_type &n) const {
              return *it[n];
            }
        };

        List(xmlNodePtr node);
        ~List() {
          for(std::vector<Entry*>::iterator entry = entries.begin(); entry != entries.end(); ++entry)
            delete *entry;
        }

      public:
        typedef iterator_base<Entry, std::vector<Entry*>::iterator> iterator;
        typedef iterator_base<const Entry, std::vector<Entry*>::const_iterator> const_iterator;

        size_t getSize() const {
          return entries.size();
        }

        bool isEmpty() const {
          return entries.empty();
        }

        Entry& operator[](size_t i) {
          return *entries[i];
        }

        const Entry& operator[](size_t i) const {
          return *entries[i];
        }

        iterator begin() {
          return iterator(entries.begin());
        }

        const_iterator begin() const {
          return const_iterator(entries.begin());
        }

        iterator end() {
          return iterator(entries.end());
        }

        const_iterator end() const {
          return const_iterator(entries.end());
        }

        iterator insertEntry(iterator it) {
          xmlNodePtr newNode = xmlNewNode(0, (xmlChar*)"entry");

          if(it == end())
            xmlAddChild(elementNode, newNode);
          else
            xmlAddPrevSibling(it->entryNode, newNode);

          return iterator(entries.insert(it.it, new Entry(newNode)));
        }

        iterator addEntry() {
          return insertEntry(end());
        }

        void removeEntry(iterator it) {
          xmlUnlinkNode(it->entryNode);
          xmlFreeNode(it->entryNode);
          delete *it.it;

          entries.erase(it.it);
        }
    };

    XmlPacket();
    XmlPacket(const XmlPacket &o);
    XmlPacket(const Net::Packet &packet);

    XmlPacket& operator=(const XmlPacket &o);

    virtual ~XmlPacket() {
      delete entry;

      xmlFreeDoc(doc);
    }

    std::string getType() const;
    void setType(const std::string &type);

    template <typename T>
    bool set(const std::string &name, T val) {
      return entry->set(name, val);
    }

    template <typename T>
    T get(const std::string &name) const {
      return entry->get<T>(name);
    }

    List* createList(const std::string &name, bool unique = false) {
      return entry->createList(name, unique);
    }

    List* getList(const std::string &name) {
      return entry->getList(name);
    }

    const List* getList(const std::string &name) const {
      return entry->getList(name);
    }

    void unset(const std::string &name) {
      entry->unset(name);
    }

    Net::Packet encode(uint16_t requestId) const;
};

template <> std::string XmlPacket::Entry::get<std::string>(const std::string &name) const;
template <> const std::string& XmlPacket::Entry::get<const std::string&>(const std::string &name) const;

template <> std::vector<boost::uint8_t> XmlPacket::Entry::get<std::vector<unsigned char> >(const std::string &name) const;
template <> const std::vector<boost::uint8_t>& XmlPacket::Entry::get<const std::vector<unsigned char>&>(const std::string &name) const;

}
}

#endif /* MAD_COMMON_XMLPACKET_H_ */