Added ability to define friends, players you want to ignore or disregard and

configure whether trading is allowed. Based on new popup code, configuration
improvements to store hierarchical data and a table model.

1 files changed, 133 insertions, 14 deletions

diff --git a/src/configuration.h b/src/configuration.h
index 28246a02..36d9e150 100644
--- a/src/configuration.h
+++ b/src/configuration.h
@@ -27,28 +27,53 @@
 #include <map>
 #include <list>
 #include <string>
+#include <cassert>
+#include <libxml/xmlwriter.h>
 
 class ConfigListener;
+class ConfigurationObject;
 
 /**
- * Configuration handler for reading (and writing).
+ * Configuration list manager interface; responsible for serlialising/deserialising
+ * configuration choices in containers.
  *
- * \ingroup CORE
+ * \param T Type of the container elements to serialise
+ * \param CONT Type of the container we (de)serialise
  */
-class Configuration
+template <class T, class CONT>
+class ConfigurationListManager
 {
     public:
         /**
-         * Reads config file and parse all options into memory.
+         * Writes a value into a configuration object
          *
-         * \param filename path to config file
+         * \param value The value to write out
+         * \param obj The configuation object to write to
+         * \return obj, or otherwise NULL to indicate that this option should be skipped
          */
-        void init(const std::string &filename);
+        virtual ConfigurationObject *writeConfigItem(T value, ConfigurationObject *obj) = 0;
 
         /**
-         * Writes the current settings back to the config file.
+         * Reads a value from a configuration object
+         *
+         * \param obj The configuration object to read from
+         * \param container The container to insert the object to
          */
-        void write();
+        virtual CONT readConfigItem(ConfigurationObject *obj, CONT container) = 0;
+};
+
+/**
+ * Configuration object, mapping values to names and possibly containing
+ * lists of further configuration objects
+ *
+ * \ingroup CORE
+ */
+class ConfigurationObject
+{
+    friend class Configuration;
+
+    public:
+        virtual ~ConfigurationObject(void);
 
         /**
          * Sets an option using a string value.
@@ -56,7 +81,7 @@ class Configuration
          * \param key Option identifier.
          * \param value Value.
          */
-        void setValue(const std::string &key, std::string value);
+        virtual void setValue(const std::string &key, std::string value);
 
         /**
          * Sets an option using a numeric value.
@@ -64,7 +89,7 @@ class Configuration
          * \param key Option identifier.
          * \param value Value.
          */
-        void setValue(const std::string &key, float value);
+        virtual void setValue(const std::string &key, float value);
 
         /**
          * Gets a value as string.
@@ -83,6 +108,102 @@ class Configuration
         float getValue(const std::string &key, float deflt);
 
         /**
+         * Re-sets all data in the configuration
+         */
+        virtual void clear(void);
+
+        /**
+         * Serialises a container into a list of configuration options
+         *
+         * \param IT Iterator type over CONT
+         * \param T Elements that IT iterates over
+         * \param CONT The associated container type
+         *
+         * \param name Name of the list the elements should be stored under
+         * \param begin Iterator start
+         * \param end Iterator end
+         * \param manager An object capable of serialising T items
+         */
+        template <class IT, class T, class CONT>
+        void setList(const std::string &name, IT begin, IT end, ConfigurationListManager<T, CONT> *manager)
+        {
+            ConfigurationObject *nextobj = new ConfigurationObject();
+            deleteList(name);
+            ConfigurationList *list = &(mContainerOptions[name]);
+
+            for (IT it = begin; it != end; it++) {
+                ConfigurationObject *wrobj = manager->writeConfigItem(*it, nextobj);
+                if (wrobj) { // wrote something
+                    assert (wrobj == nextobj);
+                    nextobj = new ConfigurationObject();
+                    list->push_back(wrobj);
+                } else
+                    nextobj->clear(); // you never know...
+            }
+
+            delete nextobj;
+        }
+
+       /**
+        * Serialises a container into a list of configuration options
+        *
+        * \param IT Iterator type over CONT
+        * \param T Elements that IT iterates over
+        * \param CONT The associated container type
+        *
+        * \param name Name of the list the elements should be read from under
+        * \param empty Initial (empty) container to write to
+        * \param manager An object capable of deserialising items into CONT
+        */
+        template<class T, class CONT>
+        CONT getList(const std::string &name, CONT empty, ConfigurationListManager<T, CONT> *manager)
+        {
+            ConfigurationList *list = &(mContainerOptions[name]);
+            CONT container = empty;
+            
+            for (ConfigurationList::const_iterator it = list->begin(); it != list->end(); it++)
+                container = manager->readConfigItem(*it, container);
+
+            return container;
+        }
+
+    protected:
+        virtual void initFromXML(xmlNodePtr node);
+        virtual void writeToXML(xmlTextWriterPtr writer);
+
+        void deleteList(const std::string &name);
+
+        typedef std::map<std::string, std::string> Options;
+        typedef Options::iterator OptionIterator;
+        Options mOptions;
+
+        typedef std::list<ConfigurationObject *> ConfigurationList;
+        std::map<std::string, ConfigurationList> mContainerOptions;
+};
+
+/**
+ * Configuration handler for reading (and writing).
+ *
+ * \ingroup CORE
+ */
+class Configuration : public ConfigurationObject
+{
+    public:
+        virtual ~Configuration(void) {}
+
+        /**
+         * Reads config file and parse all options into memory.
+         *
+         * \param filename path to config file
+         */
+        void init(const std::string &filename);
+
+        /**
+         * Writes the current settings back to the config file.
+         */
+        void write();
+
+        /**
          * Adds a listener to the listen list of the specified config option.
          */
         void addListener(const std::string &key, ConfigListener *listener);
@@ -93,11 +214,9 @@ class Configuration
          */
         void removeListener(const std::string &key, ConfigListener *listener);
 
+        virtual void setValue(const std::string &key, std::string value);
+        virtual void setValue(const std::string &key, float value);
     private:
-        typedef std::map<std::string, std::string> Options;
-        typedef Options::iterator OptionIterator;
-        Options mOptions;
-
         typedef std::list<ConfigListener*> Listeners;
         typedef Listeners::iterator ListenerIterator;
         typedef std::map<std::string, Listeners> ListenerMap;