- Generate mode modern c++ code.

- Use existing predefined types.
- Allow for better management by allowing large string vectors to be mmapped.

21 files changed, 176 insertions, 132 deletions

diff --git a/config/src/tests/configagent/configagent.cpp b/config/src/tests/configagent/configagent.cpp
index 4843b2f0647..10f321c181d 100644
--- a/config/src/tests/configagent/configagent.cpp
+++ b/config/src/tests/configagent/configagent.cpp
@@ -114,7 +114,7 @@ private:
 
 ConfigValue createValue(const std::string & myField, const std::string & xxhash64)
 {
-    std::vector< vespalib::string > lines;
+    StringVector lines;
     lines.push_back("myField \"" + myField + "\"");
     return ConfigValue(lines, xxhash64);
 }
diff --git a/config/src/tests/configgen/map_inserter.cpp b/config/src/tests/configgen/map_inserter.cpp
index 2a37d401792..bf1b856972e 100644
--- a/config/src/tests/configgen/map_inserter.cpp
+++ b/config/src/tests/configgen/map_inserter.cpp
@@ -1,8 +1,8 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/vespalib/testkit/test_kit.h>
-#include <vespa/config/configgen/map_inserter.h>
 #include <vespa/vespalib/data/slime/slime.h>
+#include <vespa/config/configgen/map_inserter.hpp>
 
 using namespace config;
 using namespace config::internal;
diff --git a/config/src/tests/configgen/vector_inserter.cpp b/config/src/tests/configgen/vector_inserter.cpp
index b8611317650..e2b0d7c875f 100644
--- a/config/src/tests/configgen/vector_inserter.cpp
+++ b/config/src/tests/configgen/vector_inserter.cpp
@@ -1,7 +1,8 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/vespalib/testkit/test_kit.h>
-#include <vespa/config/configgen/vector_inserter.h>
+#include <vespa/config/common/types.h>
+#include <vespa/config/configgen/vector_inserter.hpp>
 #include <vespa/vespalib/data/slime/slime.h>
 
 using namespace config;
