Streamline configuration.h 75/76475/13
authorJames Harrison <00jamesh@gmail.com>
Fri, 7 Apr 2017 13:08:18 +0000 (14:08 +0100)
committerDave Rigby <daver@couchbase.com>
Thu, 20 Apr 2017 16:36:12 +0000 (16:36 +0000)
Move more out of configuration.h into configuration_impl.h as
configuration.h is large and included in a number of places.

Change-Id: I099ab79253372675f70d677c13e73a2d9c59d74f
Reviewed-on: http://review.couchbase.org/76475
Reviewed-by: David Haikney <david.haikney@couchbase.com>
Reviewed-by: Dave Rigby <daver@couchbase.com>
Tested-by: Build Bot <build@couchbase.com>
src/configuration.cc
src/configuration.h
src/configuration_impl.h
src/executorpool.h
src/mutation_log.h
tests/module_tests/configuration_test.cc
tools/genconfig.cc

index 7f94dfd..3db442c 100644 (file)
@@ -20,6 +20,8 @@
 
 #include "configuration_impl.h"
 
+#include "locks.h"
+
 #ifdef AUTOCONF_BUILD
 #include "generated_configuration.cc"
 #endif
index 9bd61c5..a94b514 100644 (file)
 #include <memcached/engine.h>
 
 #include <iostream>
-#include <limits>
 #include <map>
-#include <set>
+#include <mutex>
 #include <string>
 
