Rewrite.

Simplified namespace nesting.
Refactor virtual setter method name.

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);
 }
-            }
+
-        }
-    }
 }
 
 struct foo : settable::settable {

settable.hpp

@@ -4,58 +4,67 @@
 #include <map>
 #include <string>
 
+#include <boost/assert.hpp>
 #include <boost/shared_ptr.hpp>
 
-namespace settable {
-    namespace setter {
 namespace string2type {
-            namespace helper {
+
 template<typename T>
 T convert(const std::string &value);
+
 }
-        }
+
+namespace settable {
 
 class abstract_setter {
 public:
-            virtual void operator=(const std::string &value) = 0;
+    virtual void set_value(const std::string &value) = 0;
 };
 
 template<typename T>
 class setter: public abstract_setter {
 public:
-            setter(void *p) : ptr(p) {
+    setter(void *p)
+        : ptr(p) {
         BOOST_ASSERT(ptr != 0);
     }
 
-            virtual void operator=(const std::string &value) {
+    virtual void set_value(const std::string &value) {
         T *ptrT = static_cast<T*>(ptr);
         BOOST_ASSERT(ptrT != 0);
 
-                *ptrT = string2type::helper::convert<T>(value);
+        *ptrT = string2type::convert<T>(value);
     }
 
     void *ptr;
 };
-    }
 
 class settable {
 public:
     void set_attribute(const std::string &attr, const std::string &value) {
-            boost::shared_ptr<setter::abstract_setter> setter = setters[attr];
+        setters_map::iterator it = setters.find(attr);
 
-            if (setter) {
+        if (it != setters.end()) {
-                *setter = value;
+            it->second->set_value(value);
         }
     }
 
     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:
-        std::map< std::string, boost::shared_ptr<setter::abstract_setter> > setters;
+    typedef boost::shared_ptr<abstract_setter> setter_ptr;
+    typedef std::map<std::string, setter_ptr> setters_map;
+
+    setters_map setters;
 };
+
 }
 
 #endif /* SETTABLE_HPP */