fable: Rename fable::schema::Array to Vector

This is orthogonal with the standard library (std::vector) and allows us to add
the Array type, which corresponds to the std::array type.

BREAKING CHANGE: If you used fable::schema::Array directly you need
to rename it to fable::schema::Vector.

This is especially important as a future commit will introduce
a separate Array schema type.

Author: cassava

engine/src/stack.hpp

@@ -107,7 +107,7 @@ inline auto id_path_prototype(std::string&& desc = "") {
  */
 using IncludeConf = boost::filesystem::path;
 using IncludeSchema = decltype(schema::make_schema(static_cast<IncludeConf*>(nullptr), ""));
-using IncludesSchema = schema::Array<IncludeConf, IncludeSchema>;
+using IncludesSchema = schema::Vector<IncludeConf, IncludeSchema>;
 
 // --------------------------------------------------------------------------------------------- //
 

fable/include/fable/schema.hpp

@@ -120,7 +120,6 @@
 #include <utility>      // for move
 #include <vector>       // for vector<>
 
-#include <fable/schema/array.hpp>      // for Array<>
 #include <fable/schema/boolean.hpp>    // for Boolean
 #include <fable/schema/confable.hpp>   // for FromConfable
 #include <fable/schema/const.hpp>      // for Const<>
@@ -137,6 +136,7 @@
 #include <fable/schema/string.hpp>     // for String
 #include <fable/schema/struct.hpp>     // for Struct
 #include <fable/schema/variant.hpp>    // for Variant
+#include <fable/schema/vector.hpp>     // for Vector<>
 
 // It is important that this include comes after all the other ones,
 // so that it has access to ALL the previous definitions.

fable/include/fable/schema/array.hpp renamed to fable/include/fable/schema/vector.hpp

@@ -16,7 +16,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
- * \file fable/schema/array.hpp
+ * \file fable/schema/vector.hpp
  * \see  fable/schema/xmagic.hpp
  * \see  fable/schema.hpp
  * \see  fable/schema_test.cpp
@@ -37,21 +37,21 @@ namespace fable {
 namespace schema {
 
 template <typename T, typename P>
-class Array : public Base<Array<T, P>> {
+class Vector : public Base<Vector<T, P>> {
  public:  // Types and Constructors
   using Type = std::vector<T>;
   using PrototypeSchema = std::remove_cv_t<std::remove_reference_t<P>>;
 
-  Array(Type* ptr, std::string desc);
-  Array(Type* ptr, PrototypeSchema prototype)
-      : Base<Array<T, P>>(JsonType::array), prototype_(std::move(prototype)), ptr_(ptr) {}
-  Array(Type* ptr, PrototypeSchema prototype, std::string desc)
-      : Base<Array<T, P>>(JsonType::array, std::move(desc)), prototype_(std::move(prototype)), ptr_(ptr) {}
+  Vector(Type* ptr, std::string desc);
+  Vector(Type* ptr, PrototypeSchema prototype)
+      : Base<Vector<T, P>>(JsonType::array), prototype_(std::move(prototype)), ptr_(ptr) {}
+  Vector(Type* ptr, PrototypeSchema prototype, std::string desc)
+      : Base<Vector<T, P>>(JsonType::array, std::move(desc)), prototype_(std::move(prototype)), ptr_(ptr) {}
 
 #if 0
   // This is defined in: fable/schema/xmagic.hpp
-  Array(Type* ptr, std::string desc)
-      : Array(ptr, make_prototype<T>(), std::move(desc)) {}
+  Vector(Type* ptr, std::string desc)
+      : Vector(ptr, make_prototype<T>(), std::move(desc)) {}
 #endif
 
  public:  // Specials
@@ -71,21 +71,21 @@ class Array : public Base<Array<T, P>> {
   /**
    * Set whether deserialization should extend the underlying array.
    */
-  Array<T, P> extend(bool value) && {
+  Vector<T, P> extend(bool value) && {
     option_extend_ = value;
     return std::move(*this);
   }
 
   size_t min_items() const { return min_items_; }
   void set_min_items(size_t value) { min_items_ = value; }
-  Array<T, P> min_items(size_t value) && {
+  Vector<T, P> min_items(size_t value) && {
     min_items_ = value;
     return std::move(*this);
   }
 
   size_t max_items() const { return max_items_; }
   void set_max_items(size_t value) { max_items_ = value; }
-  Array<T, P> max_items(size_t value) && {
+  Vector<T, P> max_items(size_t value) && {
     max_items_ = value;
     return std::move(*this);
   }
@@ -174,8 +174,8 @@ class Array : public Base<Array<T, P>> {
 };
 
 template <typename T, typename P, typename S>
-Array<T, P> make_schema(std::vector<T>* ptr, P&& prototype, S&& desc) {
-  return Array<T, P>(ptr, std::forward<P>(prototype), std::forward<S>(desc));
+Vector<T, P> make_schema(std::vector<T>* ptr, P&& prototype, S&& desc) {
+  return Vector<T, P>(ptr, std::forward<P>(prototype), std::forward<S>(desc));
 }
 
 }  // namespace schema

fable/include/fable/schema/xmagic.hpp

@@ -40,26 +40,23 @@
 #include <utility>  // for move
 #include <vector>   // for vector<>
 
-#include <fable/schema/array.hpp>     // for Array<>
+#include <fable/fable_fwd.hpp>        // for Confable
 #include <fable/schema/confable.hpp>  // for FromConfable<>
 #include <fable/schema/const.hpp>     // for Const<>
 #include <fable/schema/map.hpp>       // for Map<>
 #include <fable/schema/optional.hpp>  // for Optional<>
+#include <fable/schema/vector.hpp>    // for Vector<>
 
 namespace fable {
-
-// Forward declarations:
-class Confable;
-
 namespace schema {
 
 template <typename T, typename P>
-Array<T, P>::Array(std::vector<T>* ptr, std::string desc)
-    : Array<T, P>(ptr, make_prototype<T>(), std::move(desc)) {}
+Vector<T, P>::Vector(std::vector<T>* ptr, std::string desc)
+    : Vector<T, P>(ptr, make_prototype<T>(), std::move(desc)) {}
 
 template <typename T, typename S>
-Array<T, decltype(make_prototype<T>())> make_schema(std::vector<T>* ptr, S&& desc) {
-  return Array<T, decltype(make_prototype<T>())>(ptr, std::forward<S>(desc));
+Vector<T, decltype(make_prototype<T>())> make_schema(std::vector<T>* ptr, S&& desc) {
+  return Vector<T, decltype(make_prototype<T>())>(ptr, std::forward<S>(desc));
 }
 
 template <typename T, typename P>

fable/src/fable/schema/enum_test.cpp

@@ -64,7 +64,7 @@ TEST(fable_schema_enum, struct_enum) {
 TEST(fable_schema_enum, vector_enum_ok) {
   using namespace fable::schema;  // NOLINT(build/namespaces)
   std::vector<LogLevel> xs;
-  Array<LogLevel, Enum<LogLevel>> s{&xs, ""};
+  Vector<LogLevel, Enum<LogLevel>> s{&xs, ""};
 
   fable::assert_to_json(s, "[]");
   fable::assert_from_eq_to(s, R"([
@@ -77,7 +77,7 @@ TEST(fable_schema_enum, vector_enum_ok) {
 TEST(fable_schema_enum, vector_struct_enum) {
   using namespace fable::schema;  // NOLINT(build/namespaces)
   std::vector<LoggerStruct> xs;
-  Array<LoggerStruct, FromConfable<LoggerStruct>> s{&xs, ""};
+  Vector<LoggerStruct, FromConfable<LoggerStruct>> s{&xs, ""};
 
   fable::assert_to_json(s, "[]");
   fable::assert_from_eq_to(s, R"([