@@ -27,7 +28,7 @@ TEST("require that vector of ints can be inserted") {
     root.addLong(3);
     root.addLong(2);
     root.addLong(6);
-    VectorInserter<int32_t> inserter(vector);
+    VectorInserter inserter(vector);
     root.traverse(inserter);
     ASSERT_EQUAL(3u, vector.size());
     ASSERT_EQUAL(3, vector[0]);
@@ -45,7 +46,7 @@ TEST("require that vector of struct can be inserted") {
     Cursor & two = root.addObject();
     two.setLong("foo", 1);
     two.setLong("bar", 6);
-    VectorInserter<MyType> inserter(typeVector);
+    VectorInserter inserter(typeVector);
     root.traverse(inserter);
     ASSERT_EQUAL(2u, typeVector.size());
     ASSERT_EQUAL(3, typeVector[0].foo);
@@ -61,7 +62,7 @@ TEST("require that vector of long can be inserted") {
     root.addLong(3);
     root.addLong(2);
     root.addLong(6);
-    VectorInserter<int64_t> inserter(vector);
+    VectorInserter inserter(vector);
     root.traverse(inserter);
     ASSERT_EQUAL(3u, vector.size());
     ASSERT_EQUAL(3, vector[0]);
@@ -76,7 +77,7 @@ TEST("require that vector of double can be inserted") {
     root.addDouble(3.1);
     root.addDouble(2.4);
     root.addDouble(6.6);
-    VectorInserter<double> inserter(vector);
+    VectorInserter inserter(vector);
     root.traverse(inserter);
     ASSERT_EQUAL(3u, vector.size());
     ASSERT_EQUAL(3.1, vector[0]);
@@ -91,7 +92,7 @@ TEST("require that vector of bool can be inserted") {
     root.addBool(true);
     root.addBool(false);
     root.addBool(true);
-    VectorInserter<bool> inserter(vector);
+    VectorInserter inserter(vector);
     root.traverse(inserter);
     ASSERT_EQUAL(3u, vector.size());
     ASSERT_TRUE(vector[0]);
@@ -106,7 +107,22 @@ TEST("require that vector of string can be inserted") {
     root.addString("foo");
     root.addString("bar");
     root.addString("baz");
-    VectorInserter<vespalib::string> inserter(vector);
+    VectorInserter inserter(vector);
+    root.traverse(inserter);
+    ASSERT_EQUAL(3u, vector.size());
+    ASSERT_EQUAL("foo", vector[0]);
+    ASSERT_EQUAL("bar", vector[1]);
+    ASSERT_EQUAL("baz", vector[2]);
+}
+
+TEST("require that vector of string can be inserted") {
+    StringVector vector;
+    Slime slime;
+    Cursor & root = slime.setArray();
+    root.addString("foo");
+    root.addString("bar");
+    root.addString("baz");
+    VectorInserter inserter(vector);
     root.traverse(inserter);
     ASSERT_EQUAL(3u, vector.size());
     ASSERT_EQUAL("foo", vector[0]);
diff --git a/config/src/tests/configmanager/configmanager.cpp b/config/src/tests/configmanager/configmanager.cpp
index 9bed974f628..a7171b11137 100644
--- a/config/src/tests/configmanager/configmanager.cpp
+++ b/config/src/tests/configmanager/configmanager.cpp
@@ -17,7 +17,7 @@ namespace {
 
     ConfigValue createValue(const std::string & myField, const std::string & md5)
     {
-        std::vector< vespalib::string > lines;
+        StringVector lines;
         lines.push_back("myField \"" + myField + "\"");
         return ConfigValue(lines, md5);
     }
diff --git a/config/src/tests/configparser/configparser.cpp b/config/src/tests/configparser/configparser.cpp
index 3e569a2d3fb..32043ae79dc 100644
--- a/config/src/tests/configparser/configparser.cpp
+++ b/config/src/tests/configparser/configparser.cpp
@@ -3,6 +3,7 @@
 #include <vespa/config/common/configparser.h>
 #include <vespa/config/common/exceptions.h>
 #include <vespa/config/common/configvalue.h>
+#include <vespa/config/common/misc.h>
 #include "config-foo.h"
 #include <fstream>
 #include <vespa/vespalib/stllike/asciistream.h>
@@ -23,7 +24,7 @@ namespace {
     ConfigValue readConfig(const vespalib::string & fileName)
     {
         asciistream is(asciistream::createFromFile(fileName));
-        return ConfigValue(is.getlines(), "");
+        return ConfigValue(getlines(is), "");
     }
 }
 
diff --git a/config/src/vespa/config/common/configparser.cpp b/config/src/vespa/config/common/configparser.cpp
index 3e18d6ae4e7..97373071ed5 100644
--- a/config/src/vespa/config/common/configparser.cpp
+++ b/config/src/vespa/config/common/configparser.cpp
@@ -124,10 +124,9 @@ getValueForKey(vespalib::stringref key, vespalib::stringref line,
 }
 
 StringVector
-ConfigParser::getLinesForKey(vespalib::stringref key,
-                             const vsvector & lines)
+ConfigParser::getLinesForKey(vespalib::stringref key, Cfg lines)
 {
-    vsvector retval;
+    StringVector retval;
 
     for (uint32_t i = 0; i < lines.size(); i++) {
         vespalib::string value;
@@ -140,6 +139,18 @@ ConfigParser::getLinesForKey(vespalib::stringref key,
     return retval;
 }
 
+std::set<vespalib::string>
+ConfigParser::getUniqueNonWhiteSpaceLines(Cfg config) {
+    std::set<vespalib::string> unique;
+    for (uint32_t i = 0; i < config.size(); i++) {
+        vespalib::string line = stripWhitespace(config[i]);
+        if (!line.empty()) {
+            unique.insert(line);
+        }
+    }
+    return unique;
+}
+
 void
 ConfigParser::stripLinesForKey(vespalib::stringref key,
                                std::set<vespalib::string>& config)
@@ -155,10 +166,10 @@ ConfigParser::stripLinesForKey(vespalib::stringref key,
     }
 }
 
-std::map<vespalib::string, ConfigParser::vsvector>
-ConfigParser::splitMap(const vsvector & config)
+std::map<vespalib::string, StringVector>
+ConfigParser::splitMap(Cfg config)
 {
-    std::map<vespalib::string, vsvector> items;
+    std::map<vespalib::string, StringVector> items;
 
     vespalib::string lastValue;
 
@@ -178,7 +189,7 @@ ConfigParser::splitMap(const vsvector & config)
         vespalib::string value = config[i].substr(pos + 1);
 
         if (key != lastValue) {
-            items[key] = vsvector();
+            items[key] = StringVector();
             lastValue = key;
         }
 
@@ -191,10 +202,10 @@ ConfigParser::splitMap(const vsvector & config)
     return items;
 }
 
-std::vector<ConfigParser::vsvector>
-ConfigParser::splitArray(const vsvector & config)
+std::vector<StringVector>
+ConfigParser::splitArray(Cfg config)
 {
-    std::vector<vsvector> items;
+    std::vector<StringVector> items;
 
     vespalib::string lastValue;
 
@@ -214,7 +225,7 @@ ConfigParser::splitArray(const vsvector & config)
         vespalib::string value = config[i].substr(pos + 1);
 
         if (key != lastValue) {
-            items.push_back(vsvector());
+            items.push_back(StringVector());
             lastValue = key;
         }
 
@@ -266,7 +277,7 @@ ConfigParser::stripWhitespace(vespalib::stringref source)
 }
 
 vespalib::string
-ConfigParser::arrayToString(const vsvector & array)
+ConfigParser::arrayToString(Cfg array)
 {
     vespalib::asciistream ost;
     if (array.size() == 0) {
@@ -281,13 +292,13 @@ ConfigParser::arrayToString(const vsvector & array)
 
 template<>
 bool
-ConfigParser::convert<bool>(const vsvector & config)
+ConfigParser::convert<bool>(const StringVector & config)
 {
     if (config.size() != 1) {
         throw InvalidConfigException("Expected single line with bool value, "
                 "got " + arrayToString(config), VESPA_STRLOC);
     }
-    std::string value = stripWhitespace(deQuote(config[0]));
+    vespalib::string value = stripWhitespace(deQuote(config[0]));
 
     if (value == "true") {
         return true;
@@ -301,13 +312,13 @@ ConfigParser::convert<bool>(const vsvector & config)
 
 template<>
 int32_t
-ConfigParser::convert<int32_t>(const vsvector & config)
+ConfigParser::convert<int32_t>(const StringVector & config)
 {
     if (config.size() != 1) {
         throw InvalidConfigException("Expected single line with int32_t value, "
                 "got " + arrayToString(config), VESPA_STRLOC);
     }
-    std::string value(deQuote(stripWhitespace(config[0])));
+    vespalib::string value(deQuote(stripWhitespace(config[0])));
 
     const char *startp = value.c_str();
     char *endp;
@@ -321,13 +332,13 @@ ConfigParser::convert<int32_t>(const vsvector & config)
 
 template<>
 int64_t
-ConfigParser::convert<int64_t>(const vsvector & config)
+ConfigParser::convert<int64_t>(const StringVector & config)
 {
     if (config.size() != 1) {
         throw InvalidConfigException("Expected single line with int64_t value, "
                 "got " + arrayToString(config), VESPA_STRLOC);
     }
-    std::string value(deQuote(stripWhitespace(config[0])));
+    vespalib::string value(deQuote(stripWhitespace(config[0])));
 
     const char *startp = value.c_str();
     char *endp;
@@ -341,13 +352,13 @@ ConfigParser::convert<int64_t>(const vsvector & config)
 
 template<>
 double
-ConfigParser::convert<double>(const vsvector & config)
+ConfigParser::convert<double>(const StringVector & config)
 {
     if (config.size() != 1) {
         throw InvalidConfigException("Expected single line with double value, "
                 "got " + arrayToString(config), VESPA_STRLOC);
     }
-    std::string value(deQuote(stripWhitespace(config[0])));
+    vespalib::string value(deQuote(stripWhitespace(config[0])));
 
     const char *startp = value.c_str();
     char *endp;
@@ -362,14 +373,14 @@ ConfigParser::convert<double>(const vsvector & config)
 
 template<>
 vespalib::string
-ConfigParser::convert<vespalib::string>(const vsvector & config)
+ConfigParser::convert<vespalib::string>(const StringVector & config)
 {
     if (config.size() != 1) {
         throw InvalidConfigException("Expected single line with string value, "
                 "got " + arrayToString(config), VESPA_STRLOC);
     }
 
-    std::string value = stripWhitespace(config[0]);
+    vespalib::string value = stripWhitespace(config[0]);
 
     return deQuote(value);
 }
diff --git a/config/src/vespa/config/common/configparser.h b/config/src/vespa/config/common/configparser.h
index dc89930c23e..42ee684eb59 100644
--- a/config/src/vespa/config/common/configparser.h
+++ b/config/src/vespa/config/common/configparser.h
@@ -14,69 +14,83 @@ namespace config {
  */
 class ConfigParser {
 public:
-    using vsvector = StringVector;
+    class Cfg {
+    public:
+        Cfg(const std::vector<vespalib::string> & v)
+            : _cfg(&v[0]), _sz(v.size())
+        { }
+        Cfg(const std::vector<vespalib::string, vespalib::allocator_large<vespalib::string>> & v) :
+            _cfg(&v[0]),
+            _sz(v.size())
+        { }
+        size_t size() const { return _sz; }
+        const vespalib::string & operator[] (size_t idx) const { return _cfg[idx]; }
+    private:
+        const vespalib::string * _cfg;
+        size_t                   _sz;
+    };
 private:
-    static vsvector getLinesForKey(vespalib::stringref key, const vsvector & config);
+    static StringVector getLinesForKey(vespalib::stringref key, Cfg config);
 
-    static std::vector<vsvector> splitArray( const vsvector & config);
-    static std::map<vespalib::string, vsvector> splitMap( const vsvector & config);
+    static std::vector<StringVector> splitArray(Cfg config);
+    static std::map<vespalib::string, StringVector> splitMap(Cfg config);
 
     static vespalib::string deQuote(const vespalib::string & source);
     static void throwNoDefaultValue(vespalib::stringref key);
 
     template<typename T>
-    static T convert(const vsvector &);
+    static T convert(const StringVector & config);
 
-    static vespalib::string arrayToString(const vsvector &);
+    static vespalib::string arrayToString(Cfg config);
 
-    template<typename T, typename V>
-    static T parseInternal(vespalib::stringref key, const V & config);
-    template<typename T, typename V>
-    static T parseInternal(vespalib::stringref key, const V & config, T defaultValue);
+    template<typename T>
+    static T parseInternal(vespalib::stringref key, Cfg config);
+    template<typename T>
+    static T parseInternal(vespalib::stringref key, Cfg config, T defaultValue);
 
-    template<typename T, typename V>
-    static std::vector<T> parseArrayInternal(vespalib::stringref key, const V & config);
-    template<typename T, typename V>
-    static std::map<vespalib::string, T> parseMapInternal(vespalib::stringref key, const V & config);
-    template<typename T, typename V>
-    static T parseStructInternal(vespalib::stringref key, const V & config);
+    template<typename V>
+    static V parseArrayInternal(vespalib::stringref key, Cfg config);
+    template<typename T>
+    static std::map<vespalib::string, T> parseMapInternal(vespalib::stringref key, Cfg config);
+    template<typename T>
+    static T parseStructInternal(vespalib::stringref key, Cfg config);
 
 public:
-    static void stripLinesForKey(vespalib::stringref key,
-                                 std::set<vespalib::string>& config);
+    static void stripLinesForKey(vespalib::stringref key, std::set<vespalib::string>& config);
+    static std::set<vespalib::string> getUniqueNonWhiteSpaceLines(Cfg config);
     static vespalib::string stripWhitespace(vespalib::stringref source);
 
     template<typename T>
-    static T parse(vespalib::stringref key, const vsvector & config) {
-        return parseInternal<T, vsvector>(key, config);
+    static T parse(vespalib::stringref key, Cfg config) {
+        return parseInternal<T>(key, config);
     }
     template<typename T>
-    static T parse(vespalib::stringref key, const vsvector & config, T defaultValue) {
+    static T parse(vespalib::stringref key, Cfg config, T defaultValue) {
         return parseInternal(key, config, defaultValue);
     }
 
-    template<typename T>
-    static std::vector<T> parseArray(vespalib::stringref key, const vsvector & config) {
-        return parseArrayInternal<T, vsvector>(key, config);
+    template<typename V>
+    static V parseArray(vespalib::stringref key, Cfg config) {
+        return parseArrayInternal<V>(key, config);
     }
 
     template<typename T>
-    static std::map<vespalib::string, T> parseMap(vespalib::stringref key, const vsvector & config) {
-        return parseMapInternal<T, vsvector>(key, config);
+    static std::map<vespalib::string, T> parseMap(vespalib::stringref key, Cfg config) {
+        return parseMapInternal<T>(key, config);
     }
 
     template<typename T>
-    static T parseStruct(vespalib::stringref key, const vsvector & config) {
-        return parseStructInternal<T, vsvector>(key, config);
+    static T parseStruct(vespalib::stringref key, Cfg config) {
+        return parseStructInternal<T>(key, config);
     }
 
 };
 
-template<typename T, typename V>
+template<typename T>
 T
-ConfigParser::parseInternal(vespalib::stringref key, const V & config)
+ConfigParser::parseInternal(vespalib::stringref key, Cfg config)
 {
-    V lines = getLinesForKey(key, config);
+    StringVector lines = getLinesForKey(key, config);
 
     if (lines.size() == 0) {
         throwNoDefaultValue(key);
@@ -84,11 +98,11 @@ ConfigParser::parseInternal(vespalib::stringref key, const V & config)
     return convert<T>(lines);
 }
 
-template<typename T, typename V>
+template<typename T>
 T
-ConfigParser::parseInternal(vespalib::stringref key, const V & config, T defaultValue)
+ConfigParser::parseInternal(vespalib::stringref key, Cfg config, T defaultValue)
 {
-    V lines = getLinesForKey(key, config);
+    StringVector lines = getLinesForKey(key, config);
 
     if (lines.size() == 0) {
         return defaultValue;
@@ -99,67 +113,68 @@ ConfigParser::parseInternal(vespalib::stringref key, const V & config, T default
 
 template<typename T>
 T
-ConfigParser::convert(const vsvector & lines) {
+ConfigParser::convert(const StringVector & lines) {
     return T(lines);
 }
 
-template<typename T, typename V>
+template<typename T>
 std::map<vespalib::string, T>
-ConfigParser::parseMapInternal(vespalib::stringref key, const V & config)
+ConfigParser::parseMapInternal(vespalib::stringref key, Cfg config)
 {
-    V lines = getLinesForKey(key, config);
-    typedef std::map<vespalib::string, V> SplittedMap;
+    StringVector lines = getLinesForKey(key, config);
+    using SplittedMap = std::map<vespalib::string, StringVector>;
     SplittedMap s = splitMap(lines);
     std::map<vespalib::string, T> retval;
-    for (typename SplittedMap::iterator it(s.begin()), mt(s.end()); it != mt; it++) {
-        retval[it->first] = convert<T>(it->second);
+    for (const auto & e : s) {
+        retval[e.first] = convert<T>(e.second);
     }
     return retval;
 }
 
-template<typename T, typename V>
-std::vector<T>
-ConfigParser::parseArrayInternal(vespalib::stringref key, const V & config)
+template<typename V>
+V
+ConfigParser::parseArrayInternal(vespalib::stringref key, Cfg config)
 {
-    V lines = getLinesForKey(key, config);
-    std::vector<V> split = splitArray(lines);
+    StringVector lines = getLinesForKey(key, config);
+    std::vector<StringVector> split = splitArray(lines);
 
-    std::vector<T> retval;
+    V retval;
+    retval.reserve(split.size());
     for (uint32_t i = 0; i < split.size(); i++) {
-        retval.push_back(convert<T>(split[i]));
+        retval.push_back(convert<typename V::value_type>(split[i]));
     }
 
     return retval;
 }
 
-template<typename T, typename V>
+template<typename T>
 T
-ConfigParser::parseStructInternal(vespalib::stringref key, const V & config)
+ConfigParser::parseStructInternal(vespalib::stringref key, Cfg config)
 {
-    V lines = getLinesForKey(key, config);
+    StringVector lines = getLinesForKey(key, config);
 
     return convert<T>(lines);
 }
 
 template<>
 bool
-ConfigParser::convert<bool>(const vsvector & config);
+ConfigParser::convert<bool>(const StringVector & config);
 
 template<>
 int32_t
-ConfigParser::convert<int32_t>(const vsvector & config);
+ConfigParser::convert<int32_t>(const StringVector & config);
 
 template<>
 int64_t
-ConfigParser::convert<int64_t>(const vsvector & config);
+ConfigParser::convert<int64_t>(const StringVector & config);
 
 template<>
 double
-ConfigParser::convert<double>(const vsvector & config);
+ConfigParser::convert<double>(const StringVector & config);
 
 template<>
 vespalib::string
-ConfigParser::convert<vespalib::string>(const vsvector & config);
+ConfigParser::convert<vespalib::string>(const StringVector & config);
 
 } // config
 
diff --git a/config/src/vespa/config/common/configstate.h b/config/src/vespa/config/common/configstate.h
index a0229f85cd5..0895517343c 100644
--- a/config/src/vespa/config/common/configstate.h
+++ b/config/src/vespa/config/common/configstate.h
@@ -1,7 +1,6 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #pragma once
 
-#include <vespa/vespalib/stllike/string.h>
 #include "misc.h"
 
 namespace config {
diff --git a/config/src/vespa/config/common/misc.cpp b/config/src/vespa/config/common/misc.cpp
index 7eba045a2c7..31c66cd4eb8 100644
--- a/config/src/vespa/config/common/misc.cpp
+++ b/config/src/vespa/config/common/misc.cpp
@@ -39,6 +39,16 @@ calculateContentXxhash64(const StringVector & fileContents)
     return ss.str();
 }
 
+StringVector
+getlines(vespalib::asciistream & is, char delim)
+{
+    StringVector lines;
+    while (!is.eof()) {
+        lines.push_back(is.getline(delim));
+    }
+    return lines;
+}
+
 bool
 isGenerationNewer(int64_t newGen, int64_t oldGen)
 {
diff --git a/config/src/vespa/config/common/misc.h b/config/src/vespa/config/common/misc.h
index f26ee3df850..584a7ca527b 100644
--- a/config/src/vespa/config/common/misc.h
+++ b/config/src/vespa/config/common/misc.h
@@ -5,6 +5,7 @@
 #include <memory>
 
 namespace vespalib {
+    class asciistream;
     class Slime;
     namespace slime {
         struct Inspector;
@@ -32,4 +33,6 @@ typedef std::shared_ptr<const vespalib::Slime> SlimePtr;
  */
 void copySlimeObject(const vespalib::slime::Inspector & src, vespalib::slime::Cursor & dest);
 
+StringVector getlines(vespalib::asciistream & is, char delim='\n');
+
 }
diff --git a/config/src/vespa/config/common/types.h b/config/src/vespa/config/common/types.h
index b59685ffaa0..0c9ad15d046 100644
--- a/config/src/vespa/config/common/types.h
+++ b/config/src/vespa/config/common/types.h
@@ -2,12 +2,14 @@
 #pragma once
 
 #include <vespa/vespalib/stllike/string.h>
+#include <vespa/vespalib/stllike/allocator.h>
 #include <vector>
 #include <map>
 
 namespace config {
 
-using StringVector = std::vector<vespalib::string>;
+//using StringVector = std::vector<vespalib::string>;
+using StringVector = std::vector<vespalib::string, vespalib::allocator_large<vespalib::string>>;
 using BoolVector = std::vector<bool>;
 using DoubleVector = std::vector<double>;
 using LongVector = std::vector<int64_t>;
diff --git a/config/src/vespa/config/configgen/map_inserter.h b/config/src/vespa/config/configgen/map_inserter.h
index 9f596912c5f..e35ee8cb0ac 100644
--- a/config/src/vespa/config/configgen/map_inserter.h
+++ b/config/src/vespa/config/configgen/map_inserter.h
@@ -4,12 +4,9 @@
 #include "value_converter.h"
 #include <vespa/vespalib/data/slime/object_traverser.h>
 #include <vespa/vespalib/stllike/string.h>
-
 #include <map>
 
-namespace config {
-
-namespace internal {
+namespace config::internal {
 
 template<typename T, typename Converter = config::internal::ValueConverter<T> >
 class MapInserter : public ::vespalib::slime::ObjectTraverser {
@@ -20,9 +17,4 @@ private:
     std::map<vespalib::string, T> & _map;
 };
 
-} // namespace internal
-
-} // namespace config
-
-#include "map_inserter.hpp"
-
+}
diff --git a/config/src/vespa/config/configgen/map_inserter.hpp b/config/src/vespa/config/configgen/map_inserter.hpp
index 6ffdb0e893b..9bd04c95b11 100644
--- a/config/src/vespa/config/configgen/map_inserter.hpp
+++ b/config/src/vespa/config/configgen/map_inserter.hpp
@@ -1,7 +1,10 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-namespace config {
 
-namespace internal {
+#pragma once
+
+#include "map_inserter.h"
+
+namespace config::internal {
 
 template<typename T, typename Converter>
 MapInserter<T, Converter>::MapInserter(std::map<vespalib::string, T> & map)
@@ -16,6 +19,4 @@ MapInserter<T, Converter>::field(const ::vespalib::Memory & symbol, const ::vesp
     _map[symbol.make_string()] = converter(inspector);
 }
 
-} // namespace internal
-
 }
diff --git a/config/src/vespa/config/configgen/value_converter.cpp b/config/src/vespa/config/configgen/value_converter.cpp
index 4b25c6040da..36843456b25 100644
--- a/config/src/vespa/config/configgen/value_converter.cpp
+++ b/config/src/vespa/config/configgen/value_converter.cpp
@@ -54,7 +54,7 @@ template<>
 vespalib::string convertValue(const ::vespalib::slime::Inspector & __inspector) { return __inspector.asString().make_string(); }
 
 void
-requireValid(const vespalib::string & __fieldName, const ::vespalib::slime::Inspector & __inspector) {
+requireValid(vespalib::stringref __fieldName, const ::vespalib::slime::Inspector & __inspector) {
     if (!__inspector.valid()) {
         throw ::config::InvalidConfigException("Value for '" + __fieldName + "' required but not found");
     }
diff --git a/config/src/vespa/config/configgen/value_converter.h b/config/src/vespa/config/configgen/value_converter.h
index 695e798b015..c583f1595dc 100644
--- a/config/src/vespa/config/configgen/value_converter.h
+++ b/config/src/vespa/config/configgen/value_converter.h
@@ -7,7 +7,7 @@
 
 namespace config::internal {
 
-void requireValid(const vespalib::string & __fieldName, const ::vespalib::slime::Inspector & __inspector);
+void requireValid(vespalib::stringref __fieldName, const ::vespalib::slime::Inspector & __inspector);
 
 template<typename T>
 T convertValue(const ::vespalib::slime::Inspector & __inspector) { return T(::config::ConfigPayload(__inspector)); }
@@ -29,7 +29,7 @@ vespalib::string convertValue(const ::vespalib::slime::Inspector & __inspector);
 
 template<typename T>
 struct ValueConverter {
-    T operator()(const vespalib::string & __fieldName, const ::vespalib::slime::Inspector & __inspector) {
+    T operator()(vespalib::stringref __fieldName, const ::vespalib::slime::Inspector & __inspector) {
         requireValid(__fieldName, __inspector);
         return convertValue<T>(__inspector);
     }
diff --git a/config/src/vespa/config/configgen/vector_inserter.h b/config/src/vespa/config/configgen/vector_inserter.h
index 3c5a406ef67..4b8c7a5e0a1 100644
--- a/config/src/vespa/config/configgen/vector_inserter.h
+++ b/config/src/vespa/config/configgen/vector_inserter.h
@@ -5,22 +5,15 @@
 #include <vespa/vespalib/data/slime/array_traverser.h>
 #include <vespa/vespalib/stllike/string.h>
 
-namespace config {
+namespace config::internal {
 
-namespace internal {
-
-template<typename T, typename Converter = ::config::internal::ValueConverter<T> >
+template<typename V, typename Converter = ::config::internal::ValueConverter<typename V::value_type> >
 class VectorInserter : public ::vespalib::slime::ArrayTraverser {
 public:
-    VectorInserter(std::vector<T> & vector);
+    VectorInserter(V & vector);
     void entry(size_t idx, const ::vespalib::slime::Inspector & inspector) override;
 private:
-    std::vector<T> & _vector;
+    V & _vector;
 };
 
-} // namespace internal
-
-} // namespace config
-
-#include "vector_inserter.hpp"
-
+}
diff --git a/config/src/vespa/config/configgen/vector_inserter.hpp b/config/src/vespa/config/configgen/vector_inserter.hpp
index ed43dda07d6..31c3c52a358 100644
--- a/config/src/vespa/config/configgen/vector_inserter.hpp
+++ b/config/src/vespa/config/configgen/vector_inserter.hpp
@@ -1,22 +1,23 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-namespace config {
 
-namespace internal {
+#pragma once
 
-template<typename T, typename Converter>
-VectorInserter<T, Converter>::VectorInserter(std::vector<T> & vector)
+#include "vector_inserter.h"
+
+namespace config::internal {
+
+template<typename V, typename Converter>
+VectorInserter<V, Converter>::VectorInserter(V & vector)
     : _vector(vector)
 {}
 
-template<typename T, typename Converter>
+template<typename V, typename Converter>
 void
-VectorInserter<T, Converter>::entry(size_t idx, const ::vespalib::slime::Inspector & inspector)
+VectorInserter<V, Converter>::entry(size_t idx, const ::vespalib::slime::Inspector & inspector)
 {
     (void) idx;
     Converter converter;
     _vector.push_back(converter(inspector));
 }
 
-} // namespace internal
-
 }
diff --git a/config/src/vespa/config/file/filesource.cpp b/config/src/vespa/config/file/filesource.cpp
index 1585bd1bd53..011868f7c06 100644
--- a/config/src/vespa/config/file/filesource.cpp
+++ b/config/src/vespa/config/file/filesource.cpp
@@ -53,7 +53,7 @@ StringVector
 FileSource::readConfigFile(const vespalib::string & fileName)
 {
     asciistream is(asciistream::createFromFile(fileName));
-    return is.getlines();
+    return getlines(is);
 }
 
 void
diff --git a/config/src/vespa/config/raw/rawsource.cpp b/config/src/vespa/config/raw/rawsource.cpp
index f37f30bb2f7..cf551106405 100644
--- a/config/src/vespa/config/raw/rawsource.cpp
+++ b/config/src/vespa/config/raw/rawsource.cpp
@@ -36,7 +36,7 @@ StringVector
 RawSource::readConfig()
 {
     vespalib::asciistream is(_payload);
-    return is.getlines();
+    return getlines(is);
 }
 
 }
diff --git a/config/src/vespa/config/set/configinstancesourcefactory.cpp b/config/src/vespa/config/set/configinstancesourcefactory.cpp
index 64abaada0a4..15a6125d096 100644
--- a/config/src/vespa/config/set/configinstancesourcefactory.cpp
+++ b/config/src/vespa/config/set/configinstancesourcefactory.cpp
@@ -14,7 +14,7 @@ public:
     { }
     void close() override { }
     void getConfig() override {
-        _holder->handle(std::make_unique<config::ConfigUpdate>(config::ConfigValue(_buffer.getlines()), true, _generation));
+        _holder->handle(std::make_unique<config::ConfigUpdate>(config::ConfigValue(config::getlines(_buffer)), true, _generation));
 
     }
     void reload(int64_t generation) override { _generation = generation; }
diff --git a/config/src/vespa/config/set/configsetsource.cpp b/config/src/vespa/config/set/configsetsource.cpp
index 94547fbe63d..41886a12d01 100644
--- a/config/src/vespa/config/set/configsetsource.cpp
+++ b/config/src/vespa/config/set/configsetsource.cpp
@@ -30,7 +30,7 @@ ConfigSetSource::getConfig()
     vespalib::asciistream ss;
     AsciiConfigWriter writer(ss);
     writer.write(*instance);
-    StringVector lines(ss.getlines());
+    StringVector lines(getlines(ss));
     vespalib::string currentXxhash64(calculateContentXxhash64(lines));
 
     if (isGenerationNewer(_generation, _lastState.generation) && currentXxhash64.compare(_lastState.xxhash64) != 0) {