Tidy up the index parsing

Author: Matt Godbolt

src/IndexParser.cpp

@@ -6,67 +6,96 @@
 #include <fstream>
 #include <stdexcept>
 
-void IndexParser::buildIndexes(Index::Builder *builder, ConsoleLog& log) {
+void IndexParser::buildIndexes(Index::Builder *builder, ConsoleLog &log) {
     std::ifstream in(fileName_, std::ifstream::in);
     std::string contents((std::istreambuf_iterator<char>(in)),
                          std::istreambuf_iterator<char>());
-    cJSON * root = cJSON_Parse(contents.c_str());
-    if(root == nullptr) {
+    cJSON *root = cJSON_Parse(contents.c_str());
+    if (root == nullptr) {
         throw std::runtime_error("Could not parse the json config file. "
                                          "Careful, this is a strict parser.");
     }
     if (!cJSON_HasObjectItem(root, "indexes")) {
         throw std::runtime_error("No indexes to be found in the config file.");
     }
-    cJSON* indexes = cJSON_GetObjectItem(root,"indexes");
+    cJSON *indexes = cJSON_GetObjectItem(root, "indexes");
     auto arraySize = cJSON_GetArraySize(indexes);
-    for (int i =0; i < arraySize; i++) {
+    for (int i = 0; i < arraySize; i++) {
         parseIndex(cJSON_GetArrayItem(indexes, i), builder, log);
     }
 }
 
-void IndexParser::parseIndex(cJSON *index, Index::Builder *builder, ConsoleLog& log) {
+void IndexParser::parseIndex(cJSON *index, Index::Builder *builder,
+                             ConsoleLog &log) {
     if (!cJSON_HasObjectItem(index, "type")) {
-        throw std::runtime_error("All indexes must have a type field, i.e. Regex, Field, ");
+        throw std::runtime_error(
+                "All indexes must have a type field, i.e. Regex, Field, ");
     }
     std::string indexName = "default";
     if (cJSON_HasObjectItem(index, "name")) {
         indexName = cJSON_GetObjectItem(index, "name")->valuestring;
     }
     std::string type = cJSON_GetObjectItem(index, "type")->valuestring;
     Index::IndexConfig config{};
-    config.numeric = cJSON_GetObjectItem(index, "numeric") && strcmp("true", cJSON_GetObjectItem(index, "numeric")->string);
-    config.unique = cJSON_GetObjectItem(index, "unique") && strcmp("true", cJSON_GetObjectItem(index, "unique")->string);
-    config.sparse = cJSON_GetObjectItem(index, "sparse") && strcmp("true", cJSON_GetObjectItem(index, "sparse")->string);
-    config.indexLineOffsets = cJSON_GetObjectItem(index, "indexLineOffsets") && strcmp("true", cJSON_GetObjectItem(index, "indexLineOffsets")->string);
+    config.numeric = getBoolean(index, "numeric");
+    config.unique = getBoolean(index, "unique");
+    config.sparse = getBoolean(index, "sparse");
+    config.indexLineOffsets = getBoolean(index, "indexLineOffsets");
 
-    // TODO: if anything is missing here we segfault
     if (type == "regex") {
-        std::string regex = cJSON_GetObjectItem(index, "regex")->valuestring;
+        auto regex = getOrThrowStr(index, "regex");
         if (cJSON_HasObjectItem(index, "capture")) {
             uint capture = cJSON_GetObjectItem(index, "capture")->valueint;
             builder->addIndexer(indexName, regex, config,
-                               std::unique_ptr<LineIndexer>(new RegExpIndexer(regex, capture)));
+                                std::unique_ptr<LineIndexer>(
+                                        new RegExpIndexer(regex, capture)));
         } else {
             builder->addIndexer(indexName, regex, config,
-                               std::unique_ptr<LineIndexer>(new RegExpIndexer(regex)));
+                                std::unique_ptr<LineIndexer>(
+                                        new RegExpIndexer(regex)));
         }
     } else if (type == "field") {
-        std::string delimiter = cJSON_GetObjectItem(index, "delimiter")->valuestring;
-        uint fieldNum = cJSON_GetObjectItem(index, "fieldNum")->valueint;
+        auto delimiter = getOrThrowStr(index, "delimiter");
+        auto fieldNum = getOrThrowUint(index, "fieldNum");
         std::ostringstream name;
         name << "Field " << fieldNum << " delimited by '"
-            << delimiter << "'";
+             << delimiter << "'";
         builder->addIndexer(indexName, name.str(), config,
-                           std::unique_ptr<LineIndexer>(new FieldIndexer(delimiter, fieldNum)));
+                            std::unique_ptr<LineIndexer>(
+                                    new FieldIndexer(delimiter, fieldNum)));
     } else if (type == "pipe") {
-        std::string pipeCommand = cJSON_GetObjectItem(index, "command")->valuestring;
-        std::string delimiter = cJSON_GetObjectItem(index, "delimiter")->valuestring;
+        auto pipeCommand = getOrThrowStr(index, "command");
+        auto delimiter = getOrThrowStr(index, "delimiter");
 
         builder->addIndexer(indexName, pipeCommand, config, std::move(
-                        std::unique_ptr<LineIndexer>(new ExternalIndexer(log,
-                                            pipeCommand, delimiter))));
+                std::unique_ptr<LineIndexer>(new ExternalIndexer(log,
+                                                                 pipeCommand,
+                                                                 delimiter))));
     } else {
         throw std::runtime_error("unknown index " + type);
     }
 }
+
+bool IndexParser::getBoolean(cJSON *index, const char *field) const {
+    return cJSON_GetObjectItem(index, field)
+           && strcmp("true", cJSON_GetObjectItem(index, field)->string);
+}
+
+std::string IndexParser::getOrThrowStr(cJSON *index, const char *field) const {
+    auto *item = cJSON_GetObjectItem(index, field);
+    if (!item)
+        throw std::runtime_error("Could not parse the json config file. Field '"
+                                 + std::string(field) + "' was missing");
+    return item->valuestring;
+}
+
+unsigned IndexParser::getOrThrowUint(cJSON *index, const char *field) const {
+    auto *item = cJSON_GetObjectItem(index, field);
+    if (!item)
+        throw std::runtime_error("Could not parse the json config file. Field '"
+                                 + std::string(field) + "' was missing");
+    if (item->valueint < 0)
+        throw std::runtime_error("Could not parse the json config file. Field '"
+                                 + std::string(field) + "' was negative");
+    return static_cast<unsigned>(item->valueint);
+}

src/IndexParser.h

@@ -18,5 +18,7 @@ class IndexParser {
 
 private:
     void parseIndex(cJSON *index, Index::Builder* builder, ConsoleLog& log);
-    void parse(const char *p, Index::Builder* builder, ConsoleLog& log);
+    bool getBoolean(cJSON *index, const char *field) const;
+    std::string getOrThrowStr(cJSON *index, const char *field) const;
+    unsigned getOrThrowUint(cJSON *index, const char *field) const;
 };