From db168ca56ee27ee24cb7f838dfae0b7a2e8e24bb Mon Sep 17 00:00:00 2001
From: Jens Luedicke <jens.luedicke@gmail.com>
Date: Sun, 19 Sep 2010 22:37:57 +0200
Subject: [PATCH] Rewrite.

Simplified namespace nesting.
Refactor virtual setter method name.
---
 examples/demo.cpp | 20 ++++------
 settable.hpp      | 95 ++++++++++++++++++++++++++---------------------
 2 files changed, 60 insertions(+), 55 deletions(-)

diff --git a/examples/demo.cpp b/examples/demo.cpp
index 84201a4..f16c80b 100644
--- a/examples/demo.cpp
+++ b/examples/demo.cpp
@@ -4,17 +4,13 @@
 
 #include <boost/lexical_cast.hpp>
 
-namespace settable {
-    namespace setter {
-        namespace string2type {
-            namespace helper {
-                template<>
-                int convert<int>(const std::string &value) {
-                    return boost::lexical_cast<int>(value);
-                }
-            }
-        }
-    }
+namespace string2type {
+
+template<>
+int convert<int>(const std::string &value) {
+    return boost::lexical_cast<int>(value);
+}
+
 }
 
 struct foo : settable::settable {
@@ -32,4 +28,4 @@ int main(int argc, char *argv) {
     std::cout << f.x << std::endl;
 
     return 0;
-}
\ No newline at end of file
+}
diff --git a/settable.hpp b/settable.hpp
index 683d3cd..cf1f42e 100644
--- a/settable.hpp
+++ b/settable.hpp
@@ -4,58 +4,67 @@
 #include <map>
 #include <string>
 
+#include <boost/assert.hpp>
 #include <boost/shared_ptr.hpp>
 
+namespace string2type {
+
+template<typename T>
+T convert(const std::string &value);
+
+}
+
 namespace settable {
-    namespace setter {
-        namespace string2type {
-            namespace helper {
-                template <typename T>
-                T convert(const std::string &value);
-            }
-        }
 
-        class abstract_setter {
-        public:
-            virtual void operator=(const std::string &value) = 0;
-        };
+class abstract_setter {
+public:
+    virtual void set_value(const std::string &value) = 0;
+};
 
-        template <typename T>
-        class setter : public abstract_setter {
-        public:
-            setter(void *p) : ptr(p) {
-                BOOST_ASSERT(ptr != 0);
-            }
-            
-            virtual void operator=(const std::string &value) {
-                T *ptrT = static_cast<T*>(ptr);
-                BOOST_ASSERT(ptrT != 0);
-
-                *ptrT = string2type::helper::convert<T>(value);
-            }
-
-            void *ptr;
-        };
+template<typename T>
+class setter: public abstract_setter {
+public:
+    setter(void *p)
+        : ptr(p) {
+        BOOST_ASSERT(ptr != 0);
     }
 
-    class settable {
-    public:
-        void set_attribute(const std::string &attr, const std::string &value) {
-            boost::shared_ptr<setter::abstract_setter> setter = setters[attr];
-            
-            if (setter) {
-                *setter = value;
-            }
-        }
+    virtual void set_value(const std::string &value) {
+        T *ptrT = static_cast<T*>(ptr);
+        BOOST_ASSERT(ptrT != 0);
 
-        template <typename T>
-        void register_setter(const std::string &name, void *ptr) {
-            setters.insert(std::make_pair(name, boost::shared_ptr<setter::abstract_setter>(new setter::setter<T>(ptr))));
-        }
+        *ptrT = string2type::convert<T>(value);
+    }
+
+    void *ptr;
+};
+
+class settable {
+public:
+    void set_attribute(const std::string &attr, const std::string &value) {
+        setters_map::iterator it = setters.find(attr);
+
+        if (it != setters.end()) {
+            it->second->set_value(value);
+        }
+    }
+
+    template<typename T>
+    void register_setter(const std::string &name, T *ptr) {
+        typedef setter<T> specific_setter;
+
+        setter_ptr setter(new specific_setter(ptr));
+
+        setters.insert(std::make_pair(name, setter));
+    }
+
+private:
+    typedef boost::shared_ptr<abstract_setter> setter_ptr;
+    typedef std::map<std::string, setter_ptr> setters_map;
+
+    setters_map setters;
+};
 
-    private:
-        std::map< std::string, boost::shared_ptr<setter::abstract_setter> > setters;
-    };
 }
 
 #endif /* SETTABLE_HPP */