From 1ad869ceeb2423927d8726d001808adc22fe887d Mon Sep 17 00:00:00 2001
From: Evgenii Zhemchugov <evgenii.zhemchugov@warwick.ac.uk>
Date: Mon, 2 Jun 2025 15:14:18 +0100
Subject: [PATCH 1/4] Json: implement json_scan, json_decode

Implement full-blown JSON serialization and validation functions.
Support extensions for user classes.
---
 src/Store/BStore.cpp |   2 +-
 src/Store/BStore.h   |   2 +-
 src/Store/Json.cpp   | 376 +++++++++++++++++++++++++++++++++++++++++-
 src/Store/Json.h     | 379 +++++++++++++++++++++++++++++++++++++------
 4 files changed, 696 insertions(+), 63 deletions(-)

diff --git a/src/Store/BStore.cpp b/src/Store/BStore.cpp
index 5d52515..7ce91cf 100644
--- a/src/Store/BStore.cpp
+++ b/src/Store/BStore.cpp
@@ -957,7 +957,7 @@ BStore::~BStore(){
 }
 
 namespace ToolFramework {
-  bool json_encode(std::ostream& output, const BStore& store) {
+  bool json_encode_r(std::ostream& output, const BStore& store, adl_tag) {
     return store.JsonEncode(output);
   }
 }
diff --git a/src/Store/BStore.h b/src/Store/BStore.h
index 34b9d1d..b45e540 100644
--- a/src/Store/BStore.h
+++ b/src/Store/BStore.h
@@ -258,7 +258,7 @@ namespace ToolFramework{
     
   };
 
-  bool json_encode(std::ostream&, const BStore&);
+  bool json_encode_r(std::ostream&, const BStore&, adl_tag);
 }
 
 #endif
