quicktype-core 20.0.27 → 21.0.0

package/dist/language/CPlusPlus.d.ts

@@ -120,12 +120,22 @@ export declare class CPlusPlusRenderer extends ConvenienceRenderer {
     private readonly _memberNamingFunction;
     private _stringType;
     private _optionalType;
+    private _optionalFactory;
     private _nulloptType;
     private _variantType;
     private _variantIndexMethodName;
     protected readonly typeNamingStyle: NamingStyle;
     protected readonly enumeratorNamingStyle: NamingStyle;
     constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _options: OptionValues<typeof cPlusPlusOptions>);
+    isUnion(t: Type | UnionType): t is UnionType;
+    isOptionalAsValuePossible(t: Type): boolean;
+    isImplicitCycleBreaker(t: Type): boolean;
+    optionalTypeStack(): string;
+    optionalFactoryStack(): string;
+    optionalTypeHeap(): string;
+    optionalFactoryHeap(): string;
+    optionalType(t: Type): string;
+    optionalTypeLabel(t: Type): string;
     protected getConstraintMembers(): ConstraintMember[];
     protected lookupGlobalName(type: GlobalNames): string;
     protected lookupMemberName(type: MemberNames): string;
@@ -154,7 +164,7 @@ export declare class CPlusPlusRenderer extends ConvenienceRenderer {
     protected variantType(u: UnionType, inJsonNamespace: boolean): Sourcelike;
     protected ourQualifier(inJsonNamespace: boolean): Sourcelike;
     protected jsonQualifier(inJsonNamespace: boolean): Sourcelike;
-    protected variantIndirection(needIndirection: boolean, typeSrc: Sourcelike): Sourcelike;
+    protected variantIndirection(type: Type, needIndirection: boolean, typeSrc: Sourcelike): Sourcelike;
     protected cppType(t: Type, ctx: TypeContext, withIssues: boolean, forceNarrowString: boolean, isOptional: boolean): Sourcelike;
     /**
      * similar to cppType, it practically gathers all the generated types within

package/dist/language/CPlusPlus.js

@@ -216,19 +216,10 @@ const keywords = [
     "transaction_safe_dynamic",
     "NULL"
 ];
-/**
- * We can't use boost/std optional. They MUST have the declaration of
- * the given structure available, meaning we can't forward declare anything.
- * Which is bad as we have circles in Json schema, which require at least
- * forward declarability.
- * The next question, why isn't unique_ptr is enough here?
- * That problem relates to getter/setter. If using getter/setters we
- * can't/mustn't return a unique_ptr out of the class -> as that is the
- * sole reason why we have declared that as unique_ptr, so that only
- * the class owns it. We COULD return unique_ptr references, which practically
- * kills the uniqueness of the smart pointer -> hence we use shared_ptrs.
- */
-const optionalType = "std::shared_ptr";
+/// Type to use as an optional if cycle breaking is required
+const optionalAsSharedType = "std::shared_ptr";
+/// Factory to use when creating an optional if cycle breaking is required
+const optionalFactoryAsSharedType = "std::make_shared";
 /**
  * To be able to support circles in multiple files -
  * e.g. class#A using class#B using class#A (obviously not directly,
@@ -434,18 +425,124 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
         if (_options.boost) {
             this._optionalType = "boost::optional";
+            this._optionalFactory = "boost::optional";
             this._nulloptType = "boost::none";
             this._variantType = "boost::variant";
             this._variantIndexMethodName = "which";
         }
         else {
             this._optionalType = "std::optional";
+            this._optionalFactory = "std::make_optional";
             this._nulloptType = "std::nullopt";
             this._variantType = "std::variant";
             this._variantIndexMethodName = "index";
         }
         this.setupGlobalNames();
     }
+    // union typeguard
+    isUnion(t) {
+        return t.kind === "union";
+    }
+    // Returns true if the type can be stored in
+    // a stack based optional type. This requires
+    // that the type does not require forward declaration.
+    isOptionalAsValuePossible(t) {
+        if (this.isForwardDeclaredType(t))
+            return false;
+        if (this.isUnion(t)) {
+            // There is something stinky about this test.
+            // There is special handling somewhere that if you
+            // have the following schema
+            // {
+            //     "$schema": "http://json-schema.org/draft-06/schema#",
+            //     "$ref": "#/definitions/List",
+            //     "definitions": {
+            //         "List": {
+            //             "type": "object",
+            //             "additionalProperties": false,
+            //             "properties": {
+            //                 "data": {
+            //                     "type": "string"
+            //                 },
+            //                 "next": {
+            //                     "anyOf": [
+            //                         {
+            //                             "$ref": "#/definitions/List"
+            //                         }
+            //                         {
+            //                             "type": "null"
+            //                         }
+            //                     ]
+            //                 }
+            //             },
+            //             "required": [],
+            //             "title": "List"
+            //         }
+            //     }
+            // }
+            // Then a variant is not output but the single item inlined
+            //
+            //     struct TopLevel {
+            //       std::optional<std::string> data;
+            //       std::optional<TopLevel> next;
+            //     };
+            //
+            // instead of
+            //     struct TopLevel {
+            //       std::optional<std::string> data;
+            //       std::shared_ptr<TopLevel> next;
+            //     };
+            //
+            // checking to see if the collapse of the variant has
+            // occured and then doing the isCycleBreakerType check
+            // on the single type the variant would contain seems
+            // to solve the problem. But does this point to a problem
+            // with the core library or with the CPlusPlus package
+            const [, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(t);
+            if (nonNulls.size === 1) {
+                const tt = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(nonNulls));
+                return !this.isCycleBreakerType(tt);
+            }
+        }
+        return !this.isCycleBreakerType(t);
+    }
+    isImplicitCycleBreaker(t) {
+        const kind = t.kind;
+        return kind === "array" || kind === "map";
+    }
+    // Is likely to return std::optional or boost::optional
+    optionalTypeStack() {
+        return this._optionalType;
+    }
+    // Is likely to return std::make_optional or boost::optional
+    optionalFactoryStack() {
+        return this._optionalFactory;
+    }
+    // Is likely to return std::shared_ptr
+    optionalTypeHeap() {
+        return optionalAsSharedType;
+    }
+    // Is likely to return std::make_shared
+    optionalFactoryHeap() {
+        return optionalFactoryAsSharedType;
+    }
+    // Returns the optional type most suitable for the given type.
+    // Classes that don't require forward declarations can be stored
+    // in std::optional ( or boost::optional )
+    optionalType(t) {
+        if (this.isOptionalAsValuePossible(t))
+            return this.optionalTypeStack();
+        else
+            return this.optionalTypeHeap();
+    }
+    // Returns a label that can be used to distinguish between
+    // heap and stack based optional handling methods
+    optionalTypeLabel(t) {
+        if (this.isOptionalAsValuePossible(t))
+            return "stack";
+        else
+            return "heap";
+    }
     getConstraintMembers() {
         return [
             {
@@ -672,7 +769,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         if (!indirection) {
             return variant;
         }
-        return [optionalType, "<", variant, ">"];
+        return [this.optionalType(u), "<", variant, ">"];
     }
     ourQualifier(inJsonNamespace) {
         return inJsonNamespace ? [(0, collection_utils_1.arrayIntercalate)("::", this._namespaceNames), "::"] : [];
@@ -680,10 +777,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     jsonQualifier(inJsonNamespace) {
         return inJsonNamespace ? [] : "nlohmann::";
     }
-    variantIndirection(needIndirection, typeSrc) {
+    variantIndirection(type, needIndirection, typeSrc) {
         if (!needIndirection)
             return typeSrc;
-        return [optionalType, "<", typeSrc, ">"];
+        return [this.optionalType(type), "<", typeSrc, ">"];
     }
     cppType(t, ctx, withIssues, forceNarrowString, isOptional) {
         const inJsonNamespace = ctx.inJsonNamespace;
@@ -719,7 +816,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             "std::vector<",
             this.cppType(arrayType.items, { needsForwardIndirection: false, needsOptionalIndirection: true, inJsonNamespace }, withIssues, forceNarrowString, false),
             ">"
-        ], classType => this.variantIndirection(ctx.needsForwardIndirection && this.isForwardDeclaredType(classType) && !isOptional, [this.ourQualifier(inJsonNamespace), this.nameForNamedType(classType)]), mapType => {
+        ], classType => this.variantIndirection(classType, ctx.needsForwardIndirection && this.isForwardDeclaredType(classType) && !isOptional, [this.ourQualifier(inJsonNamespace), this.nameForNamedType(classType)]), mapType => {
             let keyType = this._stringType.getType();
             if (forceNarrowString) {
                 keyType = "std::string";
@@ -733,14 +830,17 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             ];
         }, enumType => [this.ourQualifier(inJsonNamespace), this.nameForNamedType(enumType)], unionType => {
             const nullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
-            if (nullable === null)
+            if (nullable !== null) {
+                isOptional = true;
+                return this.cppType(nullable, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace }, withIssues, forceNarrowString, false);
+            }
+            else {
                 return [this.ourQualifier(inJsonNamespace), this.nameForNamedType(unionType)];
-            isOptional = true;
-            return this.cppType(nullable, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace }, withIssues, forceNarrowString, false);
+            }
         });
         if (!isOptional)
             return typeSource;
-        return [optionalType, "<", typeSource, ">"];
+        return [this.optionalType(t), "<", typeSource, ">"];
     }
     /**
      * similar to cppType, it practically gathers all the generated types within
@@ -938,8 +1038,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         // Forward declarations for std::map<std::wstring, Key> (need to convert UTF16 <-> UTF8)
         if (t instanceof Type_1.MapType && this._stringType !== this.NarrowString) {
             const ourQualifier = this.ourQualifier(true);
-            this.emitLine("template <>");
             this.emitBlock(["struct adl_serializer<", ourQualifier, className, ">"], true, () => {
+                this.emitLine("template <>");
                 this.emitLine("static void from_json(", this.withConst("json"), " & j, ", ourQualifier, className, " & x);");
                 this.emitLine("static void to_json(json & j, ", this.withConst([ourQualifier, className]), " & x);");
             });
@@ -1045,9 +1145,9 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             inJsonNamespace: false
                         }, false, false);
                         this.emitLine(assignment.wrap([], [
-                            this._stringType.wrapEncodingChange([ourQualifier], [optionalType, "<", cppType, ">"], [optionalType, "<", toType, ">"], [
+                            this._stringType.wrapEncodingChange([ourQualifier], [this.optionalType(t), "<", cppType, ">"], [this.optionalType(t), "<", toType, ">"], [
                                 ourQualifier,
-                                "get_optional<",
+                                `get_${this.optionalTypeLabel(t)}_optional<`,
                                 cppType,
                                 ">(j, ",
                                 this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])]),
@@ -1276,16 +1376,20 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("#ifndef NLOHMANN_OPT_HELPER");
         this.emitLine("#define NLOHMANN_OPT_HELPER");
         this.emitNamespaces(["nlohmann"], () => {
-            this.emitLine("template <typename T>");
-            this.emitBlock(["struct adl_serializer<", optionalType, "<T>>"], true, () => {
-                this.emitBlock(["static void to_json(json & j, ", this.withConst([optionalType, "<T>"]), " & opt)"], false, () => {
-                    this.emitLine("if (!opt) j = nullptr; else j = *opt;");
-                });
-                this.ensureBlankLine();
-                this.emitBlock(["static ", optionalType, "<T> from_json(", this.withConst("json"), " & j)"], false, () => {
-                    this.emitLine(`if (j.is_null()) return std::unique_ptr<T>(); else return std::unique_ptr<T>(new T(j.get<T>()));`);
+            const emitAdlStruct = (optType, factory) => {
+                this.emitLine("template <typename T>");
+                this.emitBlock(["struct adl_serializer<", optType, "<T>>"], true, () => {
+                    this.emitBlock(["static void to_json(json & j, ", this.withConst([optType, "<T>"]), " & opt)"], false, () => {
+                        this.emitLine("if (!opt) j = nullptr; else j = *opt;");
+                    });
+                    this.ensureBlankLine();
+                    this.emitBlock(["static ", optType, "<T> from_json(", this.withConst("json"), " & j)"], false, () => {
+                        this.emitLine(`if (j.is_null()) return ${factory}<T>(); else return ${factory}<T>(j.get<T>());`);
+                    });
                 });
-            });
+            };
+            emitAdlStruct(this.optionalTypeHeap(), this.optionalFactoryHeap());
+            emitAdlStruct(this.optionalTypeStack(), this.optionalFactoryStack());
         });
         this.emitLine("#endif");
     }
@@ -1481,26 +1585,37 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
             this.emitLine("#ifndef " + optionalMacroName);
             this.emitLine("#define " + optionalMacroName);
-            this.emitLine("template <typename T>");
-            this.emitBlock([
-                "inline ",
-                optionalType,
-                "<T> get_optional(",
-                this.withConst("json"),
-                " & j, ",
-                this.withConst("char"),
-                " * property)"
-            ], false, () => {
-                this.emitBlock(["if (j.find(property) != j.end())"], false, () => {
-                    this.emitLine("return j.at(property).get<", optionalType, "<T>>();");
+            const emitGetOptional = (optionalType, label) => {
+                this.emitLine("template <typename T>");
+                this.emitBlock([
+                    "inline ",
+                    optionalType,
+                    `<T> get_${label}_optional(`,
+                    this.withConst("json"),
+                    " & j, ",
+                    this.withConst("char"),
+                    " * property)"
+                ], false, () => {
+                    this.emitLine(["auto it = j.find(property);"]);
+                    this.emitBlock(["if (it != j.end() && !it->is_null())"], false, () => {
+                        this.emitLine("return j.at(property).get<", optionalType, "<T>>();");
+                    });
+                    this.emitLine("return ", optionalType, "<T>();");
                 });
-                this.emitLine("return ", optionalType, "<T>();");
-            });
-            this.ensureBlankLine();
-            this.emitLine("template <typename T>");
-            this.emitBlock(["inline ", optionalType, "<T> get_optional(", this.withConst("json"), " & j, std::string property)"], false, () => {
-                this.emitLine("return get_optional<T>(j, property.data());");
-            });
+                this.ensureBlankLine();
+                this.emitLine("template <typename T>");
+                this.emitBlock([
+                    "inline ",
+                    optionalType,
+                    `<T> get_${label}_optional(`,
+                    this.withConst("json"),
+                    " & j, std::string property)"
+                ], false, () => {
+                    this.emitLine(`return get_${label}_optional<T>(j, property.data());`);
+                });
+            };
+            emitGetOptional(this.optionalTypeHeap(), "heap");
+            emitGetOptional(this.optionalTypeStack(), "stack");
             this.emitLine("#endif");
             this.ensureBlankLine();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "20.0.27",
+    "version": "21.0.0",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",