Fix storing of a BStore in a BStore and implement JSON encoders (#24)

* BStore::BStore(const BStore&): copy slots properly

* BStore::Serialise: serialise m_variables and m_type_info

* BStore: implement JSON encoding

Implement BStore::JsonEncode methods that can be used to serialise
BStore contents in JSON format, if this representation is possible.
This requires type checking enabled. BStore::operator>> is not changed
to provide backwards compatibility and a way to serialise a BStore with
type checking disabled (only useful if all values are strings).

Functions in Json.h can also be used independently to serialise other
C++ integral types, strings, vectors and maps.

---------

Co-authored-by: Evgenii Zhemchugov <evgenii.zhemchugov@warwick.ac.uk>

Author: jini-zh

src/Store/BStore.cpp

@@ -1,5 +1,7 @@
 #include <BStore.h>
 
+#include <unordered_map>
+
 using namespace ToolFramework;
 
 ////////////////////////
@@ -48,22 +50,23 @@ BStore::BStore(const BStore &bs):m_version(1.0){
 
    if(bs.Header){
      Header = new BStore(*bs.Header);
-   }
+   } else
+     Header = nullptr;
 
    m_lookup = bs.m_lookup;
    output = bs.output;
-   m_file_end = m_file_end;
-   m_file_name = m_file_name;
-   m_open_file_end = m_open_file_end;
-   m_previous_file_end = m_previous_file_end;
-   m_type = m_type;
-   m_type_checking = m_type_checking;
-   m_has_header = m_has_header;
-   m_header_start = m_header_start;
-   m_flags_start = m_flags_start;
-   m_lookup_start = m_lookup_start;
-   m_update = m_update;  
-   m_version = m_version;
+   m_file_end = bs.m_file_end;
+   m_file_name = bs.m_file_name;
+   m_open_file_end = bs.m_open_file_end;
+   m_previous_file_end = bs.m_previous_file_end;
+   m_type = bs.m_type;
+   m_type_checking = bs.m_type_checking;
+   m_has_header = bs.m_has_header;
+   m_header_start = bs.m_header_start;
+   m_flags_start = bs.m_flags_start;
+   m_lookup_start = bs.m_lookup_start;
+   m_update = bs.m_update;
+   m_version = bs.m_version;
 
 }
 
