Rewrite.

Simplified namespace nesting.
Refactor virtual setter method name.

examples/demo.cpp

@@ -4,17 +4,13 @@
 
 #include <boost/lexical_cast.hpp>
 
-namespace settable {
+namespace string2type {
-    namespace setter {
+
-        namespace string2type {
+template<>
-            namespace helper {
+int convert<int>(const std::string &value) {
-                template<>
+    return boost::lexical_cast<int>(value);
-                int convert<int>(const std::string &value) {
+}
-                    return boost::lexical_cast<int>(value);
+
-                }
-            }
-        }
-    }
 }
 
 struct foo : settable::settable {

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 {
+class abstract_setter {
-        public:
+public:
-            virtual void operator=(const std::string &value) = 0;
+    virtual void set_value(const std::string &value) = 0;
-        };
+};
 
-        template <typename T>
+template<typename T>
-        class setter : public abstract_setter {
+class setter: public abstract_setter {
-        public:
+public:
-            setter(void *p) : ptr(p) {
+    setter(void *p)
-                BOOST_ASSERT(ptr != 0);
+        : 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;
-        };
     }
 
-    class settable {
+    virtual void set_value(const std::string &value) {
-    public:
+        T *ptrT = static_cast<T*>(ptr);
-        void set_attribute(const std::string &attr, const std::string &value) {
+        BOOST_ASSERT(ptrT != 0);
-            boost::shared_ptr<setter::abstract_setter> setter = setters[attr];
 
-            if (setter) {
+        *ptrT = string2type::convert<T>(value);
-                *setter = 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>
+    template<typename T>
-        void register_setter(const std::string &name, void *ptr) {
+    void register_setter(const std::string &name, T *ptr) {
-            setters.insert(std::make_pair(name, boost::shared_ptr<setter::abstract_setter>(new setter::setter<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 */