Add support for range to construct json_arrayt and json_objectt

The end result of this commit is that code like the following example
can be used to construct `json_arrayt` / `json_objectt` -
```
const std::vector<std::string> input{"foo", "bar"};
const auto json_array =
make_range(input)
.map(constructor_of<json_stringt>())
.collect<json_arrayt>();
```
This commit includes -
* Constructors from iterators for json_arrayt and json_objectt, so
that the iterators from a range can be used to construct these classes.
* A `collect` member function for `ranget`, so that a chain of range
operations can finish with the construction of a resulting container
containing a collection of the results.
* A `constructor_of` template function, which provides syntactic sugar
when using `map` to call a constructor, compared to writing a new lambda
function each time such an operation is carried out.
* Unit tests covering all of the above functionality.

Author: thomasspriggs

src/util/constructor_of.h

@@ -0,0 +1,33 @@
+/*******************************************************************\
+
+Module: constructor_of
+
+Author: Diffblue Ltd.
+
+\*******************************************************************/
+
+#ifndef CPROVER_UTIL_CONSTRUCTOR_OF_H
+#define CPROVER_UTIL_CONSTRUCTOR_OF_H
+
+/// A type of functor which wraps around the set of constructors of a type.
+/// \tparam constructedt: The type which this functor constructs.
+template <typename constructedt>
+class constructort final
+{
+public:
+  template <typename... argumentst>
+  constructedt operator()(argumentst &&... arguments)
+  {
+    return constructedt{std::forward<argumentst>(arguments)...};
+  }
+};
+
+/// \tparam constructedt: A type for construction.
+/// \brief Returns a functor which constructs type `constructedt`.
+template <typename constructedt>
+constexpr constructort<constructedt> constructor_of()
+{
+  return {};
+}
+
+#endif // CPROVER_UTIL_CONSTRUCTOR_OF_H

src/util/json.h

@@ -170,6 +170,14 @@ class json_arrayt:public jsont
   {
   }
 
+  template <typename begin_iteratort, typename end_iteratort>
+  json_arrayt(begin_iteratort &&begin_iterator, end_iteratort &&end_iterator)
+    : json_arrayt(arrayt(
+        std::forward<begin_iteratort>(begin_iterator),
+        std::forward<end_iteratort>(end_iterator)))
+  {
+  }
+
   void resize(std::size_t size)
   {
     array.resize(size);
@@ -294,6 +302,14 @@ class json_objectt:public jsont
   {
   }
 
+  template <typename begin_iteratort, typename end_iteratort>
+  json_objectt(begin_iteratort &&begin_iterator, end_iteratort &&end_iterator)
+    : json_objectt(objectt(
+        std::forward<begin_iteratort>(begin_iterator),
+        std::forward<end_iteratort>(end_iterator)))
+  {
+  }
+
   jsont &operator[](const std::string &key)
   {
     return object[key];

src/util/range.h

@@ -351,6 +351,14 @@ struct ranget final
     return end_value;
   }
 
+  /// Constructs a collection containing the values, which this range iterates
+  /// over.
+  template <typename containert>
+  containert collect() const
+  {
+    return containert(begin(), end());
+  }
+
 private:
   iteratort begin_value;
   iteratort end_value;

unit/util/json_array.cpp

@@ -7,7 +7,12 @@ Author: Diffblue Ltd.
 \*******************************************************************/
 
 #include <testing-utils/catch.hpp>
+#include <util/constructor_of.h>
 #include <util/json.h>
+#include <util/range.h>
+
+#include <string>
+#include <vector>
 
 SCENARIO(
   "Test that json_arrayt can be constructed from an initializer list.",
@@ -33,3 +38,29 @@ SCENARIO(
     }
   }
 }
+
+SCENARIO(
+  "Test that json_arrayt can be constructed using `ranget`",
+  "[core][util][json]")
+{
+  GIVEN("A vector of strings.")
+  {
+    const std::vector<std::string> input{"foo", "bar"};
+    THEN(
+      "A json_arrayt can be constructed from the vector of strings using range "
+      "and map.")
+    {
+      const json_arrayt array = make_range(input)
+                                  .map(constructor_of<json_stringt>())
+                                  .collect<json_arrayt>();
+      auto it = array.begin();
+      REQUIRE(it->kind == jsont::kindt::J_STRING);
+      REQUIRE(it->value == "foo");
+      ++it;
+      REQUIRE(it->kind == jsont::kindt::J_STRING);
+      REQUIRE(it->value == "bar");
+      ++it;
+      REQUIRE(it == array.end());
+    }
+  }
+}

unit/util/json_object.cpp

@@ -10,9 +10,12 @@ Author: Diffblue Ltd.
 #include <util/json.h>
 #include <util/optional.h>
 #include <util/optional_utils.h>
+#include <util/range.h>
 
 #include <algorithm>
 #include <iterator>
+#include <string>
+#include <vector>
 
 SCENARIO(
   "Test that json_objectt is compatible with STL algorithms",
@@ -73,3 +76,31 @@ SCENARIO(
     }
   }
 }
+
+SCENARIO(
+  "Test that json_objectt can be constructed using `ranget`",
+  "[core][util][json]")
+{
+  GIVEN("A vector of numbers.")
+  {
+    const std::vector<int> input{1, 2, 3};
+    THEN(
+      "A json_objectt can be constructed from the vector of numbers using "
+      "range and map.")
+    {
+      const json_objectt output =
+        make_range(input)
+          .map([](const int number) {
+            const std::string number_as_string = std::to_string(number);
+            return make_pair(number_as_string, json_stringt{number_as_string});
+          })
+          .collect<json_objectt>();
+      REQUIRE(output["1"].kind == jsont::kindt::J_STRING);
+      REQUIRE(output["1"].value == "1");
+      REQUIRE(output["2"].kind == jsont::kindt::J_STRING);
+      REQUIRE(output["2"].value == "2");
+      REQUIRE(output["3"].kind == jsont::kindt::J_STRING);
+      REQUIRE(output["3"].value == "3");
+    };
+  }
+}