-#include "locks.h"
 #include "utility.h"
 
 /**
@@ -214,153 +212,6 @@ public:
     virtual ~ValueChangedValidator() { }
 };
 
-/**
- * A configuration input validator that ensures a numeric (size_t)
- * value falls between a specified upper and lower limit.
- */
-class SizeRangeValidator : public ValueChangedValidator {
-public:
-    SizeRangeValidator() : lower(0), upper(0) {}
-
-    SizeRangeValidator *min(size_t v) {
-        lower = v;
-        return this;
-    }
-
-    SizeRangeValidator *max(size_t v) {
-        upper = v;
-        return this;
-    }
-
-    virtual void validateSize(const std::string& key, size_t value) {
-        if (value < lower || value > upper) {
-            std::string error = "Validation Error, " + key +
-                                " takes values between " +
-                                std::to_string(lower) + " and " +
-                                std::to_string(upper) + " (Got: " +
-                                std::to_string(value) + ")";
-            throw std::range_error(error);
-        }
-    }
-
-    virtual void validateSSize(const std::string& key, ssize_t value) {
-        ssize_t s_lower = static_cast<ssize_t> (lower);
-        ssize_t s_upper = static_cast<ssize_t> (upper);
-
-        if (value < s_lower || value > s_upper) {
-            std::string error = "Validation Error, " + key +
-                                " takes values between " +
-                                std::to_string(s_lower) + " and " +
-                                std::to_string(s_upper) + " (Got: " +
-                                std::to_string(value) + ")";
-            throw std::range_error(error);
-        }
-    }
-private:
-    size_t lower;
-    size_t upper;
-};
-
-/**
- * A configuration input validator that ensures a signed numeric (ssize_t)
- * value falls between a specified upper and lower limit.
- */
-class SSizeRangeValidator : public ValueChangedValidator {
-public:
-    SSizeRangeValidator() : lower(0), upper(0) {}
-
-    SSizeRangeValidator* min(size_t v) {
-        lower = v;
-        return this;
-    }
-
-    SSizeRangeValidator* max(size_t v) {
-        upper = v;
-        return this;
-    }
-
-    virtual void validateSSize(const std::string& key, ssize_t value) {
-        if (value < lower || value > upper) {
-            std::string error = "Validation Error, " + key +
-                                " takes values between " +
-                                std::to_string(lower) + " and " +
-                                std::to_string(upper) + " (Got: " +
-                                std::to_string(value) + ")";
-            throw std::range_error(error);
-        }
-    }
-private:
-    ssize_t lower;
-    ssize_t upper;
-};
-
-/**
- * A configuration input validator that ensures that a numeric (float)
- * value falls between a specified upper and lower limit.
- */
-class FloatRangeValidator : public ValueChangedValidator {
-public:
-    FloatRangeValidator() : lower(0), upper(0) {}
-
-    FloatRangeValidator *min(float v) {
-        lower = v;
-        return this;
-    }
-
-    FloatRangeValidator *max(float v) {
-        upper = v;
-        return this;
-    }
-
-    virtual void validateFloat(const std::string& key, float value) {
-        if (value < lower || value > upper) {
-            std::string error = "Validation Error, " + key +
-                                " takes values between " +
-                                std::to_string(lower) + " and " +
-                                std::to_string(upper) + " (Got: " +
-                                std::to_string(value) + ")";
-            throw std::range_error(error);
-        }
-    }
-private:
-    float lower;
-    float upper;
-};
-
-/**
- * A configuration input validator that ensures that a value is one
- * from a predefined set of acceptable values.
- */
-class EnumValidator : public ValueChangedValidator {
-public:
-    EnumValidator() {}
-
-    EnumValidator *add(const char *s) {
-        acceptable.insert(std::string(s));
-        return this;
-    }
-
-    virtual void validateString(const std::string& key, const char* value) {
-        if (acceptable.find(std::string(value)) == acceptable.end()) {
-            std::string error = "Validation Error, " + key +
-                                " takes one of [";
-            for (const auto& it : acceptable) {
-                error += it + ", ";
-            }
-            if (acceptable.size() > 0) {
-                error.pop_back();
-                error.pop_back();
-            }
-
-            error += "] (Got: " + std::string(value) + ")";
-            throw std::range_error(error);
-        }
-    }
-
-private:
-    std::set<std::string> acceptable;
-};
-
 class Requirement;
 
 /**
index 6359cc4..5282d45 100644 (file)
 
 #pragma once
 
+#include "configuration.h"
+
 #include <boost/variant.hpp>
 
+#include <set>
 #include <string>
 #include <vector>
 
@@ -37,6 +40,152 @@ public:
     }
 };
 
+/** A configuration input validator that ensures a numeric (size_t)
+ * value falls between a specified upper and lower limit.
+ */
+class SizeRangeValidator : public ValueChangedValidator {
+public:
+    SizeRangeValidator() : lower(0), upper(0) {}
+
+    SizeRangeValidator *min(size_t v) {
+        lower = v;
+        return this;
+    }
+
+    SizeRangeValidator *max(size_t v) {
+        upper = v;
+        return this;
+    }
+
+    virtual void validateSize(const std::string& key, size_t value) {
+        if (value < lower || value > upper) {
+            std::string error = "Validation Error, " + key +
+                                " takes values between " +
+                                std::to_string(lower) + " and " +
+                                std::to_string(upper) + " (Got: " +
+                                std::to_string(value) + ")";
+            throw std::range_error(error);
+        }
+    }
+
+    virtual void validateSSize(const std::string& key, ssize_t value) {
+        ssize_t s_lower = static_cast<ssize_t> (lower);
+        ssize_t s_upper = static_cast<ssize_t> (upper);
+
+        if (value < s_lower || value > s_upper) {
+            std::string error = "Validation Error, " + key +
+                                " takes values between " +
+                                std::to_string(s_lower) + " and " +
+                                std::to_string(s_upper) + " (Got: " +
+                                std::to_string(value) + ")";
+            throw std::range_error(error);
+        }
+    }
+private:
+    size_t lower;
+    size_t upper;
+};
+
+/**
+ * A configuration input validator that ensures a signed numeric (ssize_t)
+ * value falls between a specified upper and lower limit.
+ */
+class SSizeRangeValidator : public ValueChangedValidator {
+public:
+    SSizeRangeValidator() : lower(0), upper(0) {}
+
+    SSizeRangeValidator* min(size_t v) {
+        lower = v;
+        return this;
+    }
+
+    SSizeRangeValidator* max(size_t v) {
+        upper = v;
+        return this;
+    }
+
+    virtual void validateSSize(const std::string& key, ssize_t value) {
+        if (value < lower || value > upper) {
+            std::string error = "Validation Error, " + key +
+                                " takes values between " +
+                                std::to_string(lower) + " and " +
+                                std::to_string(upper) + " (Got: " +
+                                std::to_string(value) + ")";
+            throw std::range_error(error);
+        }
+    }
+private:
+    ssize_t lower;
+    ssize_t upper;
+};
+
+/**
+ * A configuration input validator that ensures that a numeric (float)
+ * value falls between a specified upper and lower limit.
+ */
+class FloatRangeValidator : public ValueChangedValidator {
+public:
+    FloatRangeValidator() : lower(0), upper(0) {}
+
+    FloatRangeValidator *min(float v) {
+        lower = v;
+        return this;
+    }
+
+    FloatRangeValidator *max(float v) {
+        upper = v;
+        return this;
+    }
+
+    virtual void validateFloat(const std::string& key, float value) {
+        if (value < lower || value > upper) {
+            std::string error = "Validation Error, " + key +
+                                " takes values between " +
+                                std::to_string(lower) + " and " +
+                                std::to_string(upper) + " (Got: " +
+                                std::to_string(value) + ")";
+            throw std::range_error(error);
+        }
+    }
+private:
+    float lower;
+    float upper;
+};
+
+/**
+ * A configuration input validator that ensures that a value is one
+ * from a predefined set of acceptable values.
+ */
+class EnumValidator : public ValueChangedValidator {
+public:
+    EnumValidator() {}
+
+    EnumValidator *add(const char *s) {
+        acceptable.insert(std::string(s));
+        return this;
+    }
+
+    virtual void validateString(const std::string& key, const char* value) {
+        if (acceptable.find(std::string(value)) == acceptable.end()) {
+            std::string error = "Validation Error, " + key +
+                                " takes one of [";
+            for (const auto& it : acceptable) {
+                error += it + ", ";
+            }
+            if (acceptable.size() > 0) {
+                error.pop_back();
+                error.pop_back();
+            }
+
+            error += "] (Got: " + std::string(value) + ")";
+            throw std::range_error(error);
+        }
+    }
+
+private:
+    std::set<std::string> acceptable;
+};
+
 class Requirement {
 public:
     Requirement* add(const std::string& key, value_variant_t value) {
index 9e196a9..f5c228c 100644 (file)
@@ -73,6 +73,7 @@
 #include "taskable.h"
 
 #include <map>
+#include <set>
 
 // Forward decl
 class TaskQueue;
index 74d774a..fb7fc84 100644 (file)
@@ -45,6 +45,7 @@
 #include <array>
 #include <cstring>
 #include <memory>
+#include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
index 3dae2ef..fb88567 100644 (file)
@@ -17,6 +17,8 @@
 
 #include "configuration.h"
 
+#include "configuration_impl.h"
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
index 45b2498..fd52af0 100644 (file)
@@ -218,7 +218,8 @@ static void initialize() {
         << "#include \"config.h\"" << endl
         << "#include \"configuration.h\"" << endl
         << "#include \"configuration_impl.h\"" << endl
-        << "#include <platform/sysinfo.h>" << endl;
+        << "#include <platform/sysinfo.h>" << endl
+        << "#include <limits>" << endl;
     validators["range"] = getRangeValidatorCode;
     validators["enum"] = getEnumValidatorCode;
     datatypes["bool"] = "bool";