splitting Schema into a base class with a builder and factories

src/aws-cpp-sdk-core/include/smithy/client/schema/CborShapeSerializer.h

@@ -5,6 +5,8 @@
 #include <smithy/Smithy_EXPORTS.h>
 #include <smithy/client/schema/ShapeSerializer.h>
 
+#include <functional>
+
 namespace smithy {
 namespace schema {
 
@@ -14,8 +16,9 @@ class SMITHY_API CborShapeSerializer final : public ShapeSerializer {
   CborShapeSerializer();
   ~CborShapeSerializer();
 
-  bool BeginStructure(const Schema& schema) override;
-  void EndStructure() override;
+  void WriteStruct(const Schema& schema, const SerializableStruct& value) override;
+  void WriteList(const Schema& schema, size_t size, const std::function<void(ShapeSerializer&)>& consumer) override;
+  void WriteMap(const Schema& schema, size_t size, const std::function<void(MapSerializer&)>& consumer) override;
 
   void WriteBoolean(const Schema& schema, bool value) override;
   void WriteInteger(const Schema& schema, int value) override;
@@ -28,16 +31,6 @@ class SMITHY_API CborShapeSerializer final : public ShapeSerializer {
   void WriteEnum(const Schema& schema, int value) override;
   void WriteNull(const Schema& schema) override;
 
-  bool BeginList(const Schema& schema, size_t count) override;
-  void EndList() override;
-
-  bool BeginMap(const Schema& schema, size_t count) override;
-  void WriteMapKey(const Aws::String& key) override;
-  void EndMap() override;
-
-  bool BeginNestedStructure(const Schema& schema) override;
-  void EndNestedStructure() override;
-
   SerializerOutcome GetPayload();
 
  private:

src/aws-cpp-sdk-core/include/smithy/client/schema/InterceptingSerializer.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <smithy/Smithy_EXPORTS.h>
+#include <smithy/client/schema/ShapeSerializer.h>
+
+#include <functional>
+
+namespace smithy {
+namespace schema {
+
+// Routes each write through Before()/After(). Before() returns the serializer
+// that performs the write; After() runs once it returns.
+class SMITHY_API InterceptingSerializer : public ShapeSerializer {
+ public:
+  void WriteStruct(const Schema& schema, const SerializableStruct& value) override {
+    Before(schema).WriteStruct(schema, value);
+    After(schema);
+  }
+  void WriteList(const Schema& schema, size_t size, const std::function<void(ShapeSerializer&)>& consumer) override {
+    Before(schema).WriteList(schema, size, consumer);
+    After(schema);
+  }
+  void WriteMap(const Schema& schema, size_t size, const std::function<void(MapSerializer&)>& consumer) override {
+    Before(schema).WriteMap(schema, size, consumer);
+    After(schema);
+  }
+  void WriteBoolean(const Schema& schema, bool value) override {
+    Before(schema).WriteBoolean(schema, value);
+    After(schema);
+  }
+  void WriteInteger(const Schema& schema, int value) override {
+    Before(schema).WriteInteger(schema, value);
+    After(schema);
+  }
+  void WriteLong(const Schema& schema, int64_t value) override {
+    Before(schema).WriteLong(schema, value);
+    After(schema);
+  }
+  void WriteFloat(const Schema& schema, float value) override {
+    Before(schema).WriteFloat(schema, value);
+    After(schema);
+  }
+  void WriteDouble(const Schema& schema, double value) override {
+    Before(schema).WriteDouble(schema, value);
+    After(schema);
+  }
+  void WriteString(const Schema& schema, const Aws::String& value) override {
+    Before(schema).WriteString(schema, value);
+    After(schema);
+  }
+  void WriteTimestamp(const Schema& schema, const Aws::Utils::DateTime& value) override {
+    Before(schema).WriteTimestamp(schema, value);
+    After(schema);
+  }
+  void WriteBlob(const Schema& schema, const Aws::Utils::ByteBuffer& value) override {
+    Before(schema).WriteBlob(schema, value);
+    After(schema);
+  }
+  void WriteEnum(const Schema& schema, int value) override {
+    Before(schema).WriteEnum(schema, value);
+    After(schema);
+  }
+  void WriteNull(const Schema& schema) override {
+    Before(schema).WriteNull(schema);
+    After(schema);
+  }
+
+ protected:
+  virtual ShapeSerializer& Before(const Schema& schema) = 0;
+  virtual void After(const Schema& /*schema*/) {}
+};
+
+}  // namespace schema
+}  // namespace smithy

src/aws-cpp-sdk-core/include/smithy/client/schema/JsonShapeSerializer.h

@@ -5,6 +5,8 @@
 #include <smithy/Smithy_EXPORTS.h>
 #include <smithy/client/schema/ShapeSerializer.h>
 
+#include <functional>
+
 namespace smithy {
 namespace schema {
 
@@ -14,8 +16,9 @@ class SMITHY_API JsonShapeSerializer final : public ShapeSerializer {
   JsonShapeSerializer();
   ~JsonShapeSerializer();
 
-  bool BeginStructure(const Schema& schema) override;
-  void EndStructure() override;
+  void WriteStruct(const Schema& schema, const SerializableStruct& value) override;
+  void WriteList(const Schema& schema, size_t size, const std::function<void(ShapeSerializer&)>& consumer) override;
+  void WriteMap(const Schema& schema, size_t size, const std::function<void(MapSerializer&)>& consumer) override;
 
   void WriteBoolean(const Schema& schema, bool value) override;
   void WriteInteger(const Schema& schema, int value) override;
@@ -28,16 +31,6 @@ class SMITHY_API JsonShapeSerializer final : public ShapeSerializer {
   void WriteEnum(const Schema& schema, int value) override;
   void WriteNull(const Schema& schema) override;
 
-  bool BeginList(const Schema& schema, size_t count) override;
-  void EndList() override;
-
-  bool BeginMap(const Schema& schema, size_t count) override;
-  void WriteMapKey(const Aws::String& key) override;
-  void EndMap() override;
-
-  bool BeginNestedStructure(const Schema& schema) override;
-  void EndNestedStructure() override;
-
   SerializerOutcome GetPayload();
 
  private:

src/aws-cpp-sdk-core/include/smithy/client/schema/MapSerializer.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <smithy/Smithy_EXPORTS.h>
+
+#include <functional>
+
+namespace smithy {
+namespace schema {
+
+class ShapeSerializer;
+
+// Handed to the WriteMap consumer; writes each entry's key then its value.
+class SMITHY_API MapSerializer {
+ public:
+  virtual ~MapSerializer() = default;
+
+  virtual void WriteEntry(const Aws::String& key, const std::function<void(ShapeSerializer&)>& value) = 0;
+};
+
+}  // namespace schema
+}  // namespace smithy

src/aws-cpp-sdk-core/include/smithy/client/schema/Schema.h

@@ -1,14 +1,19 @@
 #pragma once
 
 #include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/crt/Optional.h>
+#include <smithy/Smithy_EXPORTS.h>
 #include <smithy/client/schema/TraitMap.h>
 
 #include <cstdint>
+#include <initializer_list>
 #include <memory>
 
 namespace smithy {
 namespace schema {
 
+class SchemaBuilder;
+
 enum class ShapeType : uint8_t {
   Boolean,
   Byte,
@@ -34,21 +39,30 @@ enum class ShapeType : uint8_t {
   Service
 };
 
-class Schema {
+// A single trait supplied at construction time.
+struct TraitEntry {
+  const TraitKeyBase& key;
+  std::shared_ptr<const Trait> value;
+};
+using TraitList = std::initializer_list<TraitEntry>;
+
+// Abstract, immutable description of a shape. Concrete variants are created
+// through the factories below and SchemaBuilder.
+class SMITHY_API Schema {
  public:
-  Schema() = default;
-  Schema(const Aws::String& memberName, ShapeType type) : m_type(type), m_memberName(memberName) {}
+  virtual ~Schema() = default;
 
-  ShapeType GetType() const { return m_type; }
-  const char* GetId() const { return m_id; }
-  Aws::String GetMemberName() const { return m_memberName; }
-  int GetMemberIndex() const { return m_memberIndex; }
-  bool IsMember() const { return !m_memberName.empty(); }
+  virtual ShapeType GetType() const = 0;
+  virtual const char* GetId() const = 0;
 
-  const Schema* GetMember(const char* name) const;
-  const Schema* GetMember(int index) const;
+  virtual bool IsMember() const { return false; }
+  virtual Aws::String GetMemberName() const { return {}; }
+  virtual int GetMemberIndex() const { return 0; }
+  virtual Aws::Crt::Optional<std::shared_ptr<const Schema>> GetMemberTarget() const { return {}; }
 
-  uint16_t GetMemberCount() const { return m_memberCount; }
+  virtual Aws::Crt::Optional<std::shared_ptr<const Schema>> GetMember(const char* /*name*/) const { return {}; }
+  virtual Aws::Crt::Optional<std::shared_ptr<const Schema>> GetMember(int /*index*/) const { return {}; }
+  virtual uint16_t GetMemberCount() const { return 0; }
 
   template <typename T>
   std::shared_ptr<const T> GetTrait(const TraitKey<T>& key) const {
@@ -57,19 +71,41 @@ class Schema {
 
   bool HasTrait(const TraitKeyBase& key) const { return m_traits.Has(key); }
 
-  Schema& SetTrait(const TraitKeyBase& key, std::shared_ptr<const Trait> trait) {
-    m_traits.Set(key, std::move(trait));
-    return *this;
-  }
+  // Scalar factories.
+  static std::shared_ptr<const Schema> CreateBoolean(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateByte(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateShort(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateInteger(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateLong(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateFloat(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateDouble(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateBigInteger(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateBigDecimal(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateString(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateEnum(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateIntEnum(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateBlob(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateTimestamp(const char* id, TraitList traits = {});
+  static std::shared_ptr<const Schema> CreateDocument(const char* id, TraitList traits = {});
+
+  // Standalone member node targeting an (otherwise empty) shape of targetType.
+  static std::shared_ptr<const Schema> CreateMember(const char* name, ShapeType targetType, TraitList traits = {});
+
+  // Aggregate builders.
+  static SchemaBuilder StructureBuilder(const char* id, TraitList traits = {});
+  static SchemaBuilder UnionBuilder(const char* id, TraitList traits = {});
+  static SchemaBuilder ListBuilder(const char* id, TraitList traits = {});
+  static SchemaBuilder MapBuilder(const char* id, TraitList traits = {});
+
+ protected:
+  Schema() = default;
+  explicit Schema(TraitList traits);
 
- private:
-  const char* m_id = nullptr;
-  ShapeType m_type = ShapeType::Structure;
-  Aws::String m_memberName;
-  int m_memberIndex = 0;
-  const Schema* m_members = nullptr;
-  uint16_t m_memberCount = 0;
   TraitMap m_traits;
+
+ private:
+  Schema(const Schema&) = delete;
+  Schema& operator=(const Schema&) = delete;
 };
 
 }  // namespace schema

src/aws-cpp-sdk-core/include/smithy/client/schema/SchemaBuilder.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <aws/core/utils/memory/AWSMemory.h>
+#include <smithy/Smithy_EXPORTS.h>
+#include <smithy/client/schema/Schema.h>
+
+#include <memory>
+
+namespace smithy {
+namespace schema {
+
+// Assembles a shape that carries members (structure, union, list, map). Move-only;
+// obtained from Schema::StructureBuilder and friends.
+class SMITHY_API SchemaBuilder final {
+ public:
+  ~SchemaBuilder();
+  SchemaBuilder(SchemaBuilder&&) noexcept;
+  SchemaBuilder& operator=(SchemaBuilder&&) noexcept;
+
+  SchemaBuilder& PutMember(const char* name, std::shared_ptr<const Schema> target, TraitList traits = {});
+  SchemaBuilder& PutMember(const char* name, SchemaBuilder& target, TraitList traits = {});
+
+  std::shared_ptr<const Schema> Build();
+
+ private:
+  friend class Schema;
+  class SchemaBuilderImpl;
+
+  explicit SchemaBuilder(Aws::UniquePtr<SchemaBuilderImpl> impl);
+
+  Aws::UniquePtr<SchemaBuilderImpl> m_impl;
+
+  SchemaBuilder(const SchemaBuilder&) = delete;
+  SchemaBuilder& operator=(const SchemaBuilder&) = delete;
+};
+
+}  // namespace schema
+}  // namespace smithy

src/aws-cpp-sdk-core/include/smithy/client/schema/SerializableStruct.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <smithy/Smithy_EXPORTS.h>
+#include <smithy/client/schema/Schema.h>
+
+namespace smithy {
+namespace schema {
+
+class ShapeSerializer;
+
+// Implemented by generated shapes: knows its Schema and how to write its members
+// to whichever ShapeSerializer is passed in.
+class SMITHY_API SerializableStruct {
+ public:
+  virtual ~SerializableStruct() = default;
+
+  virtual const Schema& GetSchema() const = 0;
+  virtual void SerializeMembers(ShapeSerializer& serializer) const = 0;
+};
+
+}  // namespace schema
+}  // namespace smithy

src/aws-cpp-sdk-core/include/smithy/client/schema/ShapeSerializer.h

@@ -7,16 +7,23 @@
 #include <smithy/client/schema/Schema.h>
 
 #include <cstdint>
+#include <functional>
 
 namespace smithy {
 namespace schema {
 
+class SerializableStruct;
+class MapSerializer;
+
+// Push-based serializer: the model drives serialization and the serializer owns
+// all wire-format structure. Aggregates hand control back through a consumer.
 class SMITHY_API ShapeSerializer {
  public:
   virtual ~ShapeSerializer() = default;
 
-  virtual bool BeginStructure(const Schema& schema) = 0;
-  virtual void EndStructure() = 0;
+  virtual void WriteStruct(const Schema& schema, const SerializableStruct& value) = 0;
+  virtual void WriteList(const Schema& schema, size_t size, const std::function<void(ShapeSerializer&)>& consumer) = 0;
+  virtual void WriteMap(const Schema& schema, size_t size, const std::function<void(MapSerializer&)>& consumer) = 0;
 
   virtual void WriteBoolean(const Schema& schema, bool value) = 0;
   virtual void WriteInteger(const Schema& schema, int value) = 0;
@@ -28,16 +35,6 @@ class SMITHY_API ShapeSerializer {
   virtual void WriteBlob(const Schema& schema, const Aws::Utils::ByteBuffer& value) = 0;
   virtual void WriteEnum(const Schema& schema, int value) = 0;
   virtual void WriteNull(const Schema& schema) = 0;
-
-  virtual bool BeginList(const Schema& schema, size_t count) = 0;
-  virtual void EndList() = 0;
-
-  virtual bool BeginMap(const Schema& schema, size_t count) = 0;
-  virtual void WriteMapKey(const Aws::String& key) = 0;
-  virtual void EndMap() = 0;
-
-  virtual bool BeginNestedStructure(const Schema& schema) = 0;
-  virtual void EndNestedStructure() = 0;
 };
 
 }  // namespace schema