[Refactor]: Change configuration.cc to use boost::variant 10/75210/19
authorJames Harrison <00jamesh@gmail.com>
Tue, 14 Mar 2017 15:04:07 +0000 (15:04 +0000)
committerDave Rigby <daver@couchbase.com>
Thu, 6 Apr 2017 17:13:36 +0000 (17:13 +0000)
Using variant simplifies some aspects of configuration.cc. It also paved
the way to templating a number of methods, reducing code repetition.

Change-Id: I625c84dd1daa905d38f6ab0e2d7ee31bf998657b
Reviewed-on: http://review.couchbase.org/75210
Tested-by: Build Bot <build@couchbase.com>
Reviewed-by: Dave Rigby <daver@couchbase.com>
src/configuration.cc
src/configuration.h
tests/module_tests/configuration_test.cc
tools/genconfig.cc

index c818e40..2afcd47 100644 (file)
  */
 
 #include "config.h"
+#include "configuration.h"
+
+#include <boost/variant.hpp>
+#include <platform/cb_malloc.h>
 
 #include <algorithm>
-#include <iostream>
-#include <limits>
 #include <sstream>
 #include <vector>
 
-#include <platform/cb_malloc.h>
-
-#include "configuration.h"
-
 #ifdef AUTOCONF_BUILD
 #include "generated_configuration.cc"
 #endif
 #include "statwriter.h"
 #undef STATWRITER_NAMESPACE
 
-Configuration::Configuration() {
-    initialize();
-}
-
-std::string Configuration::getString(const std::string &key) const {
-    LockHolder lh(mutex);
-
-    const auto iter = attributes.find(key);
-    if (iter == attributes.end()) {
-        return std::string();
-    }
-    if (iter->second->datatype != DT_STRING) {
-        throw std::invalid_argument("Configuration::getString: key (which is " +
-                                    std::to_string(iter->second->datatype) +
-                                    ") is not DT_STRING");
-    }
-
-    if (iter->second->val.v_string) {
-        return std::string(iter->second->val.v_string);
-    }
-    return std::string();
-}
-
-bool Configuration::getBool(const std::string &key) const {
-    LockHolder lh(mutex);
-
-    const auto iter = attributes.find(key);
-    if (iter == attributes.end()) {
-        return false;
-    }
-    if (iter->second->datatype != DT_BOOL) {
-        throw std::invalid_argument("Configuration::getBool: key (which is " +
-                                    std::to_string(iter->second->datatype) +
-                                    ") is not DT_BOOL");
-    }
-    return iter->second->val.v_bool;
-}
-
-float Configuration::getFloat(const std::string &key) const {
-    LockHolder lh(mutex);
-
-    const auto iter = attributes.find(key);
-    if (iter == attributes.end()) {
-        return 0;
-    }
-    if (iter->second->datatype != DT_FLOAT) {
-        throw std::invalid_argument("Configuration::getFloat: key (which is " +
-                                    std::to_string(iter->second->datatype) +
-                                    ") is not DT_FLOAT");
-    }
-    return iter->second->val.v_float;
-}
+// Used to get a name from a type to use in logging
+template <typename T>
+struct type_name {
+    static char* const value;
+};
 
-size_t Configuration::getInteger(const std::string &key) const {
-    LockHolder lh(mutex);
+#define TYPENAME(type) \
+    template <>        \
+    char* const type_name<type>::value = (char* const) #type;
 
-    const auto iter = attributes.find(key);
-    if (iter == attributes.end()) {
-        return 0;
-    }
-    if (iter->second->datatype != DT_SIZE) {
-        throw std::invalid_argument(
-                "Configuration::getInteger: key (which is " +
-                std::to_string(iter->second->datatype) + ") is not DT_SIZE");
-    }
-    return iter->second->val.v_size;
-}
+TYPENAME(bool)
+TYPENAME(size_t)
+TYPENAME(ssize_t)
+TYPENAME(float)
+TYPENAME(std::string)
+#undef TYPENAME
 