diff --git a/src/Store/Json.cpp b/src/Store/Json.cpp
index b44f19b..c1b2178 100644
--- a/src/Store/Json.cpp
+++ b/src/Store/Json.cpp
@@ -1,19 +1,381 @@
+#include <iomanip>
+
+#include <cstdint>
+#include <cstring>
+
 #include <Json.h>
 
 namespace ToolFramework {
 
-bool json_encode(std::ostream& output, const char* datum) {
+static bool json_encode(
+    std::ostream& output,
+    const char* begin,
+    const char* end
+) {
   output << '"';
-  while (*datum) {
-    if (*datum == '"' || *datum == '\\') output << '\\';
-    output << *datum;
-  };
+  for (auto c = begin; c < end; ++c)
+    switch (*c) {
+      case '\a':
+        output << "\\a";
+        break;
+      case '\b':
+        output << "\\b";
+        break;
+      case '\f':
+        output << "\\f";
+        break;
+      case '\n':
+        output << "\\n";
+        break;
+      case '\r':
+        output << "\\r";
+        break;
+      case '\t':
+        output << "\\t";
+        break;
+      case '\\':
+      case '"':
+        output << '\\' << *c;
+        break;
+      default:
+        {
+          uint8_t byte = static_cast<uint8_t>(*c);
+          if (byte < 0x20 || byte > 0x7F) {
+            uint16_t codepoint = byte;
+            if (++c != end)
+              codepoint = codepoint << 8 | static_cast<uint8_t>(*c);
+            output
+              << "\\u"
+              << std::setw(4)
+              << std::setfill('0')
+              << std::hex
+              << codepoint
+              << std::dec;
+          } else
+            output << byte;
+        };
+    };
   output << '"';
   return true;
 }
 
-bool json_encode(std::ostream& output, const std::string& datum) {
-  return json_encode(output, datum.c_str());
+bool json_encode(
+    std::ostream& output,
+    std::string::const_iterator begin,
+    std::string::const_iterator end
+) {
+  return json_encode(output, &*begin, &*end);
+}
+
+bool json_encode_r(std::ostream& output, const std::string& datum, adl_tag) {
+  return json_encode(output, datum.begin(), datum.end());
+}
+
+bool json_encode_r(std::ostream& output, const char* datum, adl_tag) {
+  return json_encode(output, datum, datum + strlen(datum));
+}
+
+const char* json_scan_whitespace(const char* input) {
+  if (!input) return nullptr;
+  while (isspace(*input)) ++input;
+  return input;
+}
+
+const char* json_scan_token(const char* input, char token) {
+  input = json_scan_whitespace(input);
+  return input && *input == token ? input + 1 : nullptr;
+}
+
+const char* json_scan_token(const char* input, const char* token) {
+  input = json_scan_whitespace(input);
+  if (!input) return nullptr;
+  while (*token) if (*input++ != *token++) return nullptr;
+  return isalnum(*input) ? nullptr : input;
+}
+
+const char* json_scan_number(const char* input) {
+  input = json_scan_whitespace(input);
+  if (!input) return nullptr;
+
+  if (*input == '-' || *input == '+') ++input;
+  while (isdigit(*input)) ++input;
+  if (*input == '.') {
+    ++input;
+    while (isdigit(*input)) ++input;
+  };
+  if (tolower(*input) == 'e') {
+    ++input;
+    if (*input == '-' || *input == '+') ++input;
+    while (isdigit(*input)) ++input;
+  };
+
+  return isalnum(*input) ? nullptr : input;
+}
+
+const char* json_scan_string(const char* input) {
+  input = json_scan_token(input, '"');
+  if (!input) return nullptr;
+
+  bool escaped = false;
+  for (; *input; ++input)
+    if (escaped)
+      escaped = false;
+    else
+      switch (*input) {
+        case '\\':
+          escaped = true;
+          break;
+        case '"':
+          return input + 1;
+          break;
+        default:
+          break;
+      };
+
+  return nullptr;
+}
+
+static const char* json_scan_list(
+    const char* input,
+    char start,
+    char end,
+    const char* (*scan_item)(const char*)
+) {
+  bool comma = false;
+  input = json_scan_token(input, start);
+  while (input) {
+    input = json_scan_whitespace(input);
+    if (*input == end) return input + 1;
+
+    if (comma) {
+      if (*input++ != ',') return nullptr;
+    } else
+      comma = true;
+
+    input = scan_item(input);
+  };
+  return nullptr;
+}
+
+const char* json_scan_object(const char* input) {
+  return json_scan_list(
+      input, '{', '}',
+      [](const char* i) -> const char* {
+        i = json_scan_string(i);
+        i = json_scan_token(i, ':');
+        return json_scan(i);
+    }
+  );
+}
+
+const char* json_scan_array(const char* input) {
+  return json_scan_list(input, '[', ']', json_scan);
+}
+
+const char* json_scan(const char* input) {
+  input = json_scan_whitespace(input);
+  if (!input) return nullptr;
+  switch (*input) {
+    case 'f':
+      return json_scan_token(input, "false");
+    case 't':
+      return json_scan_token(input, "true");
+    case 'n':
+      return json_scan_token(input, "null");
+    case '-':
+    case '+':
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+      return json_scan_number(input);
+    case '"':
+      return json_scan_string(input);
+    case '{':
+      return json_scan_object(input);
+    case '[':
+      return json_scan_array(input);
+    default:
+      return nullptr;
+  };
+}
+
+bool json_decode_r(const char*& input, bool& value, adl_tag) {
+  const char* i = json_scan_whitespace(input);
+  if (!i) return false;
+
+  switch (*i) {
+    case 'f':
+      i = json_scan_token(i, "false");
+      if (!i) return false;
+      value = false;
+      break;
+    case 't':
+      i = json_scan_token(i, "true");
+      if (!i) return false;
+      value = true;
+      break;
+    case '0':
+      if (isalnum(*++i)) return false;
+      value = false;
+      break;
+    case '1':
+      if (isalnum(*++i)) return false;
+      value = true;
+      break;
+    default:
+      return false;
+  };
+
+  input = i;
+  return true;
+}
+
+namespace json_internal {
+
+bool json_decode_string(
+    const char*& input,
+    std::string& value,
+    bool keep_quotes
+) {
+  const char* i = json_scan_token(input, '"');
+  if (!i) return false;
+
+  std::stringstream ss;
+  if (keep_quotes) ss << '"';
+
+  bool escaped = false;
+  for (; *i; ++i) {
+    if (escaped) {
+      escaped = false;
+      switch (*i) {
+        case '\\':
+          ss << '\\';
+          break;
+        case 'a':
+          ss << '\a';
+          break;
+        case 'b':
+          ss << '\b';
+          break;
+        case 'f':
+          ss << '\f';
+          break;
+        case 'n':
+          ss << '\n';
+          break;
+        case 'r':
+          ss << '\r';
+          break;
+        case 't':
+          ss << '\t';
+          break;
+        case 'u':
+          {
+            uint16_t codepoint = 0;
+            for (int b = 0; b < 2; ++b) {
+              for (int d = 0; d < 2; ++d) {
+                char digit = *++i;
+                if (digit >= '0' && digit <= '9')
+                  digit -= '0';
+                else if (digit >= 'a' && digit <= 'f')
+                  digit = digit - 'a' + 10;
+                else if (digit >= 'A' && digit <= 'F')
+                  digit = digit - 'A' + 10;
+                else
+                  return false; // TODO: invalid string
+                codepoint = codepoint << 4 | digit;
+              };
+            };
+            if (codepoint > 0xFF) ss << static_cast<char>(codepoint >> 8);
+            ss << static_cast<char>(codepoint & 0xFF);
+          };
+          break;
+        default:
+          // TODO: invalid escape sequence. Store anyway?
+          ss << *i;
+      };
+    } else {
+      switch (*i) {
+        case '\\':
+          escaped = true;
+          continue;
+        case '"':
+          if (keep_quotes) ss << '"';
+          input = ++i;
+          value = ss.str();
+          return true;
+        default:
+          ss << *i;
+      };
+    };
+  };
+
+  return false;
+}
+
+}
+
+bool json_decode_r(const char*& input, std::string& value, adl_tag) {
+  return json_internal::json_decode_string(input, value, false);
+}
+
+static bool json_decode_list(
+    const char*& input,
+    char start,
+    char end,
+    const std::function<bool (const char*&)> decode_item
+) {
+  const char* i = json_scan_token(input, start);
+  if (!i) return false;
+
+  bool comma = false;
+  while (true) {
+    i = json_scan_whitespace(i);
+    if (*i == end) break;
+
+    if (comma) {
+      if (*i++ != ',') return false;
+    } else
+      comma = true;
+
+    if (!decode_item(i)) return false;
+  };
+
+  input = i + 1;
+  return true;
+}
+
+bool json_decode_array(
+    const char*& input,
+    const std::function<bool (const char*&)>& decode_item
+) {
+  return json_decode_list(input, '[', ']', decode_item);
+}
+
+bool json_decode_object(
+    const char*& input,
+    const std::function<bool (const char*&, std::string)>& decode_value
+) {
+  return json_decode_list(
+      input, '{', '}',
+      [&](const char*& input_) -> bool {
+        const char* i = input_;
+        std::string key;
+        if (!json_decode_r(i, key, adl_tag {})) return false;
+        i = json_scan_token(i, ':');
+        if (!i) return false;
+        if (!decode_value(i, std::move(key))) return false;
+        input_ = i;
+        return true;
+      }
+  );
 }
 
 }
diff --git a/src/Store/Json.h b/src/Store/Json.h
index 2cb23c1..e2080a6 100644
--- a/src/Store/Json.h
+++ b/src/Store/Json.h
@@ -1,82 +1,173 @@
 #ifndef TOOLFRAMEWORK_JSON_H
 #define TOOLFRAMEWORK_JSON_H
 
+#include <functional>
 #include <map>
 #include <ostream>
 #include <sstream>
 #include <string>
 #include <type_traits>
+#include <unordered_map>
 #include <vector>
 
+
+/**
+   This file provides functions working with JSON.
+
+   Three families of functions are provided: json_encode for JSON
+   serialization, json_scan for JSON validation, and json_decode for JSON
+   parsing.
+*/
+
 namespace ToolFramework {
 
+/**
+   JSON serialization functions
+
+   json_encode comes in two flavours: json_encode(std::ostream&, const T&)
+   serializes a value into a stream, json_encode(std::string&, const T&)
+   serializes a value into a string. The latter calls the former, and the
+   former calls json_encode_r to encode specific objects. Provide overloads of
+   json_encode_r function or template to extend for custom classes.
+
+   json_encode returns false if encoding has failed; for the function working
+   with a stream it can only happen in user extensions, functions in this file
+   always return true. json_encode(std::string&, const T&) checks the stream
+   flags.
+*/
+
+template <typename T> bool json_encode(std::ostream& output, const T& datum);
+template <typename T> bool json_encode(std::string& output, const T& datum);
+
+// Encode a part of a string as a string
+bool json_encode(
+    std::ostream& output,
+    std::string::const_iterator begin,
+    std::string::const_iterator end
+);
+
+// A helper function to write fixed-size objects
+// Example: call `json_encode_object(output, "x", 42, "a", false)`
+// to produce `{"x":42,"a":false}`
+template <typename... Fields>
+bool json_encode_object(std::ostream& output, Fields... fields);
+
+/*
+   JSON decoder function
+   Use this if you know the structure of JSON data in advance
+
+   Returns false if the JSON string is invalid.
+   If the object was decoded successfully, input is set one character past it,
+   otherwise it is left unchanged.
+*/
+template <typename T> bool json_decode(const char*& input, T& value);
+
+// Expects an array in input, calls decode_item(item) on each array item
+bool json_decode_array(
+    const char*& input,
+    const std::function<bool (const char*& /* input */)>& decode_item
+);
+
+// Expects an object in input, calls decode_value(key, value) on each key-value pair
+bool json_decode_object(
+    const char*& input,
+    const std::function<bool (const char*& /* input */, std::string /* key */)>&
+      decode_value
+);
+
+// A class to trigger argument-dependent lookup (ADL) in json_encode_r and
+// json_decode_r functions. It is required for the compiler to find overloads
+// declared after this file. See
+// https://akrzemi1.wordpress.com/2016/01/16/a-customizable-framework/
+// for caveats.
+struct adl_tag {};
+
+
+/**
+   JSON scanner functions
+
+   Scanner functions find the end of an object without further interpretation.
+
+   Each function returns nullptr if the JSON string is invalid.
+   It is okay to pass nullptr as input.
+*/
+const char* json_scan_whitespace(const char* input);
+const char* json_scan_token(const char* input, char token);
+const char* json_scan_token(const char* input, const char* token);
+const char* json_scan_number(const char* input);
+const char* json_scan_string(const char* input);
+const char* json_scan_object(const char* input);
+const char* json_scan_array(const char* input);
+const char* json_scan(const char* input); // generic
+
+
+// json_encode_r implements encoding of specific objects. Add overloads to this
+// function to support custom classes.
+
+template <typename T>
+typename std::enable_if<std::is_arithmetic<T>::value, bool>::type
+json_encode_r(std::ostream& output, T datum, adl_tag);
+
+bool json_encode_r(std::ostream& output, const std::string& datum, adl_tag);
+
+bool json_encode_r(std::ostream& output, const char* datum, adl_tag);
+
+template <typename T>
+bool json_encode_r(std::ostream& output, const T* data, size_t size, adl_tag);
+
 template <typename T, size_t N>
-bool json_encode(std::ostream&, const std::array<T, N>&);
+bool json_encode_r(std::ostream&, const std::array<T, N>&, adl_tag);
 
 template <typename T>
-bool json_encode(std::ostream&, const std::vector<T>&);
+bool json_encode_r(std::ostream&, const std::vector<T>&, adl_tag);
 
 template <typename T>
-bool json_encode(std::ostream&, const std::map<std::string, T>&);
+bool json_encode_r(std::ostream&, const std::map<std::string, T>&, adl_tag);
+
+// json_decode_r implements decoding of specific objects. Add overloads to this
+// function to support custom classes.
+
+bool json_decode_r(const char*& input, bool& value, adl_tag);
 
 template <typename T>
-typename std::enable_if<std::is_arithmetic<T>::value, bool>::type
-json_encode(std::ostream& output, T datum) {
-  output << datum;
-  return true;
-}
+typename std::enable_if<
+  std::is_integral<T>::value && std::is_signed<T>::value,
+  bool
+>::type
+json_decode_r(const char*& input, T& value, adl_tag);
 
-bool json_encode(std::ostream& output, const char* datum);
-bool json_encode(std::ostream& output, const std::string& datum);
+template <typename T>
+typename std::enable_if<
+  std::is_integral<T>::value && !std::is_signed<T>::value,
+  bool
+>::type
+json_decode_r(const char*& input, T& value);
 
 template <typename T>
-bool json_encode(std::ostream& output, const T* data, size_t size) {
-  output << '[';
-  bool comma = false;
-  for (size_t i = 0; i < size; ++i) {
-    if (comma)
-      output << ',';
-    comma = true;
-    if (!json_encode(output, data[i])) return false;
-  };
-  output << ']';
-  return true;
-}
+typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+json_decode_r(const char*& input, T& value, adl_tag);
 
-template <typename T, size_t N>
-bool json_encode(std::ostream& output, const std::array<T, N>& array) {
-  return json_encode(output, array.data(), array.size());
-}
+bool json_decode_r(const char*& input, std::string& value, adl_tag);
 
 template <typename T>
-bool json_encode(std::ostream& output, const std::vector<T>& vector) {
-  return json_encode(output, vector.data(), vector.size());
-}
+bool json_decode_r(const char*& input, std::vector<T>& value, adl_tag);
 
 template <typename T>
-bool json_encode(std::ostream& output, const std::map<std::string, T>& data) {
-  output << '{';
-  bool comma = false;
-  for (auto& datum : data) {
-    if (comma)
-      output << ',';
-    else
-      comma = true;
-    if (!json_encode(output, datum.first)) return false;
-    output << ':';
-    if (!json_encode(output, datum.second)) return false;
-  };
-  output << '}';
-  return true;
-}
+bool json_decode_r(
+    const char*& input,
+    std::map<std::string, T>& value,
+    adl_tag
+);
 
 template <typename T>
-bool json_encode(std::string& output, T data) {
-  std::stringstream ss;
-  if (!json_encode(ss, data)) return false;
-  output = ss.str();
-  return true;
-}
+bool json_decode_r(
+    const char*& input,
+    std::unordered_map<std::string, T>& value,
+    adl_tag
+);
+
+
+// Implementation
 
 namespace json_internal {
 
@@ -95,7 +186,7 @@ namespace json_internal {
     if (comma) output << ',';
     comma = true;
     output << '"' << name << '"' << ':';
-    if (!json_encode(output, slot)) return false;
+    if (!json_encode_r(output, slot, adl_tag {})) return false;
     return json_encode_object_slots(output, comma, rest...);
   }
 
@@ -110,12 +201,27 @@ namespace json_internal {
     return json_encode_object_slots(output, comma, name.c_str(), slot, rest...);
   }
 
+  bool json_decode_string(
+      const char*& input,
+      std::string& value,
+      bool keep_quotes
+  );
+
 } // json_internal
 
+template <typename T>
+bool json_encode(std::ostream& output, const T& datum) {
+  return json_encode_r(output, datum, adl_tag {});
+}
+
+template <typename T>
+bool json_encode(std::string& output, const T& datum) {
+  std::stringstream ss;
+  if (!json_encode(ss, datum) || !ss) return false;
+  output = ss.str();
+  return true;
+}
 
-// A helper function to write fixed-size objects
-// Example: call `json_encode_object(output, "x", 42, "a", false)`
-// to produce `{"x":42,"a":false}`
 template <typename... Args>
 bool json_encode_object(std::ostream& output, Args... args) {
   output << '{';
@@ -126,6 +232,171 @@ bool json_encode_object(std::ostream& output, Args... args) {
   return true;
 }
 
+template <typename T>
+bool json_decode(const char*& input, T& value) {
+  return json_decode_r(input, value, adl_tag {});
+}
+
+template <typename T>
+typename std::enable_if<std::is_arithmetic<T>::value, bool>::type
+json_encode_r(std::ostream& output, T datum, adl_tag) {
+  output << datum;
+  return true;
+}
+
+template <typename T>
+bool json_encode_r(std::ostream& output, const T* data, size_t size, adl_tag tag) {
+  output << '[';
+  bool comma = false;
+  for (size_t i = 0; i < size; ++i) {
+    if (comma)
+      output << ',';
+    comma = true;
+    if (!json_encode_r(output, data[i], tag)) return false;
+  };
+  output << ']';
+  return true;
+}
+
+template <typename T, size_t N>
+bool json_encode_r(
+    std::ostream& output,
+    const std::array<T, N>& array,
+    adl_tag tag
+) {
+  return json_encode_r(output, array.data(), array.size(), tag);
+}
+
+template <typename T>
+bool json_encode_r(
+    std::ostream& output,
+    const std::vector<T>& vector,
+    adl_tag tag
+) {
+  return json_encode_r(output, vector.data(), vector.size(), tag);
+}
+
+template <typename Map, typename T>
+bool json_encode_r_map(std::ostream& output, const Map& data, adl_tag tag) {
+  output << '{';
+  bool comma = false;
+  for (auto& datum : data) {
+    if (comma)
+      output << ',';
+    else
+      comma = true;
+    if (!json_encode_r(output, datum.first, tag)) return false;
+    output << ':';
+    if (!json_encode_r(output, datum.second, tag)) return false;
+  };
+  output << '}';
+  return true;
+}
+
+template <typename T>
+bool json_encode_r(
+    std::ostream& output,
+    const std::map<std::string, T>& data,
+    adl_tag tag
+) {
+  return json_encode_r_map<std::map<std::string, T>, T>(output, data, tag);
+}
+
+template <typename T>
+bool json_encode_r(
+    std::ostream& output,
+    const std::unordered_map<std::string, T>& data,
+    adl_tag tag
+) {
+  return json_encode_r_map<std::unordered_map<std::string, T>, T>(
+      output, data, tag
+  );
+}
+
+template <typename T>
+typename std::enable_if<
+  std::is_integral<T>::value && std::is_signed<T>::value,
+  bool
+>::type
+json_decode_r(const char*& input, T& value, adl_tag) {
+  char* i;
+  value = strtol(input, &i, 10);
+  if (isalnum(*i)) return false;
+  input = i;
+  return true;
+}
+
+template <typename T>
+typename std::enable_if<
+  std::is_integral<T>::value && !std::is_signed<T>::value,
+  bool
+>::type
+json_decode_r(const char*& input, T& value, adl_tag) {
+  char* i;
+  value = strtoul(input, &i, 10);
+  if (isalnum(*i)) return false;
+  input = i;
+  return true;
+}
+
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+json_decode_r(const char*& input, T& value, adl_tag) {
+  char* i;
+  value = strtod(input, &i);
+  if (isalnum(*i)) return false;
+  input = i;
+  return true;
+}
+
+template <typename T>
+bool json_decode_r(const char*& input, std::vector<T>& value, adl_tag tag) {
+  value.clear();
+  return json_decode_array(
+      input,
+      [&](const char*& i) -> bool {
+        T item;
+        if (!json_decode_r(i, item, tag)) return false;
+        value.push_back(std::move(item));
+        return true;
+      }
+  );
+}
+
+template <typename Map, typename T>
+bool json_decode_r_map(const char*& input, Map& value, adl_tag tag) {
+  value.clear();
+  return json_decode_object(
+      input,
+      [&](const char*& i, std::string key) -> bool {
+        T item;
+        if (!json_decode_r(i, item, tag)) return false;
+        value[std::move(key)] = std::move(item);
+        return true;
+      }
+  );
+}
+
+template <typename T>
+bool json_decode_r(
+    const char*& input,
+    std::map<std::string, T>& value,
+    adl_tag tag
+) {
+  return json_decode_r_map<std::map<std::string, T>, T>(input, value, tag);
+}
+
+template <typename T>
+bool json_decode_r(
+    const char*& input,
+    std::unordered_map<std::string, T>& value,
+    adl_tag tag
+) {
+  return json_decode_r_map<std::unordered_map<std::string, T>, T>(
+      input, value, tag
+  );
+}
+
 } // ToolFramework
 
 #endif

From e4682b9dc2783cd9116691c3fa78a6c470ba0d70 Mon Sep 17 00:00:00 2001
From: Evgenii Zhemchugov <evgenii.zhemchugov@warwick.ac.uk>
Date: Mon, 2 Jun 2025 15:18:16 +0100
Subject: [PATCH 2/4] Store: store structured data as JSON objects

* Use JSON encoding for strings with special characters, vectors, and
  maps to ensure that deserialization returns what has been serialized.

* Make JsonParser work for JSON objects containing strings with special
  characters.

* JsonParser now returns a bool indicating whether the parsing was
  successful.

* Replace `template <typename T> void operator>>(T&)` with `void
  operator>>(std::string&)` since it only worked for strings anyways.

* Make `operator>>` produce numbers as JSON numbers.

* Rewrite UnitTests/StoreTest to thoroughly test Store implementation.

The type of the stored object is encoded by the first character in the
stored value: `"` for strings, `[` for arrays, and `{` for objects. A
matching character is expected at the end of the value. Any other
character at the beginning of the value means that the object was
encoded with a custom `operator<<(std::ostream&, T)`, and it is expected
that `operator>>(std::istream&, T&)` can be used to decode the object
completely. If such encoding produces a string beginning with one of the
characters above, it is wrapped into a pair of '"'. These conversions
are handled transparently to the user.
---
 UnitTests/StoreTest.cpp | 628 +++++++++++++++++++++++++++++++++-------
 src/Store/Store.cpp     | 208 ++++++-------
 src/Store/Store.h       | 345 ++++++++++++----------
 3 files changed, 793 insertions(+), 388 deletions(-)

diff --git a/UnitTests/StoreTest.cpp b/UnitTests/StoreTest.cpp
index 3fca299..a1bca34 100644
--- a/UnitTests/StoreTest.cpp
+++ b/UnitTests/StoreTest.cpp
@@ -1,109 +1,525 @@
 #include <iostream>
+#include <functional>
+
+#include <string.h>
+
 #include <Store.h>
 
-using namespace ToolFramework;
-
-int test_counter=0;
-
-template <typename T> int Test(T &a, T &b, std::string message=""){
-test_counter++;
-
-if(a!=b){
-    std::cout<<"ERROR "<<test_counter<<" "<<message<<": "<<a<<"!="<<b<<std::endl;
-    return test_counter;
-}
-return 0;
-
-}
-
-
-int main(){
-
-int ret=0;
-bool pass=true;
-
-int a=1;
-short b=2;
-long c=3;
-float d=4.4;
-double e=5.5;
-bool f=true;
-char g='h';
-std::string h="hello world";
-
-unsigned int i=6;
-const int j=7;
-
-
-Store store;
-
-store.Set("a",a);
-store.Set("b",b);
-store.Set("c",c);
-store.Set("d",d);
-store.Set("e",e);
-store.Set("f",f);
-store.Set("g",g);
-store.Set("h",h);
-store.Set("i",i);
-store.Set("j",j);
-store.Set("k","hello world");
-store.Set("l",2);
-store.Set("m",4.4);
-store.Set("n",true);
-
-int a2=0;
-short b2=0;
-long c2=0;
-float d2=0;
-double e2=0;
-bool f2=false;
-char g2='0';
-std::string h2="";
-unsigned int i2=0;
-std::string k2="";
-short l2=0;
-float m2=0;
-bool n2=false;
-
-
- pass= pass && (store.Get("a",a2));
- pass= pass && (store.Get("b",b2));
- pass= pass && (store.Get("c",c2));
- pass= pass && (store.Get("d",d2));
- pass= pass && (store.Get("e",e2));
- pass= pass && (store.Get("f",f2));
- pass= pass && (store.Get("g",g2));
- pass= pass && (store.Get("h",h2));
- pass= pass && (store.Get("i",i2));
- const int j2=store.Get<int>("j");
- pass= pass && (store.Get("k",k2));
- pass= pass && (store.Get("l",l2));
- pass= pass && (store.Get("m",m2));
- pass= pass && (store.Get("n",n2));
-
-
-bool tmp=true;
-ret+=Test(pass,tmp, "Get Fail");
-
-ret+=Test(a,a2);
-ret+=Test(b,b2);
-ret+=Test(c,c2);
-ret+=Test(d,d2);
-ret+=Test(e,e2);
-ret+=Test(f,f2);
-ret+=Test(g,g2);
-ret+=Test(h,h2);
-ret+=Test(i,i2);
-ret+=Test(j,j2);
-ret+=Test(h,k2);
-ret+=Test(b,l2);
-ret+=Test(d,m2);
-ret+=Test(f,n2);
-
-store.Print();
-
-
-return ret;
-
-}
+using ToolFramework::Store;
+
+class Tester {
+  public:
+    bool success = true;
+
+    void operator()(bool result) {
+      success = success && result;
+    };
+
+    operator bool() { return success; };
+};
+
+template <>
+struct std::equal_to<Store> {
+  bool operator()(const Store& a, const Store& b) {
+    auto ia = a.begin();
+    auto ib = b.begin();
+    while (ia != a.end()) if (ib == b.end() || *ia++ != *ib++) return false;
+    return true;
+  };
+};
+
+// Compare two JSON strings neglecting whitespace
+// Skips whitespace and compares further characters. May produce false equals
+// when comparing strings within strings differing in whitespace, e.g.,
+// "{\"a\":\"q w\"}" "{\"a\":\"q  w\"}", but we don't expect those.
+static bool json_eq(const char* a, const char* b) {
+  while (*a && *b) {
+    if (*a != *b) {
+      while (isspace(*a)) ++a;
+      while (isspace(*b)) ++b;
+      if (*a != *b) return false;
+    };
+    ++a;
+    ++b;
+  };
+  while (isspace(*a)) ++a;
+  while (isspace(*b)) ++b;
+  return *a == *b;
+};
+
+template <typename T>
+std::ostream& operator<<(std::ostream&, const std::map<std::string, T>&);
+
+template <typename T>
+std::ostream& operator<<(std::ostream& stream, const std::vector<T>& vector) {
+  stream << "[ ";
+  bool comma = false;
+  for (auto& x : vector) {
+    if (comma) stream << ", ";
+    comma = true;
+    stream << x;
+  };
+  return stream << " ]";
+};
+
+template <typename T>
+std::ostream& operator<<(std::ostream& stream, const std::map<std::string, T>& map) {
+  stream << "{ ";
+  bool comma = false;
+  for (auto& kv : map) {
+    if (comma) stream << ", ";
+    comma = true;
+    stream << kv.first << " => " << kv.second;
+  };
+  return stream << " }";
+};
+
+// Custom user class
+struct User {
+  std::string field;
+
+  User() {};
+  User(const char* f): field(f) {};
+  virtual ~User() {};
+
+  bool operator==(const User& u) const {
+    return field == u.field;
+  };
+};
+
+static void print(std::ostream& stream, const User& user) {
+  stream << "user " << user.field;
+};
+
+// Custom user class with implemented json encode/decode
+struct User1: public User {
+  User1() {};
+  User1(const char* f): User(f) {};
+};
+
+namespace ToolFramework {
+  static bool json_encode_r(std::ostream& stream, const User1& user, adl_tag tag) {
+    return json_encode_r(stream, user.field, tag);
+  };
+
+  static bool json_decode_r(const char*& input, User1& user, adl_tag tag) {
+    const char* i = input;
+    if (!json_decode_r(i, user.field, tag)) return false;
+    input = i;
+    return true;
+  };
+};
+
+// Custom user class with implemented input/output operators
+struct User2: public User {
+  User2() {};
+  User2(const char* f): User(f) {};
+};
+
+static std::ostream& operator<<(std::ostream& output, const User2& user) {
+  return output << user.field;
+};
+
+static std::istream& operator>>(std::istream& input, User2& user) {
+  return input >> user.field;
+};
+
+// Custom user class with implemented both json encode/decode and input/output
+// operators
+struct User3: public User {
+  User3() {};
+  User3(const char* f): User(f) {};
+};
+
+namespace ToolFramework {
+  static bool json_encode_r(
+      std::ostream& stream, const User3& user, adl_tag tag
+  ) {
+    return json_encode_r(stream, user.field, tag);
+  };
+
+  static bool json_decode_r(
+      const char*& input, User3& user, adl_tag tag
+  ) {
+    const char* i = input;
+    if (!json_decode_r(i, user.field, tag)) return false;
+    input = i;
+    return true;
+  };
+};
+
+static std::ostream& operator<<(std::ostream& output, const User3& user) {
+  return output << user.field;
+};
+
+static std::istream& operator>>(std::istream& input, User3& user) {
+  return input >> user.field;
+};
+
+// Custom user class with json encode/decode implemented through inheritance
+struct User4: public User1 {
+  User4() {};
+  User4(const char* f): User1(f) {};
+};
+
+// Custom user class with both json encode/decode and input/output operators
+// implemented through inheritance
+struct User5: public User3 {
+  User5() {};
+  User5(const char* f): User3(f) {};
+};
+
+// Custom user class with json encode/decode implemented through inheritance
+// and custom input/output operators
+struct User6: public User1 {
+  User6() {};
+  User6(const char* f): User1(f) {};
+};
+
+static std::ostream& operator<<(std::ostream& output, const User6& user) {
+  return output << user.field;
+};
+
+static std::istream& operator>>(std::istream& input, User6& user) {
+  return input >> user.field;
+};
+
+template <typename T, typename Eq = std::equal_to<T>>
+static bool test_var(
+    const char* key,
+    const T& value,
+    const char* json = nullptr,
+    Eq eq = std::equal_to<T>(),
+    const std::function<void (std::ostream&, const T&)>& printer
+      = [](std::ostream& stream, const T& value) { stream << value; }
+) {
+  auto log = [&]() -> std::ostream& {
+    std::cout
+      << "test_var<"
+      << typeid(T).name()
+      << "> `"
+      << key
+      << '\'';
+    if (printer) {
+      std::cout << " `";
+      printer(std::cout, value);
+      std::cout << '\'';
+    };
+    return std::cout << ": ";
+  };
+
+  Store store;
+  store.Set(key, value);
+
+  T value2;
+  store.Get(key, value2);
+  if (!eq(value, value2)) {
+    log() << "Get returned `";
+    printer(std::cout, value2);
+    std::cout << "'. Store contents:\n";
+    store.Print();
+    return false;
+  };
+
+  std::string json2;
+  store >> json2;
+  if (json && !json_eq(json, json2.c_str())) {
+    log()
+      << "JSON mismatch: expected `"
+      << json
+      << "', got `"
+      << json2
+      << "'. Store contents:\n";
+    store.Print();
+    return false;
+  };
+
+  Store store2;
+  if (!store2.JsonParser(json2)) {
+    log() << "JsonParser failed on `" << json2 << "'\n";
+    return false;
+  };
+
+  store2.Get(key, value2);
+  if (!eq(value, value2)) {
+    log() << "Get after deserialization returned `";
+    printer(std::cout, value2);
+    std::cout << "'\n";
+    return false;
+  };
+
+  return true;
+};
+
+static bool test_json(
+    const char* json,
+    bool valid = true,
+    const char* expected = nullptr
+) {
+  if (!expected) expected = json;
+
+  auto log = [&]() -> std::ostream& {
+    return std::cout << "test_json `" << json << "': ";
+  };
+
+  Store store;
+  if (store.JsonParser(json) != valid) {
+    log()
+      << "JsonParser "
+      << (valid ? "failed" : "unexpectedly succeeded")
+      << '\n';
+    return false;
+  };
+
+  std::string json2;
+  store >> json2;
+
+  if (!json_eq(expected, json2.c_str())) {
+    log() << "JSON mismatch: got `" << json2 << "'\n";
+    return false;
+  };
+
+  return true;
+};
+
+int main(int argc, char** argv) {
+  Tester t;
+
+  t(test_var("a", 1, "{\"a\":1}"));
+  t(test_var("b", static_cast<short>(2), "{\"b\":2}"));
+  t(test_var("c", 3L, "{\"c\":3}"));
+  t(test_var("d", 4.4f, "{\"d\":4.4}"));
+  t(test_var("e", 5.5, "{\"e\":5.5}"));
+  t(test_var("f", true, "{\"f\":1}"));
+  t(test_var("g", 'h', "{\"g\":\"h\"}"));
+  t(test_var<std::string>("h", "hello world", "{\"h\":\"hello world\"}"));
+
+  // TODO: make it work with const char*
+  t(test_var<std::string>("i", "q \" w", "{\"i\":\"q \\\" w\"}"));
+
+  {
+    Store s;
+    s.Set("a", "q } w");
+    t(test_var("j", s, "{\"j\":{\"a\":\"q } w\"}}"));
+  };
+
+  t(test_var<std::string>("k", "{\"a\":{\"q } w\"}}", "{\"k\":\"{\\\"a\\\":{\\\"q } w\\\"}}\"}"));
+  t(test_var("l", std::vector<int> { 42, 11 }, "{\"l\":[42,11]}"));
+
+  t(
+      test_var(
+        "m",
+        std::vector<float> { -2.5e-10, -0.1, 0.1, 2.5e10 },
+        "{\"m\":[-2.5e-10,-0.1,0.1,2.5e+10]}"
+      )
+  );
+
+  {
+    Store s;
+    s.Set("x", std::vector<int> { -5, 5 });
+    s.Set("y", std::vector<float> { 0, 1.333 });
+    t(test_var("n", s, "{\"n\":{\"x\":[-5,5],\"y\":[0,1.333]}}"));
+  };
+
+  t(
+      test_var(
+        "o",
+        std::vector<std::string> { "qwe , asd", "q \"}] w" },
+        "{\"o\":[\"qwe , asd\",\"q \\\"}] w\"]}"
+      )
+  );
+
+  t(
+      test_var(
+        "p",
+        std::vector<std::vector<int>> { { 1, 2 }, { -1, -2 } },
+        "{\"p\":[[1,2],[-1,-2]]}"
+      )
+  );
+
+  t(
+      test_var(
+        "q",
+        std::map<std::string, std::string> {
+          { "a", "qwe" },
+          { "q \" w", "x } z" }
+        },
+        "{\"q\":{\"a\":\"qwe\",\"q \\\" w\":\"x } z\"}}"
+      )
+  );
+
+  t(
+      test_var(
+        "r",
+        std::vector<std::map<std::string, std::vector<int>>> {
+          {
+            { "a", { 1, 2 } },
+            { "b", { -1, -2 } }
+          },
+          {
+            { "q \" w", { 0, 42 } },
+            { "x ] z", { 15, 11 } }
+          }
+        },
+        "{\"r\":[{\"a\":[1,2],\"b\":[-1,-2]},{\"q \\\" w\":[0,42],\"x ] z\":[15,11]}]}"
+      )
+  );
+
+  t(
+      test_var(
+        "user1",
+        User1("user1"),
+        "{\"user1\":\"user1\"}",
+        std::equal_to<User1>(),
+        std::function<void (std::ostream&, const User1&)>(print)
+      )
+  );
+
+  t(
+      test_var(
+        "user2",
+        User2("user2"),
+        "{\"user2\":\"user2\"}",
+        std::equal_to<User2>(),
+        std::function<void (std::ostream&, const User2&)>(print)
+      )
+  );
+
+  t(
+      test_var(
+        "user3",
+        User3("user3"),
+        "{\"user3\":\"user3\"}",
+        std::equal_to<User3>(),
+        std::function<void (std::ostream&, const User3&)>(print)
+      )
+  );
+
+  t(
+      test_var(
+        "user4",
+        User4("user4"),
+        "{\"user4\":\"user4\"}",
+        std::equal_to<User4>(),
+        std::function<void (std::ostream&, const User4&)>(print)
+      )
+  );
+
+  t(
+      test_var(
+        "user5",
+        User5("user5"),
+        "{\"user5\":\"user5\"}",
+        std::equal_to<User5>(),
+        std::function<void (std::ostream&, const User5&)>(print)
+      )
+  );
+
+  t(
+      test_var(
+        "user6",
+        User6("user6"),
+        "{\"user6\":\"user6\"}",
+        std::equal_to<User6>(),
+        std::function<void (std::ostream&, const User6&)>(print)
+      )
+  );
+
+  t(
+      test_json(
+        "{\"key\":[{\"a\":{\"b\":[1,false]}},{\"a\":{\"b\":[null,-2.5e-2]}}]}"
+      )
+  );
+
+  // adapted from https://github.com/briandfoy/json-acceptance-tests, pass1
+  {
+    const char* json =
+      "{\n"
+"        \"integer\": 1234567890,\n"
+"        \"real\": -9876.543210,\n"
+"        \"e\": 0.123456789e-12,\n"
+"        \"E\": 1.234567890E+34,\n"
+"        \"\":  23456789012E66,\n"
+"        \"zero\": 0,\n"
+"        \"one\": 1,\n"
+"        \"space\": \" \",\n"
+"        \"quote\": \"\\\"\",\n"
+"        \"backslash\": \"\\\\\",\n"
+"        \"controls\": \"\\b\\f\\n\\r\\t\",\n"
+"        \"slash\": \"/ & \\/\",\n"
+"        \"alpha\": \"abcdefghijklmnopqrstuvwyz\",\n"
+"        \"ALPHA\": \"ABCDEFGHIJKLMNOPQRSTUVWYZ\",\n"
+"        \"digit\": \"0123456789\",\n"
+"        \"0123456789\": \"digit\",\n"
+"        \"special\": \"`1~!@#$%^&*()_+-={':[,]}|;.</>?\",\n"
+"        \"hex\": \"\\u0123\\u4567\\u89AB\\uCDEF\\uabcd\\uef4A\",\n"
+"        \"true\": true,\n"
+"        \"false\": false,\n"
+"        \"null\": null,\n"
+"        \"array\":[  ],\n"
+"        \"object\":{  },\n"
+"        \"address\": \"50 St. James Street\",\n"
+"        \"url\": \"http://www.JSON.org/\",\n"
+"        \"comment\": \"// /* <!-- --\",\n"
+"        \"# -- --> */\": \" \",\n"
+"        \" s p a c e d \" :[1,2 , 3\n"
+"\n"
+",\n"
+"\n"
+"4 , 5        ,          6           ,7        ],\"compact\":[1,2,3,4,5,6,7],\n"
+"        \"jsontext\": \"{\\\"object with 1 member\\\":[\\\"array with 1 element\\\"]}\",\n"
+"        \"quotes\": \"&#34; \\u0022 %22 0x22 034 &#x22;\",\n"
+"        \"\\/\\\\\\\"\\uCAFE\\uBABE\\uAB98\\uFCDE\\ubcda\\uef4A\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?\"\n"
+": \"A key can be any string\"\n"
+"    }"
+    ;
+
+    const char* expected =
+"      {\n"
+"              \"\":  23456789012E66,\n"
+"              \" s p a c e d \" :[1,2 , 3\n"
+"\n"
+"      ,\n"
+"\n"
+"      4 , 5        ,          6           ,7        ],\n"
+"              \"# -- --> */\": \" \",\n"
+"              \"/\\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?\"\n"
+"      : \"A key can be any string\",\n"
+"              \"0123456789\": \"digit\",\n"
+"              \"ALPHA\": \"ABCDEFGHIJKLMNOPQRSTUVWYZ\",\n"
+"              \"E\": 1.234567890E+34,\n"
+"              \"address\": \"50 St. James Street\",\n"
+"              \"alpha\": \"abcdefghijklmnopqrstuvwyz\",\n"
+"              \"array\":[  ],\n"
+"              \"backslash\": \"\\\\\",\n"
+"              \"comment\": \"// /* <!-- --\","
+"\"compact\":[1,2,3,4,5,6,7],\n"
+"              \"controls\": \"\\b\\f\\n\\r\\t\",\n"
+"              \"digit\": \"0123456789\",\n"
+"              \"e\": 0.123456789e-12,\n"
+"              \"false\": 0,\n"
+"              \"hex\": \"\\u0123Eg\\u89ab\\ucdef\\uabcd\\uef4a\",\n"
+"              \"integer\": 1234567890,\n"
+"              \"jsontext\": \"{\\\"object with 1 member\\\":[\\\"array with 1 element\\\"]}\",\n"
+"              \"null\": 0,\n"
+"              \"object\":{  },\n"
+"              \"one\": 1,\n"
+"              \"quote\": \"\\\"\",\n"
+"              \"quotes\": \"&#34; \\\" %22 0x22 034 &#x22;\",\n"
+"              \"real\": -9876.543210,\n"
+"              \"slash\": \"/ & /\",\n"
+"              \"space\": \" \",\n"
+"              \"special\": \"`1~!@#$%^&*()_+-={':[,]}|;.</>?\",\n"
+"              \"true\": 1,\n"
+"              \"url\": \"http://www.JSON.org/\",\n"
+"              \"zero\": 0\n"
+"      }\n"
+    ;
+
+    t(test_json(json, true, expected));
+  };
+
+  if (t) std::cout << "ok\n";
+
+  return 0;
+};
diff --git a/src/Store/Store.cpp b/src/Store/Store.cpp
index 8c9fb39..bd37e56 100644
--- a/src/Store/Store.cpp
+++ b/src/Store/Store.cpp
@@ -1,3 +1,6 @@
+#include <iomanip>
+#include <memory>
+
 #include "Store.h"
 
 namespace ToolFramework {
@@ -61,62 +64,58 @@ namespace ToolFramework {
     
     
   }
-  
-  
-  void Store::JsonParser(std::string input){ 
-    
-    int type=0;
-    std::string key="";
-    std::string value="";
-    int bracket_counter=0;
 
-    for(std::string::size_type i = 0; i < input.size(); ++i) {
-      
-      //std::cout<<"i="<<i<<" , "<<input[i]<<" , type="<<type<<std::endl;
-      
-      //type 0011112233444444550011112233333333001111223366666665500111122337777777555
-      //     { "key" : "value" , "key" : value , "key" : {......} , "key" : [......] }
-      
-      // types: 0 - pre key
-      //        1 - key
-      //        2 - postkey
-      //        3 - value
-      //        4 - string value
-      //        5 - post value
-      //        6 - object
-      //        7 - array
-      
-      if ((input[i] == '\n' || input[i] == '\r') && type != 4) continue;
-      
-      if(input[i]=='\"' && type<5){
-	if(type==4) value+='"';
-	type++;
-	if(type==4) value+='"';
-      }
-      else if(type==1) key+=input[i];
-      else if(input[i]==':' && type==2) type=3;   
-      else if((input[i]==',' || input[i]=='}') && (type==5 || type==3)){
-	type=0;
-	//std::cout<<"key="<<key<<" , value="<<value<<std::endl;
-	m_variables[key]=value;
-	key="";
-	value="";
-      }
-      else if(type==3  && !(input[i]==' ' || input[i]=='{' || input[i]=='[')) value+=input[i];
-      else if(type==3  && input[i]=='{'){ value+=input[i]; type=6; }
-      else if(type==4  && input[i]=='{'){ value.replace(value.length()-1, 1, "{"); type=6; }
-      else if(type==6  && input[i]=='{'){ value+=input[i]; bracket_counter++; }
-      else if(type==6  && input[i]=='}'){ value+=input[i]; bracket_counter--;if(bracket_counter==-1){ type=5; bracket_counter=0;} }
-      else if(type==3  && input[i]=='['){ value+=input[i]; type=7; }
-      else if(type==7  && input[i]=='['){ value+=input[i]; bracket_counter++; }
-      else if(type==7  && input[i]==']'){ value+=input[i]; bracket_counter--;if(bracket_counter==-1){ type=5; bracket_counter=0;} }
-      else if(type==4 || type==6 || type==7) value+=input[i];
-    }
-    
-  }
-  
+  bool Store::JsonParser(const char* input) {
+    bool result = json_decode_object(
+        input,
+        [this](const char*& input_, std::string key) -> bool {
+          const char* i = input_;
+          i = json_scan_whitespace(i);
+          switch (*i) {
+            case '"':
+              {
+                std::string value;
+                if (!json_internal::json_decode_string(i, value, true))
+                  return false;
+                m_variables[std::move(key)] = std::move(value);
+              };
+              break;
+            case 'f':
+              i = json_scan_token(i, "false");
+              if (!i) return false;
+              m_variables[std::move(key)] = "0";
+              break;
+            case 't':
+              i = json_scan_token(i, "true");
+              if (!i) return false;
+              m_variables[std::move(key)] = "1";
+              break;
+            case 'n':
+              i = json_scan_token(i, "null");
+              if (!i) return false;
+              m_variables[std::move(key)] = "0";
+              break;
+            default:
+              const char* value = i;
+              i = json_scan(i);
+              if (!i) return false;
+              m_variables[std::move(key)] = std::string(value, i);
+          };
+          input_ = i;
+          return true;
+        }
+    );
+    if (!result) return false;
 
+    input = json_scan_whitespace(input);
+    if (!input || *input) return false; // junk at the end
+    return true;
+  };
   
+  bool Store::JsonParser(const std::string& input) {
+    return JsonParser(input.c_str());
+  }
+
   bool Store::Has(std::string key){
     
     return (m_variables.count(key)!=0);
@@ -139,64 +138,6 @@ namespace ToolFramework {
   }
   
   
-  bool Store::Get(std::string name, std::string &out){
-    if(m_variables.count(name)>0){ 
-      out=StringStrip(m_variables[name]);
-      return true;
-    }
-    return false;
-  }
-  
-  bool Store::Get(std::string name, bool &out){
-    if(m_variables.count(name)>0){
-      std::string tmp=StringStrip(m_variables[name]);
-      if(tmp=="true") out=true;
-      else if(tmp=="false") out=false;
-      else if(tmp=="" || tmp=="0") out=false;
-      else out=true;
-      return true;
-      
-    }
-    return false;
-    
-  }
-  
-  bool Store::Get(std::string name, Store &out){
-    if(m_variables.count(name)>0 && StringStrip(m_variables[name])[0]=='{'){
-      out.JsonParser(StringStrip(m_variables[name]));
-      return true;
-    }
-    return false;
-    
-  }
-  
-  void Store::Set(std::string name, std::string in){
-    std::stringstream stream;
-    stream<<"\""<<in<<"\"";
-    m_variables[name]=stream.str();
-  }
-  
-  void Store::Set(std::string name, const char* in){
-    std::stringstream stream;
-    stream<<"\""<<in<<"\"";
-    m_variables[name]=stream.str();
-  }
-  
-  void Store::Set(std::string name,std::vector<std::string> in){
-    std::stringstream stream;
-    std::string tmp="[";
-    for(unsigned int i=0; i<in.size(); i++){
-      stream<<"\""<<in.at(i)<<"\"";
-      tmp+=stream.str();
-      if(i!=in.size()-1)tmp+=',';
-      stream.str("");
-      stream.clear();
-    }
-    tmp+=']';
-    m_variables[name]=tmp;
-    
-  }
-  
   std::string Store::StringStrip(std::string in){
     
     if(in.length() && in[0]=='"' && in[in.length()-1]=='"') return in.substr(1,in.length()-2);
@@ -211,21 +152,42 @@ namespace ToolFramework {
     return true;
     
   }
-  
-  std::ostream& operator<<(std::ostream& stream, const Store& s){
-    stream<<"{";
-    bool first=true;
-    for(auto it=s.m_variables.begin(); it!=s.m_variables.end(); ++it){
-      if (!first) stream<<", ";
-      stream<<"\""<<it->first<<"\":"<< it->second;
-      first=false;
-    }
-    stream<<"}";
+
+  void Store::operator>>(std::string& out) const {
+    std::stringstream ss;
+    ss << *this;
+    out = ss.str();
+  }
+
+  std::ostream& operator<<(std::ostream& stream, const Store& store) {
+    bool comma = false;
+    stream << '{';
+    for (const auto& kv : store) {
+      if (comma)
+        stream << ',';
+      else
+        comma = true;
+
+      json_encode(stream, kv.first);
+      stream << ':';
+      char c = kv.second.empty() ? 0 : kv.second[0];
+      if (c == '{' || c == '[')
+        stream << kv.second;
+      else if (c == '"')
+        json_encode(stream, kv.second.begin() + 1, kv.second.end() - 1);
+      else {
+        const char* s = json_scan_number(kv.second.c_str());
+        s = json_scan_whitespace(s);
+        if (s && !*s)
+          stream << kv.second;
+        else
+          json_encode(stream, kv.second);
+      };
+    };
+    stream << '}';
     return stream;
   }
   
-  
-  
   bool Store::Erase(std::string key){
     
     return m_variables.erase(key);
diff --git a/src/Store/Store.h b/src/Store/Store.h
index e89f7cd..f860588 100644
--- a/src/Store/Store.h
+++ b/src/Store/Store.h
@@ -6,7 +6,9 @@
 #include <vector>
 #include <map>
 #include <iostream>
-#include <sstream> 
+#include <sstream>
+
+#include "Json.h"
 
 namespace ToolFramework{
 
@@ -26,7 +28,8 @@ namespace ToolFramework{
     Store(); ////< Sinple constructor
     
     bool Initialise(std::string filename); ///< Initialises Store by reading in entries from an ASCII text file, when each line is a variable and its value in key value pairs.  @param filename The filepath and name to the input file.
-    void JsonParser(std::string input); ///<  Converts a flat JSON formatted string to Store entries in the form of key value pairs.  @param input The input flat JSON string.
+    bool JsonParser(const char* input);
+    bool JsonParser(const std::string& input); ///<  Converts a flat JSON formatted string to Store entries in the form of key value pairs.  @param input The input flat JSON string.
     void Print(); ///< Prints the contents of the Store.
     void Delete(); ///< Deletes all entries in the Store.
     bool Has(std::string key); ///<Returns bool based on if store contains entry given by sting @param string key to comapre.
@@ -34,89 +37,6 @@ namespace ToolFramework{
     bool Destring(std::string key); //convers an element from a string by stripping the speachmarks @param string key to comapre.
     bool Erase(std::string key);
     
-    /**
-       Templated getter function for sore content. Assignment is templated and via reference.
-       @param name The ASCII key that the variable in the Store is stored with.
-       @param out The variable to fill with the value.
-       @return Return value is true if varaible exists in the Store and correctly assigned to out and false if not.
-    */
-    template<typename T> bool Get(std::string name,T &out){
-      
-      if(m_variables.count(name)>0){
-	
-	std::stringstream stream(StringStrip(m_variables[name]));
-	stream>>out;
-	return !stream.fail();
-      }
-      
-      return false;
-      
-    }
-
-    /**
-       Templated getter function for sore vector/array content. Assignment is templated and via reference.
-       @param name The ASCII key that the variable in the Store is stored with.
-       @param out The variable to fill with the value.
-       @return Return value is true if varaible exists in the Store and correctly assigned to out and false if not.
-    */
-    template<typename T> bool Get(std::string name,std::vector<T> &out){
-
-      std::string stripped = StringStrip(m_variables[name]);
-
-      if(m_variables.count(name)>0 && stripped[0]=='['){
-	std::stringstream stream;
-	out.clear();
-	  
-	for(unsigned int i=1; i<stripped.length(); i++){
-	  if(stripped[i]!=',' && stripped[i]!=']'){
-	    if(stripped[i]!='"') stream.put(stripped[i]);
-	  }
-	  else {
-	    T tmp;
-	    stream>>tmp;
-	    if(stream.fail()){
-	      out.clear();
-	      return false;
-	    }
-	    stream.str("");
-	    stream.clear();
-	    out.push_back(tmp);
-	  }
-	  
-	}
-	return true;
-	
-      }
-      
-      return false;
-      
-    }
-    
-    /**
-       getter function for string content..
-       @param name The ASCII key that the variable in the Store is stored with.
-       @param out The variable to fill with the value.
-       @return Return value is true if varaible exists in the Store and correctly assigned to out and false if not.
-    */
-    bool Get(std::string name, std::string &out);
-
-        /**
-       getter function for bool content..
-       @param name The ASCII key that the variable in the Store is stored with.
-       @param out The variable to fill with the value.
-       @return Return value is true if varaible exists in the Store and correctly assigned to out and false if not.
-    */
-    bool Get(std::string name, bool &out);
-
-        /**
-       getter function for store content..
-       @param name The ASCII key that the variable in the Store is stored with.
-       @param out The variable to fill with the value.
-       @return Return value is true if varaible exists in the Store and correctly assigned to out and false if not.
-    */
-    bool Get(std::string name, Store &out);
-
-    
     /**
        Templated getter function for store content. 
        @param name The ASCII key that the variable in the Store is stored with.
@@ -124,71 +44,36 @@ namespace ToolFramework{
     */
     template<typename T> T Get(std::string name){
       
-      T tmp;
+      T tmp {};
       if(!Get(name,tmp)) std::cout<<"\033[38;5;196mERROR: Store doesnt hold value \""<<name<<"\" default returned\033[0m"<<std::endl;
       
       return tmp;
       
     }
-
     
-    
-    /**
-       Templated setter function to assign vairables in the Store.
-       @param name The key to be used to store and reference the variable in the Store.
-       @param in the varaible to be stored.
-    */
-    template<typename T> void Set(std::string name,T in){
-      std::stringstream stream;
-      stream<<in;
-      m_variables[name]=stream.str();
-    }
-
     /**
-       string setter function to assign vairables in the Store.
-       @param name The key to be used to store and reference the variable in the Store.
-       @param in the varaible to be stored.
+       Get a value from Store and put it into out.
+       @param name The key name.
+       @param out Variable to assign the value to.
+       @return false if the key does not exit or the value could not be deserialized to this type. In the latter case, out may or may not be changed.
     */
-
-    void Set(std::string name, std::string in);
+    template <typename T>
+    bool Get(const std::string& name, T& out) const {
+      auto i = m_variables.find(name);
+      if (i == m_variables.end()) return false;
+      return deserialize(i->second, out);
+    };
 
     /**
-       string setter function to assign vairables in the Store.
-       @param name The key to be used to store and reference the variable in the Store.
-       @param in the varaible to be stored.
+       Assign a value to a key.
+       @param name The key name.
+       @param value The value.
     */
+    template <typename T>
+    void Set(const std::string& name, const T& value) {
+      m_variables[name] = serialize(value);
+    };
 
-    void Set(std::string name, const char* in);
-
-    /**
-       Templated setter function to assign vairables in the Store from a vector.
-       @param name The key to be used to store and reference the variable in the Store.
-       @param in the varaible to be stored.
-    */
-    
-    template<typename T> void Set(std::string name,std::vector<T> in){
-     
-      std::stringstream stream;
-      std::string tmp="[";
-      for(unsigned int i=0; i<in.size(); i++){
-	stream<<in.at(i);
-	tmp+=stream.str();
-	if(i!=in.size()-1)tmp+=',';
-	stream.str("");
-	stream.clear();	
-      }
-      tmp+=']';
-      m_variables[name]=tmp;
-      
-    }
-
-    /**
-       string setter function to assign vairables in the Store from a vector.
-       @param name The key to be used to store and reference the variable in the Store.
-       @param in the varaible to be stored.
-    */
-    
-    void Set(std::string name,std::vector<std::string> in);
     /**
        Returns string pointer to Store element.
        @param key The key of the string pointer to return.
@@ -201,37 +86,179 @@ namespace ToolFramework{
     /**
        Allows streaming of a flat JASON formatted string of Store contents.
     */
-    template<typename T> void operator>>(T& obj){
-
-      std::stringstream stream;
-      stream<<"{";
-      bool first=true;
-      for (std::map<std::string,std::string>::iterator it=m_variables.begin(); it!=m_variables.end(); ++it){
-	if (!first) stream<<", ";
-	stream<<"\""<<it->first<<"\":"<< it->second;
-	
-	first=false;
-      }
-      stream<<"}";
-      
-      obj=stream.str();
-      
-    } 
-    
-    friend std::ostream& operator<<(std::ostream &stream, const Store &s);
+    void operator>>(std::string&) const;
     
     std::map<std::string, std::string>::iterator begin() { return m_variables.begin(); }
     std::map<std::string, std::string>::iterator end()   { return m_variables.end(); }
     
+    std::map<std::string, std::string>::const_iterator begin() const { return m_variables.begin(); };
+    std::map<std::string, std::string>::const_iterator end()   const { return m_variables.end();   };
+
+    std::map<std::string, std::string>::const_iterator cbegin() const { return m_variables.cbegin(); };
+    std::map<std::string, std::string>::const_iterator cend()   const { return m_variables.cend();   };
     
-  private:
     
+  private:
+
+    template <typename, typename = int>
+    struct json_encode_exists : std::false_type {};
+
+    template <typename T>
+    struct json_encode_exists<
+      T,
+      decltype(
+          json_encode_r(
+            std::declval<std::ostream&>(),
+            std::declval<T>(),
+            std::declval<adl_tag>()
+          ),
+          0
+      )
+    > : std::true_type {};
+
+    template <typename, typename = int>
+    struct json_decode_exists : std::false_type {};
+
+    template <typename T>
+    struct json_decode_exists<
+      T,
+      decltype(
+          json_decode_r(
+            std::declval<const char*&>(),
+            std::declval<T&>(),
+            std::declval<adl_tag>()
+          ),
+          0
+      )
+    > : std::true_type {};
     
     std::map<std::string,std::string> m_variables;
     std::string StringStrip(std::string in);
-    
+
+    template <typename T>
+    static
+    typename std::enable_if<!json_decode_exists<T>::value, bool>::type
+    deserialize(const std::string& value, T& out) {
+      char c = 0;
+      if (!value.empty()) {
+        c = value[0];
+        if (c == '[' || c == '{') return false;
+      };
+
+      std::stringstream ss;
+      if (c == '"')
+        ss.str(value.substr(1, value.size() - 2));
+      else
+        ss.str(value);
+
+      ss >> out;
+      return !ss.fail();
+    }
+
+    template <typename T>
+    static
+    typename std::enable_if<json_decode_exists<T>::value, bool>::type
+    deserialize(const std::string& value, T& out) {
+      const char* s = value.c_str();
+      return json_decode(s, out);
+    }
+
+    template <typename T>
+    static bool deserialize(const std::string& value, std::vector<T>& out) {
+      if (value.empty() || value[0] != '[') return false;
+      const char* v = value.c_str();
+      return json_decode(v, out);
+    }
+
+    static bool deserialize(const std::string& value, std::string& out) {
+      char c = value.empty() ? 0 : value[0];
+      if (c == '{' || c == '[') return false;
+      if (c == '"')
+        out.assign(value.begin() + 1, value.end() - 1);
+      else
+        out = value;
+      return true;
+    }
+
+    static bool deserialize(const std::string& value, char& out) {
+      if (value.empty()) return false;
+      switch (value[0]) {
+        case '[':
+        case '{':
+          return false;
+        case '"':
+          if (value.size() < 2) return false;
+          out = value[1];
+          break;
+        default:
+          out = value[0];
+      };
+      return true;
+    }
+
+    static bool deserialize(const std::string& value, Store& out) {
+      if (value.empty() || value[0] != '{') return false;
+      // out.m_variables.clear() ?
+      return out.JsonParser(value);
+    }
+
+    template <typename T>
+    static
+    typename std::enable_if<!json_encode_exists<T>::value, std::string>::type
+    serialize(const T& value) {
+      std::stringstream ss;
+      ss << value;
+      std::string result = ss.str();
+      if (result.empty()) return result;
+      char r = result[0];
+      if (r == '"' || r == '[' || r == '{')
+        json_encode(result, ss.str());
+      return result;
+    }
+
+    template <typename T>
+    static
+    typename std::enable_if<json_encode_exists<T>::value, std::string>::type
+    serialize(const T& value) {
+      std::string result;
+      json_encode(result, value);
+      return result;
+    }
+
+    template <typename T>
+    static std::string serialize(const std::vector<T>& value) {
+      std::string result;
+      json_encode(result, value);
+      return result;
+    }
+
+    static std::string serialize(const char* value) {
+      std::stringstream ss;
+      ss << '"' << value << '"';
+      return ss.str();
+    }
+
+    static std::string serialize(const std::string& value) {
+      return serialize(value.c_str());
+    }
+
+    static std::string serialize(char value) {
+      if (value == '"') return "\"\\\"\"";
+      if (value == '[') return "\"[\"";
+      if (value == '{') return "\"{\"";
+      return std::string(1, value);
+    }
+
+    static std::string serialize(const Store& value) {
+      std::string result;
+      value >> result;
+      return result;
+    }
+
   };
-  
+
+  std::ostream& operator<<(std::ostream&, const Store&);
+
 } // end ToolFramework namespace
   
 

From ce368318232fee5f935cc4d729a4a5e283f8b699 Mon Sep 17 00:00:00 2001
From: Evgenii Zhemchugov <evgenii.zhemchugov@warwick.ac.uk>
Date: Wed, 4 Jun 2025 13:44:10 +0100
Subject: [PATCH 3/4] Store::Initialise: fix some edge cases and make
 consistent with the new store contents

Calling Initialise on a file setting an integer variable, e.g.,

    var 1

resulted in this variable stored as "1" and interpreted as a string, so
Get<int>("1") returned 0 (json_decode failed to parse "1" as a number).
This is inconsistent both with the previous and the new behaviours where
numbers set with `Set` are stored unquoted. This patch updates
Initialise to store a value as is, unless it begins with a `"`, or it
begins with a `[` or `{` and is not a valid JSON object. In these cases
the value is quoted.

Also:

* Initialise now does not drop the whitespace in the value, so

    var a string with a   tab and a   long space

does not result in `a string with a tab and a long space`.

* Comments, newlines, and spaces at the end can now be escaped:

    escaped_comment test \# test
    escaped_newline test \
    test2
    escaped_whitespace test \

* One backward incompatible change is that a space is now not required
  before an inline comment:

    var val#ue

now results in `val` rather than `val#ue`.

StoreTest has been updated to test for these cases.
---
 UnitTests/StoreTest.cpp | 115 +++++++++++++++++++++++++++++++++
 src/Store/Store.cpp     | 136 ++++++++++++++++++++++++++++------------
 src/Store/Store.h       |   2 +-
 3 files changed, 213 insertions(+), 40 deletions(-)

diff --git a/UnitTests/StoreTest.cpp b/UnitTests/StoreTest.cpp
index a1bca34..a8ee1cd 100644
--- a/UnitTests/StoreTest.cpp
+++ b/UnitTests/StoreTest.cpp
@@ -3,6 +3,8 @@
 
 #include <string.h>
 
+#include <unistd.h>
+
 #include <Store.h>
 
 using ToolFramework::Store;
@@ -282,6 +284,117 @@ static bool test_json(
   return true;
 };
 
+template <typename T>
+static bool test_initialise_check(
+    Store& store, const char* key, const T& expected
+) {
+  T x = store.Get<T>(key);
+  if (x != expected) {
+    std::cout
+      << "test_initialise "
+      << key
+      << ": expected `"
+      << expected
+      << "', got `"
+      << x
+      << "'\n";
+    return false;
+  };
+  return true;
+};
+
+static bool test_initialise() {
+  const char* tmpdir = getenv("TMPDIR");
+  if (!tmpdir) tmpdir = "/tmp";
+  std::string tmp(tmpdir);
+  tmp += "/StoreTest.XXXXXX";
+
+  int fd = mkstemp(&tmp[0]);
+  if (fd == -1) {
+    std::cout
+      << "test_initialise: cannot create a temporary file "
+      << tmp
+      << ": "
+      << strerror(errno)
+      << '\n';
+    return false;
+  };
+
+  const char* data =
+    "int 1\n"
+    "float 2.71828e0\n"
+    "string test\n"
+    "long_string a string with several words, a\ttab and a    long space  \n"
+    "vector<int> [1, 2, 3, 4]\n"
+    "inline_comment test # test2\n"
+    "inword_comment test#test2\n"
+    "escaped_comment test\\#test2\n"
+    "escaped_newline test\\\n"
+    "test2\n"
+    "escaped_whitespace test   \\ \n"
+  ;
+
+  size_t size = strlen(data);
+  ssize_t ssize = write(fd, data, size);
+  if (ssize != static_cast<ssize_t>(size)) {
+    std::cout
+      << "test_initialise: write to temporary file "
+      << tmp
+      << " returned "
+      << ssize
+      << " (expected "
+      << size
+      << "): "
+      << strerror(errno)
+      << '\n';
+    close(fd);
+    unlink(tmp.c_str());
+    return false;
+  };
+
+  if (close(fd) == -1) {
+    std::cout
+      << "test_initialise: close of temporary file "
+      << tmp
+      << " failed: "
+      << strerror(errno)
+      << '\n';
+    unlink(tmp.c_str());
+    return false;
+  };
+
+  Tester t;
+
+  try {
+    Store store;
+    store.Initialise(tmp);
+
+#define check(type, key, value) t(test_initialise_check<type>(store, key, value))
+    check(int, "int", 1);
+    check(float, "float", 2.71828e0);
+    check(std::string, "string", "test");
+    check(std::string, "long_string", "a string with several words, a\ttab and a    long space");
+    check(std::vector<int>, "vector<int>", (std::vector<int> { 1, 2, 3, 4 }));
+    check(std::string, "inline_comment", "test");
+    check(std::string, "inword_comment", "test");
+    check(std::string, "escaped_comment", "test#test2");
+    check(std::string, "escaped_newline", "test\ntest2");
+    check(std::string, "escaped_whitespace", "test    ");
+#undef check
+
+    if (!t) {
+      std::cout << "Store contents:\n";
+      store.Print();
+    };
+
+    unlink(tmp.c_str());
+  } catch (...) {
+    unlink(tmp.c_str());
+  };
+
+  return t;
+};
+
 int main(int argc, char** argv) {
   Tester t;
 
@@ -519,6 +632,8 @@ int main(int argc, char** argv) {
     t(test_json(json, true, expected));
   };
 
+  t(test_initialise());
+
   if (t) std::cout << "ok\n";
 
   return 0;
diff --git a/src/Store/Store.cpp b/src/Store/Store.cpp
index bd37e56..83c1296 100644
--- a/src/Store/Store.cpp
+++ b/src/Store/Store.cpp
@@ -1,52 +1,110 @@
 #include <iomanip>
 #include <memory>
+#include <limits>
 
 #include "Store.h"
 
 namespace ToolFramework {
   
   Store::Store(){}
-  
-  
-  bool Store::Initialise(std::string filename){
-    
-    std::ifstream file(filename.c_str());
-    std::string line;
-    
-    if(file.is_open()){
-      
-      while (getline(file,line)){
-	if (line.size()>0){
-	  if (line.at(0)=='#')continue;
-	  std::string key="";
-	  std::string value="";
-	  std::stringstream stream(line);
-	  stream>>key>>value;
-	  std::string tmp;
-	  stream>>tmp;
-	  value='"'+value;
-	  
-	  while(tmp.length() && tmp[0]!='#'){
-	    value+=" "+tmp;
-	    tmp="";
-	    stream>>tmp;
-	  }
-	  value+="\"";
-	  
-	  if(value!="") m_variables[key]=value;
-	}
-	
-      }
-      file.close();
-    }
-    else{
-      std::cout<<"\033[38;5;196m WARNING!!!: Config file "<<filename<<" does not exist no config loaded \033[0m"<<std::endl;
+
+  bool Store::Initialise(const std::string& filename) {
+    std::ifstream file(filename);
+    if (!file.is_open()) {
+      std::cout
+        << "\033[38;5;196m WARNING!!!: Config file "
+        << filename
+        << " does not exist no config loaded \033[0m"
+        << std::endl;
       return false;
-    }
-  
+    };
+
+    std::string key;
+    std::vector<char> value;
+    while (file) {
+      // skip whitespace but not newline
+      int c;
+      do c = file.get();
+      while (std::isspace(c) && c != '\n');
+
+      // skip comments
+      if (c == EOF) break;
+      switch (c) {
+        case '#':
+          file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+        case '\n':
+          continue;
+        default:
+          break;
+      };
+
+      // read the key
+      file.unget();
+      file >> key;
+
+      // skip whitespace again
+      do c = file.get();
+      while (std::isspace(c) && c != '\n');
+      file.unget();
+
+      // read the value
+      bool escaped = false;
+      size_t end = 0;
+      value.clear();
+      while (true) {
+        c = file.get();
+        if (escaped) {
+          if (c == EOF) break;
+          escaped = false;
+          end = value.size();
+        } else {
+          switch (c) {
+            case '#':
+              file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            case '\n':
+            case EOF:
+              goto value_read;
+            case '\\':
+              escaped = true;
+              continue;
+            default:
+              break;
+          };
+          if (!isspace(c)) end = value.size();
+        };
+        value.push_back(c);
+      };
+value_read:
+      // XXX: backslash at the end of the file --- ignore?
+      // if (escaped) value.push_back();
+
+      // delete whitespace at the end
+      value.erase(value.begin() + static_cast<ssize_t>(end) + 1, value.end());
+
+      value.push_back('\0');
+
+      if (!value.empty()) {
+        if (value[0] == '{' || value[0] == '[') {
+          const char* s = json_scan(value.data());
+          s = json_scan_whitespace(s);
+          if (!s || *s) {
+            // invalid JSON. Throw an error? Return false?
+            Set(key, value.data()); // store as a string
+            continue;
+          };
+        } else if (value[0] == '"') {
+          // quote to avoid confusion
+          Set(key, value.data());
+          continue;
+        };
+      };
+
+      m_variables[key] = value.data();
+    };
+
     return true;
-  }
-  
+  };
+
   void Store::Print(){
   
     for (std::map<std::string,std::string>::iterator it=m_variables.begin(); it!=m_variables.end(); ++it){
diff --git a/src/Store/Store.h b/src/Store/Store.h
index f860588..e8a4965 100644
--- a/src/Store/Store.h
+++ b/src/Store/Store.h
@@ -27,7 +27,7 @@ namespace ToolFramework{
     
     Store(); ////< Sinple constructor
     
-    bool Initialise(std::string filename); ///< Initialises Store by reading in entries from an ASCII text file, when each line is a variable and its value in key value pairs.  @param filename The filepath and name to the input file.
+    bool Initialise(const std::string& filename); ///< Initialises Store by reading in entries from an ASCII text file, when each line is a variable and its value in key value pairs.  @param filename The filepath and name to the input file.
     bool JsonParser(const char* input);
     bool JsonParser(const std::string& input); ///<  Converts a flat JSON formatted string to Store entries in the form of key value pairs.  @param input The input flat JSON string.
     void Print(); ///< Prints the contents of the Store.

From a5e20c7190ec3a9a6f67967c29c5370529d93b84 Mon Sep 17 00:00:00 2001
From: Evgenii Zhemchugov <evgenii.zhemchugov@warwick.ac.uk>
Date: Fri, 6 Jun 2025 17:26:21 +0100
Subject: [PATCH 4/4] Store::JsonParser: validate input before parsing

Avoid leaving Store half-filled.
---
 src/Store/Json.cpp  | 6 ++++++
 src/Store/Json.h    | 2 ++
 src/Store/Store.cpp | 6 ++++--
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/Store/Json.cpp b/src/Store/Json.cpp
index c1b2178..0f633ef 100644
--- a/src/Store/Json.cpp
+++ b/src/Store/Json.cpp
@@ -206,6 +206,12 @@ const char* json_scan(const char* input) {
   };
 }
 
+bool json_valid(const char* input) {
+  input = json_scan(input);
+  input = json_scan_whitespace(input);
+  return input && !*input;
+};
+
 bool json_decode_r(const char*& input, bool& value, adl_tag) {
   const char* i = json_scan_whitespace(input);
   if (!i) return false;
diff --git a/src/Store/Json.h b/src/Store/Json.h
index e2080a6..61a1925 100644
--- a/src/Store/Json.h
+++ b/src/Store/Json.h
@@ -100,6 +100,8 @@ const char* json_scan_object(const char* input);
 const char* json_scan_array(const char* input);
 const char* json_scan(const char* input); // generic
 
+bool json_valid(const char* input);
+
 
 // json_encode_r implements encoding of specific objects. Add overloads to this
 // function to support custom classes.
diff --git a/src/Store/Store.cpp b/src/Store/Store.cpp
index 83c1296..b29052a 100644
--- a/src/Store/Store.cpp
+++ b/src/Store/Store.cpp
@@ -124,6 +124,10 @@ namespace ToolFramework {
   }
 
   bool Store::JsonParser(const char* input) {
+    if (!json_valid(input)) return false; // invalid JSON string
+
+    // We have validated input, so in the following `return false` should never
+    // happen. We keep it, however, just in case.
     bool result = json_decode_object(
         input,
         [this](const char*& input_, std::string key) -> bool {
@@ -165,8 +169,6 @@ namespace ToolFramework {
     );
     if (!result) return false;
 
-    input = json_scan_whitespace(input);
-    if (!input || *input) return false; // junk at the end
     return true;
   };