@@ -800,7 +803,10 @@ bool BStore::Serialise(BinaryStream &bs){ // do return properly
 
   bs & output;
   bs & m_lookup;
-  GetEntry(0);
+  bs & m_variables;
+  bs & m_type_checking;
+  if (m_type_checking) bs & m_type_info;
+
   /*
   save;
 
@@ -949,3 +955,111 @@ BStore::~BStore(){
 
 
 }
+
+namespace ToolFramework {
+  bool json_encode(std::ostream& output, const BStore& store) {
+    return store.JsonEncode(output);
+  }
+};
+
+template <typename T>
+static bool json_encode_bs(std::ostream& output, const BinaryStream& input) {
+  T datum;
+  // input must be const to conform to the JSON encoders interface layed out in
+  // Json.h (const std::vector<BStore>& must be JSON-serializable) and to the
+  // general idea that reading an object shouldn't change it. However, reading
+  // from BinaryStream changes its position. We have to either cast away the
+  // constness here or declare BinaryStream::m_pos mutable. I don't know which
+  // way is better.  --- Evgenii
+  auto& in = const_cast<BinaryStream&>(input);
+  in.m_pos = 0;
+  return (in >> datum) && json_encode(output, datum);
+}
+
+// Maps typeid().name to a function that extracts data from BinaryStream and
+// prints it as JSON.
+//
+// Extend as needed
+std::unordered_map<std::string, bool (*)(std::ostream&, const BinaryStream&)> json_encoders {
+#define encoder(type) { typeid(type).name(), json_encode_bs<type> }
+  encoder(bool),
+  encoder(int),
+  encoder(unsigned int),
+  encoder(double),
+  encoder(std::string),
+  encoder(BStore),
+  encoder(std::vector<int>),
+  encoder(std::vector<double>),
+  encoder(std::vector<std::string>),
+  encoder(std::vector<BStore>)
+#undef encoder
+};
+
+bool (*BStore::GetJsonEncoder(const std::string& key) const)(std::ostream&, const BinaryStream&){
+  auto type = m_type_info.find(key);
+  if (type == m_type_info.end()) return nullptr;
+  auto encoder = json_encoders.find(type->second);
+  if (encoder == json_encoders.end()) {
+    std::clog
+      << "BStore::JsonEncode: encoder for type "
+      << type->second
+      << " (field "
+      << key
+      << ") is not implemented"
+      << std::endl;
+    return nullptr;
+  };
+  return encoder->second;
+}
+
+bool BStore::JsonEncode(std::ostream& stream) const {
+  if (!m_type_checking) {
+    std::clog
+      << "BStore::JsonEncode: type checking is required for JSON encoding"
+      << std::endl;
+    return false;
+  };
+
+  bool comma = false;
+  stream << '{';
+  for (auto& kv : m_variables) {
+    if (comma)
+      stream << ',';
+    else
+      comma = true;
+    if (!json_encode(stream, kv.first)) return false;
+    stream << ':';
+    auto encoder = GetJsonEncoder(kv.first);
+    if (!encoder || !encoder(stream, kv.second)) return false;
+  };
+  stream << '}';
+  return true;
+}
+
+bool BStore::JsonEncode(std::string& json) const {
+  std::stringstream ss;
+  if (!JsonEncode(ss)) return false;
+  json = ss.str();
+  return true;
+}
+
+bool BStore::JsonEncode(const std::string& key, std::ostream& stream) const {
+  if (!m_type_checking) {
+    std::clog
+      << "BStore::JsonEncode: type checking is required for JSON encoding"
+      << std::endl;
+    return false;
+  };
+
+  auto kv = m_variables.find(key);
+  if (kv == m_variables.end()) return false;
+  auto encoder = GetJsonEncoder(kv->first);
+  return encoder && encoder(stream, kv->second);
+}
+
+bool BStore::JsonEncode(const std::string& key, std::string& json) const {
+  std::stringstream ss;
+  if (!JsonEncode(key, ss)) return false;
+  json = ss.str();
+  return true;
+}

src/Store/BStore.h

@@ -14,6 +14,7 @@
 #include <PointerWrapper.h>
 
 #include <BinaryStream.h>
+#include <Json.h>
 #include <sys/stat.h>
 
 namespace ToolFramework{
@@ -71,13 +72,18 @@ namespace ToolFramework{
     /////////importing
 
     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 JsonEncode(std::ostream& output) const; ///< Prints contents as a JSON object if possible
+    bool JsonEncode(std::string& output) const; ///< Prints contents as a JSON objec if possible
+    bool JsonEncode(const std::string& key, std::ostream& output) const; ///< Prints contents of the given key as a JSON if possible.
+    bool JsonEncode(const std::string& key, std::string& output) const; ///< Prints contents of the given key as JSON if possible.
     bool Print();
     void Print(bool values); ///< Prints the contents of the BoostStore. @param values If true values and keys are printed. If false just keys are printed
     void Delete(); ///< Deletes all entries in the BoostStore.
     void Remove(std::string key); ///< Removes a single entry from the BoostStore. @param key The key of the entry to remove. 
     std::string Type(std::string key); ///< Queries the type of an entry if type checking is turned on. @param key The key of the entry to check. @return A string encoding the type info.
     bool Has(std::string key); ///< Queries if entry exists in a BoostStore. @param key is the key of the varaible to look up. @return true if varaible is present in the store, false if not. 
     //  BoostStore *Header; ///< Pointer to header BoostStore (only available in multi event BoostStore). This can be used to access and assign header varaibles jsut like a standard non multi event store.
+    bool TypeChecking() const { return m_type_checking; }; ///< Whether type checking is enabled (required for JSON serialisation)
 
     /**
        Templated getter function for BoostStore content. Assignment is templated and via reference.
@@ -248,9 +254,11 @@ namespace ToolFramework{
     //int m_file_type; //0=gzopen, 1=fopen, 2=stringstream
     float m_version;
 
+    bool (*GetJsonEncoder(const std::string& key) const)(std::ostream&, const BinaryStream&);
 
   };
 
+  bool json_encode(std::ostream&, const BStore&);
 }
 
 #endif

src/Store/Json.cpp

@@ -0,0 +1,15 @@
+#include <Json.h>
+
+namespace ToolFramework {
+
+bool json_encode(std::ostream& output, const std::string& datum) {
+  output << '"';
+  for (char c : datum) {
+    if (c == '"' || c == '\\') output << '\\';
+    output << c;
+  };
+  output << '"';
+  return true;
+}
+
+}

src/Store/Json.h

@@ -0,0 +1,64 @@
+#ifndef TOOLFRAMEWORK_JSON_H
+#define TOOLFRAMEWORK_JSON_H
+
+#include <map>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace ToolFramework {
+
+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;
+}
+
+bool json_encode(std::ostream& output, const std::string& datum);
+
+template <typename T>
+bool json_encode(std::ostream& output, const std::vector<T>& data) {
+  output << '[';
+  bool comma = false;
+  for (const T& datum : data) {
+    if (comma)
+      output << ',';
+    else
+      comma = true;
+    json_encode(output, datum);
+  };
+  output << ']';
+  return true;
+}
+
+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;
+    json_encode(output, datum.first);
+    output << ':';
+    json_encode(output, datum.second);
+  };
+  output << '}';
+  return true;
+}
+
+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;
+}
+
+}
+
+#endif