-ssize_t Configuration::getSignedInteger(const std::string &key) const {
-    LockHolder lh(mutex);
-
-    const auto iter = attributes.find(key);
-    if (iter == attributes.end()) {
-        return 0;
-    }
-    if (iter->second->datatype != DT_SSIZE) {
-        throw std::invalid_argument(
-                "Configuration::getSignedInteger: key "
-                "(which is " +
-                std::to_string(iter->second->datatype) + ") is not DT_SSIZE");
-    }
-    return iter->second->val.v_ssize;
+Configuration::Configuration() {
+    initialize();
 }
 
-std::ostream& operator <<(std::ostream &out, const Configuration &config) {
-    LockHolder lh(config.mutex);
-    for (const auto& attribute : config.attributes) {
-        std::stringstream line;
-        line << attribute.first.c_str();
-        line << " = [";
-        switch (attribute.second->datatype) {
-        case DT_BOOL:
-            if (attribute.second->val.v_bool) {
-                line << "true";
-            } else {
-                line << "false";
-            }
-            break;
-        case DT_STRING:
-            line << attribute.second->val.v_string;
-            break;
-        case DT_SIZE:
-            line << attribute.second->val.v_size;
-            break;
-        case DT_SSIZE:
-            line << attribute.second->val.v_ssize;
-            break;
-        case DT_FLOAT:
-            line << attribute.second->val.v_float;
-            break;
-        case DT_CONFIGFILE:
-            continue;
-        default:
-            // ignore
-            ;
-        }
-        line << "]" << std::endl;
-        out << line.str();
+struct Configuration::value_t {
+    std::vector<std::unique_ptr<ValueChangedListener>> changeListener;
+    std::unique_ptr<ValueChangedValidator> validator;
+
+    // At the moment, the order of these template parameters must
+    // match the order of the types in config_datatype. Looking
+    // for a cleaner method.
+    boost::variant<size_t, ssize_t, float, bool, std::string> value;
+
+    std::vector<ValueChangedListener*> copyListeners() {
+        std::vector<ValueChangedListener*> copy;
+
+        std::transform(
+                changeListener.begin(),
+                changeListener.end(),
+                std::back_inserter(copy),
+                [](std::unique_ptr<ValueChangedListener>& listener)
+                        -> ValueChangedListener* { return listener.get(); });
+        return copy;
     }
+};
 
-    return out;
-}
-
-void Configuration::setParameter(const std::string &key, bool value) {
-    std::vector<ValueChangedListener*> copy;
-    {
-        std::lock_guard<std::mutex> lh(mutex);
-        auto validator = attributes.find(key);
-        if (validator != attributes.end()) {
-            if (validator->second->validator) {
-                validator->second->validator->validateBool(key, value);
-            }
-        } else {
-            attributes[key] = std::make_shared<value_t>();
-        }
-        attributes[key]->datatype = DT_BOOL;
-        attributes[key]->val.v_bool = value;
-        copy = attributes[key]->copyListeners();
-    }
-
-    for (auto* listener : copy) {
-        listener->booleanValueChanged(key, value);
-    }
-}
-
-void Configuration::setParameter(const std::string &key, size_t value) {
+template <class T>
+void Configuration::setParameter(const std::string& key, T value) {
     std::vector<ValueChangedListener*> copy;
     {
         std::lock_guard<std::mutex> lh(mutex);
         auto validator = attributes.find(key);
         if (validator != attributes.end()) {
             if (validator->second->validator) {
-                validator->second->validator->validateSize(key, value);
+                validator->second->validator->validate(key, value);
             }
         } else {
             attributes[key] = std::make_shared<value_t>();
         }
-        attributes[key]->datatype = DT_SIZE;
-        attributes[key]->val.v_size = value;
-
+        attributes[key]->value = value;
         copy = attributes[key]->copyListeners();
     }
 
     for (auto* listener : copy) {
-        listener->sizeValueChanged(key, value);
+        listener->valueChanged(key, value);
     }
 }
 
-void Configuration::setParameter(const std::string &key, ssize_t value) {
-    std::vector<ValueChangedListener*> copy;
-    {
-        std::lock_guard<std::mutex> lh(mutex);
-        auto validator = attributes.find(key);
-        if (validator != attributes.end()) {
-            if (validator->second->validator) {
-                validator->second->validator->validateSSize(key, value);
-            }
-        } else {
-            attributes[key] = std::make_shared<value_t>();
-        }
-        attributes[key]->datatype = DT_SSIZE;
-        attributes[key]->val.v_ssize = value;
-
-        copy = attributes[key]->copyListeners();
-    }
-
-    for (auto* listener : copy) {
-        listener->ssizeValueChanged(key, value);
-    }
+template <>
+void Configuration::setParameter<const char*>(const std::string& key,
+                                              const char* value) {
+    setParameter(key, std::string(value));
 }
 
-void Configuration::setParameter(const std::string &key, float value) {
-    std::vector<ValueChangedListener*> copy;
-    {
-        std::lock_guard<std::mutex> lh(mutex);
-
-        auto validator = attributes.find(key);
-        if (validator != attributes.end()) {
-            if (validator->second->validator) {
-                validator->second->validator->validateFloat(key, value);
-            }
-        } else {
-            attributes[key] = std::make_shared<value_t>();
-        }
+template <class T>
+T Configuration::getParameter(const std::string& key) const {
+    LockHolder lh(mutex);
 
-        attributes[key]->datatype = DT_FLOAT;
-        attributes[key]->val.v_float = value;
-        copy = attributes[key]->copyListeners();
+    const auto iter = attributes.find(key);
+    if (iter == attributes.end()) {
+        return T();
     }
 
-    for (auto* listener : copy) {
-        listener->floatValueChanged(key, value);
-    }
-}
+    T* value = boost::get<T>(&iter->second->value);
 
-void Configuration::setParameter(const std::string &key,
-                                 const std::string &value) {
-    if (value.length() == 0) {
-        setParameter(key, (const char *)NULL);
-    } else {
-        setParameter(key, value.c_str());
+    if (value == nullptr) {
+        std::cerr << iter->second->value << std::endl;
+        throw std::invalid_argument(
+                "Configuration::getParameter: key \"" + key + "\" (which is " +
+                std::to_string(iter->second->value.which()) + ") is not " +
+                type_name<T>::value);
     }
+    return *value;
 }
 
-void Configuration::setParameter(const std::string &key, const char *value) {
-    std::vector<ValueChangedListener*> copy;
-    {
-        std::lock_guard<std::mutex> lh(mutex);
-        auto attr = attributes.find(key);
-        if (attr != attributes.end()) {
-            if (attr->second->validator) {
-                attr->second->validator->validateString(key, value);
-            }
-            if (attr->second->datatype == DT_STRING) {
-                cb_free((void*)attr->second->val.v_string);
-            }
-        } else {
-            attributes[key] = std::make_shared<value_t>();
-        }
-
-        attributes[key]->datatype = DT_STRING;
-        attributes[key]->val.v_string = NULL;
-        if (value != NULL) {
-            attributes[key]->val.v_string = cb_strdup(value);
-        }
+template bool Configuration::getParameter<bool>(const std::string& key) const;
+template size_t Configuration::getParameter<size_t>(
+        const std::string& key) const;
+template ssize_t Configuration::getParameter<ssize_t>(
+        const std::string& key) const;
+template float Configuration::getParameter<float>(const std::string& key) const;
+template std::string Configuration::getParameter<std::string>(
+        const std::string& key) const;
 
-        copy = attributes[key]->copyListeners();
+std::ostream& operator<<(std::ostream& out, const Configuration& config) {
+    LockHolder lh(config.mutex);
+    for (const auto& attribute : config.attributes) {
+        std::stringstream line;
+        line << std::boolalpha << attribute.first.c_str() << " = ["
+             << attribute.second->value << "]" << std::endl;
+        out << line.str();
     }
 
-    for (auto* listener : copy) {
-        listener->stringValueChanged(key, value);
-    }
+    return out;
 }
 
 void Configuration::addAlias(const std::string& key, const std::string& alias) {
@@ -317,29 +174,7 @@ void Configuration::addStats(ADD_STAT add_stat, const void *c) const {
     LockHolder lh(mutex);
     for (const auto& attribute :  attributes) {
         std::stringstream value;
-        switch (attribute.second->datatype) {
-        case DT_BOOL:
-            value << std::boolalpha << attribute.second->val.v_bool
-                  << std::noboolalpha;
-            break;
-        case DT_STRING:
-            value << attribute.second->val.v_string;
-            break;
-        case DT_SIZE:
-            value << attribute.second->val.v_size;
-            break;
-        case DT_SSIZE:
-            value << attribute.second->val.v_ssize;
-            break;
-        case DT_FLOAT:
-            value << attribute.second->val.v_float;
-            break;
-        case DT_CONFIGFILE:
-        default:
-            // ignore
-            ;
-        }
-
+        value << std::boolalpha << attribute.second->value;
         std::stringstream key;
         key << "ep_" << attribute.first;
         std::string k = key.str();
@@ -369,7 +204,8 @@ bool Configuration::parseConfiguration(const char *str,
 
     for (const auto& attribute : attributes) {
         config.push_back(std::make_unique<ConfigItem>(
-                attribute.first.c_str(), attribute.second->datatype));
+                attribute.first.c_str(),
+                config_datatype(attribute.second->value.which())));
     }
 
     // And add support for config files...
@@ -389,7 +225,9 @@ bool Configuration::parseConfiguration(const char *str,
             if (ret) {
                 switch (items[ii].datatype) {
                 case DT_STRING:
-                    setParameter(items[ii].key, *(items[ii].value.dt_string));
+                    setParameter(items[ii].key,
+                                 const_cast<const char*>(
+                                         *(items[ii].value.dt_string)));
                     break;
                 case DT_SIZE:
                     setParameter(items[ii].key, *items[ii].value.dt_size);
index 053458e..730e875 100644 (file)
 
 #include <memcached/engine.h>
 
-#include <algorithm>
 #include <iostream>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
-#include <unordered_set>
-#include <vector>
 
 #include "locks.h"
 #include "utility.h"
  */
 class ValueChangedListener {
 public:
+    void valueChanged(const std::string& key, bool value) {
+        booleanValueChanged(key, value);
+    }
+
+    void valueChanged(const std::string& key, size_t value) {
+        sizeValueChanged(key, value);
+    }
+
+    void valueChanged(const std::string& key, ssize_t value) {
+        ssizeValueChanged(key, value);
+    }
+
+    void valueChanged(const std::string& key, float value) {
+        floatValueChanged(key, value);
+    }
+
+    void valueChanged(const std::string& key, std::string value) {
+        stringValueChanged(key, value.c_str());
+    }
+
+    void valueChanged(const std::string& key, const char* value) {
+        stringValueChanged(key, value);
+    }
+
     /**
      * Callback if when a boolean configuration value changed
      * @param key the key who changed
@@ -102,6 +123,29 @@ public:
  */
 class ValueChangedValidator {
 public:
+    void validate(const std::string& key, bool value) {
+        validateBool(key, value);
+    }
+
+    void validate(const std::string& key, size_t value) {
+        validateSize(key, value);
+    }
+
+    void validate(const std::string& key, ssize_t value) {
+        validateSSize(key, value);
+    }
+
+    void validate(const std::string& key, float value) {
+        validateFloat(key, value);
+    }
+
+    void validate(const std::string& key, const char* value) {
+        validateString(key, value);
+    }
+    void validate(const std::string& key, std::string value) {
+        validateString(key, value.c_str());
+    }
+
     /**
      * Validator for boolean values
      * @param key the key that is about to change
@@ -385,52 +429,13 @@ public:
 protected:
     /**
      * Set the configuration parameter for a given key to
-     * a boolean value.
-     * @param key the key to specify
-     * @param value the new value
-     * @throws runtime_error if the validation failed
-     */
-    void setParameter(const std::string &key, bool value);
-    /**
-     * Set the configuration parameter for a given key to
-     * a size_t value.
-     * @param key the key to specify
-     * @param value the new value
-     * @throws runtime_error if the validation failed
-     */
-    void setParameter(const std::string &key, size_t value);
-    /**
-     * Set the configuration parameter for a given key to
-     * a ssize_t value.
-     * @param key the key to specify
-     * @param value the new value
-     * @throws runtime_error if the validation failed
-     */
-    void setParameter(const std::string &key, ssize_t value);
-    /**
-     * Set the configuration parameter for a given key to
-     * a floating value.
-     * @param key the key to specify
-     * @param value the new value
-     * @throws runtime_error if the validation failed
-     */
-    void setParameter(const std::string &key, float value);
-    /**
-     * Set the configuration parameter for a given key to
-     * a character string
-     * @param key the key to specify
-     * @param value the new value
-     * @throws runtime_error if the validation failed
-     */
-    void setParameter(const std::string &key, const char *value);
-    /**
-     * Set the configuration parameter for a given key to
-     * a string.
+     * a new value (size_t, ssize_t, float, bool, string)
      * @param key the key to specify
      * @param value the new value
      * @throws runtime_error if the validation failed
      */
-    void setParameter(const std::string &key, const std::string &value);
+    template <class T>
+    void setParameter(const std::string& key, T value);
 
     /**
      * Get the configuration parameter for a given key
@@ -438,73 +443,12 @@ protected:
      * @return value the value
      * @throws runtime_error if the validation failed
      */
-    bool getBool(const std::string& key) const;
-
-    /**
-     * Get the configuration parameter for a given key
-     * @param key the key to specify
-     * @return value the value
-     */
-    size_t getInteger(const std::string& key) const;
-
-    /**
-     * Get the configuration parameter for a given key
-     * @param key the key to specify
-     * @return value the value
-     */
-    ssize_t getSignedInteger(const std::string& key) const;
-
-    /**
-     * Get the configuration parameter for a given key
-     * @param key the key to specify
-     * @return value the value
-     */
-    float getFloat(const std::string& key) const;
-
-    /**
-     * Get the configuration parameter for a given key
-     * @param key the key to specify
-     * @return value the value
-     */
-    std::string getString(const std::string& key) const;
+    template <class T>
+    T getParameter(const std::string& key) const;
 
 private:
     void initialize();
-
-    struct value_t {
-        value_t() {
-            val.v_string = 0;
-        }
-        std::vector<std::unique_ptr<ValueChangedListener>> changeListener;
-        std::unique_ptr<ValueChangedValidator> validator;
-        config_datatype datatype;
-        union {
-            size_t v_size;
-            ssize_t v_ssize;
-            float v_float;
-            bool v_bool;
-            const char *v_string;
-        } val;
-
-        std::vector<ValueChangedListener*> copyListeners() {
-            std::vector<ValueChangedListener*> copy;
-
-            std::transform(changeListener.begin(),
-                           changeListener.end(),
-                           std::back_inserter(copy),
-                           [](std::unique_ptr<ValueChangedListener>& listener)
-                                   -> ValueChangedListener* {
-                               return listener.get();
-                           });
-            return copy;
-        }
-
-        ~value_t() {
-            if (datatype == DT_STRING) {
-                cb_free((void*)val.v_string);
-            }
-        }
-    };
+    struct value_t;
 
     // Access to the configuration variables is protected by the mutex
     mutable std::mutex mutex;
@@ -514,4 +458,10 @@ private:
                                      const Configuration &config);
 };
 
+// This specialisation is needed to convert char* to std::string to store in
+// the variant.
+template <>
+void Configuration::setParameter<const char*>(const std::string& key,
+                                              const char* value);
+
 #endif  // SRC_CONFIGURATION_H_
index 067ccab..3dae2ef 100644 (file)
@@ -282,82 +282,46 @@ class ConfigurationShim : public Configuration {
      */
 
 public:
-
-    void usetParameter(const std::string &key, bool value) {
-        setParameter(key, value);
-    }
-    void usetParameter(const std::string &key, size_t value) {
-        setParameter(key, value);
-    }
-    void usetParameter(const std::string &key, ssize_t value) {
-        setParameter(key, value);
-    }
-    void usetParameter(const std::string &key, float value) {
-        setParameter(key, value);
-    }
-    void usetParameter(const std::string &key, const char *value) {
-        setParameter(key, value);
-    }
-    void usetParameter(const std::string &key, const std::string &value) {
-        setParameter(key, value);
-    }
-
-    bool ugetBool(const std::string &key) const {
-        return getBool(key);
-    }
-    size_t ugetInteger(const std::string &key) const {
-        return getInteger(key);
-    }
-
-    ssize_t ugetSignedInteger(const std::string &key) const {
-        return getSignedInteger(key);
-    }
-    float ugetFloat(const std::string &key) const {
-        return getFloat(key);
-    }
-    std::string ugetString(const std::string &key) const {
-        return getString(key);
-    }
+    using Configuration::setParameter;
+    using Configuration::getParameter;
 };
 
 TEST(ConfigurationTest, SetGetWorks) {
     ConfigurationShim configuration;
 
-    configuration.usetParameter("bool", false);
-    EXPECT_EQ(configuration.ugetBool("bool"), false);
+    configuration.setParameter("bool", false);
+    EXPECT_EQ(configuration.getParameter<bool>("bool"), false);
 
-    configuration.usetParameter("size", (size_t) 100);
-    EXPECT_EQ(configuration.ugetInteger("size"), 100);
+    configuration.setParameter("size", (size_t)100);
+    EXPECT_EQ(configuration.getParameter<size_t>("size"), 100);
 
-    configuration.usetParameter("ssize", (ssize_t) -100);
-    EXPECT_EQ(configuration.ugetSignedInteger("ssize"), -100);
+    configuration.setParameter("ssize", (ssize_t)-100);
+    EXPECT_EQ(configuration.getParameter<ssize_t>("ssize"), -100);
 
-    configuration.usetParameter("float", (float) 123.5);
-    EXPECT_EQ(configuration.ugetFloat("float"), 123.5);
+    configuration.setParameter("float", (float)123.5);
+    EXPECT_EQ(configuration.getParameter<float>("float"), 123.5);
 
-    configuration.usetParameter("char*", "hello");
-    EXPECT_EQ(configuration.ugetString("char*"), "hello");
+    configuration.setParameter("char*", "hello");
+    EXPECT_EQ(configuration.getParameter<std::string>("char*"), "hello");
 
-    configuration.usetParameter("string", std::string("hello"));
-    EXPECT_EQ(configuration.ugetString("string"), "hello");
+    configuration.setParameter("string", std::string("hello"));
+    EXPECT_EQ(configuration.getParameter<std::string>("string"), "hello");
 }
 
 TEST(ConfigurationTest, ValidatorWorks) {
     ConfigurationShim configuration;
     std::string key{"test_key"};
 
-    configuration.usetParameter(key, (size_t) 110);
+    configuration.setParameter(key, (size_t)110);
     EXPECT_NO_THROW(configuration.setValueValidator(key, (new SizeRangeValidator())->min(10)->max(100)));
-    EXPECT_NO_THROW(configuration.usetParameter(key, (size_t) 10));
-    EXPECT_NO_THROW(configuration.usetParameter(key, (size_t) 100));
-    EXPECT_THROW(configuration.usetParameter(key, (size_t) 9), std::range_error);
-
-    CB_EXPECT_THROW_MSG(
-            configuration.usetParameter(key, (size_t) 9),
-            std::range_error,
-            "Validation Error, test_key takes values between 10 and 100 (Got: 9)"
-    );
-
+    EXPECT_NO_THROW(configuration.setParameter(key, (size_t)10));
+    EXPECT_NO_THROW(configuration.setParameter(key, (size_t)100));
+    EXPECT_THROW(configuration.setParameter(key, (size_t)9), std::range_error);
+
+    CB_EXPECT_THROW_MSG(configuration.setParameter(key, (size_t)9),
+                        std::range_error,
+                        "Validation Error, test_key takes values between 10 "
+                        "and 100 (Got: 9)");
 }
 
 class MockValueChangedListener : public ValueChangedListener {
@@ -384,7 +348,7 @@ TEST(ChangeListenerTest, ChangeListenerSSizeRegression) {
     // Create listeners
     auto mvcl = new MockValueChangedListener;
     // set parameter once so entry in attributes is present to add a listener
-    configuration.usetParameter(key, (ssize_t)1);
+    configuration.setParameter(key, (ssize_t)1);
 
     EXPECT_CALL(*mvcl, ssizeValueChanged("test_key", 2)).Times(1);
     EXPECT_CALL(*mvcl, sizeValueChanged(_, _)).Times(0);
@@ -393,5 +357,5 @@ TEST(ChangeListenerTest, ChangeListenerSSizeRegression) {
     configuration.addValueChangedListener(key, mvcl);
 
     // change parameters
-    configuration.usetParameter(key, (ssize_t)2);
+    configuration.setParameter(key, (ssize_t)2);
 }
\ No newline at end of file
index caae142..0d4be30 100644 (file)
@@ -41,7 +41,6 @@ stringstream implementation;
 typedef string (*getValidatorCode)(const std::string &, cJSON*);
 
 std::map<string, getValidatorCode> validators;
-map<string, string> getters;
 map<string, string> datatypes;
 
 static string getDatatype(const std::string& key, cJSON* o);
@@ -221,11 +220,6 @@ static void initialize() {
         << "#include <platform/sysinfo.h>" << endl;
     validators["range"] = getRangeValidatorCode;
     validators["enum"] = getEnumValidatorCode;
-    getters["std::string"] = "getString";
-    getters["bool"] = "getBool";
-    getters["size_t"] = "getInteger";
-    getters["ssize_t"] = "getSignedInteger";
-    getters["float"] = "getFloat";
     datatypes["bool"] = "bool";
     datatypes["size_t"] = "size_t";
     datatypes["ssize_t"] = "ssize_t";
@@ -402,8 +396,10 @@ static void generate(cJSON *o) {
     // Generate the getter
     implementation << type << " Configuration::" << getGetterPrefix(type)
                    << cppname << "() const {" << endl
-                   << "    return " << getters[type] << "(\""
-                   << config_name << "\");" << endl << "}" << endl;
+                   << "    return "
+                   << "getParameter<" << datatypes[type] << ">(\""
+                   << config_name << "\");" << endl
+                   << "}" << endl;
 
     if  (!isReadOnly(o)) {
         // generate the setter