typia 13.0.1-dev.20260703.1 → 13.0.2

package/native/core/programmers/iterate/json_schema_station.go

@@ -1,251 +1,251 @@
-package iterate
-
-import (
-  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type json_schema_station_props struct {
-  blockNever bool
-  components *OpenApi_IComponents
-  attribute  JsonSchema
-  metadata   *nativemetadata.MetadataSchema
-}
-
-type Json_schema_station_props struct {
-  BlockNever bool
-  Components *OpenApi_IComponents
-  Attribute  JsonSchema
-  Metadata   *nativemetadata.MetadataSchema
-}
-
-func Json_schema_station(props Json_schema_station_props) JsonSchema {
-  return json_schema_station(json_schema_station_props{
-    blockNever: props.BlockNever,
-    components: props.Components,
-    attribute:  props.Attribute,
-    metadata:   props.Metadata,
-  })
-}
-
-func json_schema_station(props json_schema_station_props) JsonSchema {
-  if props.metadata.Any {
-    output := cloneJsonSchema(props.attribute)
-    if _, ok := output["type"]; ok == false {
-      output["type"] = nil
-    }
-    return output
-  }
-
-  union := []JsonSchema{}
-  insert := func(schema JsonSchema) {
-    if schema != nil {
-      union = append(union, schema)
-    }
-  }
-
-  if props.metadata.Nullable {
-    insert(JsonSchema{"type": "null"})
-  }
-  if props.metadata.Escaped != nil {
-    for _, schema := range json_schema_escaped(struct {
-      components *OpenApi_IComponents
-      escaped    *nativemetadata.MetadataEscaped
-    }{components: props.components, escaped: props.metadata.Escaped}) {
-      insert(schema)
-    }
-  }
-  if len(props.metadata.Templates) != 0 && nativehelpers.AtomicPredicator.Template(props.metadata) {
-    for _, schema := range json_schema_templates(props.metadata) {
-      insert(schema)
-    }
-  }
-  for _, constant := range props.metadata.Constants {
-    if nativehelpers.AtomicPredicator.Constant(struct {
-      Metadata *nativemetadata.MetadataSchema
-      Name     string
-    }{Metadata: props.metadata, Name: constant.Type}) == false {
-      continue
-    }
-    for _, schema := range json_schema_constant(constant) {
-      insert(schema)
-    }
-  }
-  for _, atomic := range props.metadata.Atomics {
-    if atomic.Type == "boolean" {
-      for _, schema := range json_schema_boolean(atomic) {
-        insert(schema)
-      }
-    } else if atomic.Type == "bigint" {
-      for _, schema := range json_schema_bigint(atomic) {
-        insert(schema)
-      }
-    } else if atomic.Type == "number" {
-      for _, schema := range json_schema_number(atomic) {
-        insert(schema)
-      }
-    } else if atomic.Type == "string" {
-      for _, schema := range json_schema_string(atomic) {
-        insert(schema)
-      }
-    }
-  }
-  for _, array := range props.metadata.Arrays {
-    for _, schema := range json_schema_array(struct {
-      components *OpenApi_IComponents
-      array      *nativemetadata.MetadataArray
-    }{components: props.components, array: array}) {
-      insert(schema)
-    }
-  }
-  for _, tuple := range props.metadata.Tuples {
-    insert(json_schema_tuple(struct {
-      components *OpenApi_IComponents
-      tuple      *nativemetadata.MetadataTuple
-    }{components: props.components, tuple: tuple}))
-  }
-  for _, native := range props.metadata.Natives {
-    if nativehelpers.AtomicPredicator.Native(native.Name) {
-      typ := lowerAscii(native.Name)
-      if json_schema_station_has_atomic(props.metadata, typ) {
-        continue
-      }
-      atomic := nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: typ, Tags: [][]nativemetadata.IMetadataTypeTag{}})
-      if typ == "boolean" {
-        for _, schema := range json_schema_boolean(atomic) {
-          insert(schema)
-        }
-      } else if typ == "bigint" {
-        for _, schema := range json_schema_bigint(atomic) {
-          insert(schema)
-        }
-      } else if typ == "number" {
-        for _, schema := range json_schema_number(atomic) {
-          insert(schema)
-        }
-      } else if typ == "string" {
-        for _, schema := range json_schema_string(atomic) {
-          insert(schema)
-        }
-      }
-    } else {
-      for _, schema := range json_schema_native(struct {
-        components *OpenApi_IComponents
-        native     *nativemetadata.MetadataNative
-      }{components: props.components, native: native}) {
-        insert(schema)
-      }
-    }
-  }
-  if len(props.metadata.Sets) != 0 {
-    for _, schema := range json_schema_native(struct {
-      components *OpenApi_IComponents
-      native     *nativemetadata.MetadataNative
-    }{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Set", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
-      insert(schema)
-    }
-  }
-  if len(props.metadata.Maps) != 0 {
-    for _, schema := range json_schema_native(struct {
-      components *OpenApi_IComponents
-      native     *nativemetadata.MetadataNative
-    }{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Map", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
-      insert(schema)
-    }
-  }
-  for _, object := range props.metadata.Objects {
-    for _, schema := range json_schema_object(struct {
-      components *OpenApi_IComponents
-      object     *nativemetadata.MetadataObject
-    }{components: props.components, object: object}) {
-      insert(schema)
-    }
-  }
-  for _, alias := range props.metadata.Aliases {
-    for _, schema := range json_schema_alias(struct {
-      blockNever bool
-      components *OpenApi_IComponents
-      alias      *nativemetadata.MetadataAlias
-    }{blockNever: props.blockNever, components: props.components, alias: alias}) {
-      insert(schema)
-    }
-  }
-
-  if len(union) == 0 && props.blockNever {
-    return nil
-  }
-  var schema JsonSchema
-  if len(union) == 0 {
-    schema = JsonSchema{"type": nil}
-  } else if len(union) == 1 {
-    schema = union[0]
-  } else {
-    schema = JsonSchema{"oneOf": union}
-    if discriminator := json_schema_discriminator(props.metadata); discriminator != nil {
-      schema["discriminator"] = discriminator
-    }
-  }
-  return json_schema_station_mergeAttribute(schema, props.attribute)
-}
-
-func json_schema_station_has_atomic(metadata *nativemetadata.MetadataSchema, typ string) bool {
-  for _, atomic := range metadata.Atomics {
-    if atomic.Type == typ {
-      return true
-    }
-  }
-  return false
-}
-
-func json_schema_station_mergeAttribute(schema JsonSchema, attribute JsonSchema) JsonSchema {
-  output := cloneJsonSchema(schema)
-  for key, value := range attribute {
-    output[key] = value
-  }
-  for _, key := range []string{"title", "description", "deprecated"} {
-    if _, ok := attribute[key]; ok == false {
-      if value, ok := schema[key]; ok {
-        output[key] = value
-      }
-    }
-  }
-  return output
-}
-
-func json_schema_assign(target JsonSchema, source JsonSchema) {
-  for key, value := range source {
-    target[key] = value
-  }
-}
-
-func json_schema_is_string(schema JsonSchema) bool {
-  return schema["type"] == "string"
-}
-
-func json_schema_has_tag(tags []nativemetadata.IJsDocTagInfo, name string) bool {
-  for _, tag := range tags {
-    if tag.Name == name {
-      return true
-    }
-  }
-  return false
-}
-
-func json_schema_has_any_tag(tags []nativemetadata.IJsDocTagInfo, names []string) bool {
-  for _, name := range names {
-    if json_schema_has_tag(tags, name) {
-      return true
-    }
-  }
-  return false
-}
-
-func lowerAscii(str string) string {
-  bytes := []byte(str)
-  for i, ch := range bytes {
-    if 'A' <= ch && ch <= 'Z' {
-      bytes[i] = ch + ('a' - 'A')
-    }
-  }
-  return string(bytes)
-}
+package iterate
+
+import (
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type json_schema_station_props struct {
+  blockNever bool
+  components *OpenApi_IComponents
+  attribute  JsonSchema
+  metadata   *nativemetadata.MetadataSchema
+}
+
+type Json_schema_station_props struct {
+  BlockNever bool
+  Components *OpenApi_IComponents
+  Attribute  JsonSchema
+  Metadata   *nativemetadata.MetadataSchema
+}
+
+func Json_schema_station(props Json_schema_station_props) JsonSchema {
+  return json_schema_station(json_schema_station_props{
+    blockNever: props.BlockNever,
+    components: props.Components,
+    attribute:  props.Attribute,
+    metadata:   props.Metadata,
+  })
+}
+
+func json_schema_station(props json_schema_station_props) JsonSchema {
+  if props.metadata.Any {
+    output := cloneJsonSchema(props.attribute)
+    if _, ok := output["type"]; ok == false {
+      output["type"] = nil
+    }
+    return output
+  }
+
+  union := []JsonSchema{}
+  insert := func(schema JsonSchema) {
+    if schema != nil {
+      union = append(union, schema)
+    }
+  }
+
+  if props.metadata.Nullable {
+    insert(JsonSchema{"type": "null"})
+  }
+  if props.metadata.Escaped != nil {
+    for _, schema := range json_schema_escaped(struct {
+      components *OpenApi_IComponents
+      escaped    *nativemetadata.MetadataEscaped
+    }{components: props.components, escaped: props.metadata.Escaped}) {
+      insert(schema)
+    }
+  }
+  if len(props.metadata.Templates) != 0 && nativehelpers.AtomicPredicator.Template(props.metadata) {
+    for _, schema := range json_schema_templates(props.metadata) {
+      insert(schema)
+    }
+  }
+  for _, constant := range props.metadata.Constants {
+    if nativehelpers.AtomicPredicator.Constant(struct {
+      Metadata *nativemetadata.MetadataSchema
+      Name     string
+    }{Metadata: props.metadata, Name: constant.Type}) == false {
+      continue
+    }
+    for _, schema := range json_schema_constant(constant) {
+      insert(schema)
+    }
+  }
+  for _, atomic := range props.metadata.Atomics {
+    if atomic.Type == "boolean" {
+      for _, schema := range json_schema_boolean(atomic) {
+        insert(schema)
+      }
+    } else if atomic.Type == "bigint" {
+      for _, schema := range json_schema_bigint(atomic) {
+        insert(schema)
+      }
+    } else if atomic.Type == "number" {
+      for _, schema := range json_schema_number(atomic) {
+        insert(schema)
+      }
+    } else if atomic.Type == "string" {
+      for _, schema := range json_schema_string(atomic) {
+        insert(schema)
+      }
+    }
+  }
+  for _, array := range props.metadata.Arrays {
+    for _, schema := range json_schema_array(struct {
+      components *OpenApi_IComponents
+      array      *nativemetadata.MetadataArray
+    }{components: props.components, array: array}) {
+      insert(schema)
+    }
+  }
+  for _, tuple := range props.metadata.Tuples {
+    insert(json_schema_tuple(struct {
+      components *OpenApi_IComponents
+      tuple      *nativemetadata.MetadataTuple
+    }{components: props.components, tuple: tuple}))
+  }
+  for _, native := range props.metadata.Natives {
+    if nativehelpers.AtomicPredicator.Native(native.Name) {
+      typ := lowerAscii(native.Name)
+      if json_schema_station_has_atomic(props.metadata, typ) {
+        continue
+      }
+      atomic := nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: typ, Tags: [][]nativemetadata.IMetadataTypeTag{}})
+      if typ == "boolean" {
+        for _, schema := range json_schema_boolean(atomic) {
+          insert(schema)
+        }
+      } else if typ == "bigint" {
+        for _, schema := range json_schema_bigint(atomic) {
+          insert(schema)
+        }
+      } else if typ == "number" {
+        for _, schema := range json_schema_number(atomic) {
+          insert(schema)
+        }
+      } else if typ == "string" {
+        for _, schema := range json_schema_string(atomic) {
+          insert(schema)
+        }
+      }
+    } else {
+      for _, schema := range json_schema_native(struct {
+        components *OpenApi_IComponents
+        native     *nativemetadata.MetadataNative
+      }{components: props.components, native: native}) {
+        insert(schema)
+      }
+    }
+  }
+  if len(props.metadata.Sets) != 0 {
+    for _, schema := range json_schema_native(struct {
+      components *OpenApi_IComponents
+      native     *nativemetadata.MetadataNative
+    }{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Set", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
+      insert(schema)
+    }
+  }
+  if len(props.metadata.Maps) != 0 {
+    for _, schema := range json_schema_native(struct {
+      components *OpenApi_IComponents
+      native     *nativemetadata.MetadataNative
+    }{components: props.components, native: nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Map", Tags: [][]nativemetadata.IMetadataTypeTag{}})}) {
+      insert(schema)
+    }
+  }
+  for _, object := range props.metadata.Objects {
+    for _, schema := range json_schema_object(struct {
+      components *OpenApi_IComponents
+      object     *nativemetadata.MetadataObject
+    }{components: props.components, object: object}) {
+      insert(schema)
+    }
+  }
+  for _, alias := range props.metadata.Aliases {
+    for _, schema := range json_schema_alias(struct {
+      blockNever bool
+      components *OpenApi_IComponents
+      alias      *nativemetadata.MetadataAlias
+    }{blockNever: props.blockNever, components: props.components, alias: alias}) {
+      insert(schema)
+    }
+  }
+
+  if len(union) == 0 && props.blockNever {
+    return nil
+  }
+  var schema JsonSchema
+  if len(union) == 0 {
+    schema = JsonSchema{"type": nil}
+  } else if len(union) == 1 {
+    schema = union[0]
+  } else {
+    schema = JsonSchema{"oneOf": union}
+    if discriminator := json_schema_discriminator(props.metadata); discriminator != nil {
+      schema["discriminator"] = discriminator
+    }
+  }
+  return json_schema_station_mergeAttribute(schema, props.attribute)
+}
+
+func json_schema_station_has_atomic(metadata *nativemetadata.MetadataSchema, typ string) bool {
+  for _, atomic := range metadata.Atomics {
+    if atomic.Type == typ {
+      return true
+    }
+  }
+  return false
+}
+
+func json_schema_station_mergeAttribute(schema JsonSchema, attribute JsonSchema) JsonSchema {
+  output := cloneJsonSchema(schema)
+  for key, value := range attribute {
+    output[key] = value
+  }
+  for _, key := range []string{"title", "description", "deprecated"} {
+    if _, ok := attribute[key]; ok == false {
+      if value, ok := schema[key]; ok {
+        output[key] = value
+      }
+    }
+  }
+  return output
+}
+
+func json_schema_assign(target JsonSchema, source JsonSchema) {
+  for key, value := range source {
+    target[key] = value
+  }
+}
+
+func json_schema_is_string(schema JsonSchema) bool {
+  return schema["type"] == "string"
+}
+
+func json_schema_has_tag(tags []nativemetadata.IJsDocTagInfo, name string) bool {
+  for _, tag := range tags {
+    if tag.Name == name {
+      return true
+    }
+  }
+  return false
+}
+
+func json_schema_has_any_tag(tags []nativemetadata.IJsDocTagInfo, names []string) bool {
+  for _, name := range names {
+    if json_schema_has_tag(tags, name) {
+      return true
+    }
+  }
+  return false
+}
+
+func lowerAscii(str string) string {
+  bytes := []byte(str)
+  for i, ch := range bytes {
+    if 'A' <= ch && ch <= 'Z' {
+      bytes[i] = ch + ('a' - 'A')
+    }
+  }
+  return string(bytes)
+}

package/native/core/programmers/iterate/json_schema_string.go

@@ -1,17 +1,17 @@
-package iterate
-
-import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-
-func json_schema_string(atomic *nativemetadata.MetadataAtomic) []JsonSchema {
-  return json_schema_plugin(struct {
-    schema JsonSchema
-    tags   [][]nativemetadata.IMetadataTypeTag
-  }{
-    schema: JsonSchema{"type": "string"},
-    tags:   atomic.Tags,
-  })
-}
-
-func Json_schema_string_export(atomic *nativemetadata.MetadataAtomic) []JsonSchema {
-  return json_schema_string(atomic)
-}
+package iterate
+
+import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+func json_schema_string(atomic *nativemetadata.MetadataAtomic) []JsonSchema {
+  return json_schema_plugin(struct {
+    schema JsonSchema
+    tags   [][]nativemetadata.IMetadataTypeTag
+  }{
+    schema: JsonSchema{"type": "string"},
+    tags:   atomic.Tags,
+  })
+}
+
+func Json_schema_string_export(atomic *nativemetadata.MetadataAtomic) []JsonSchema {
+  return json_schema_string(atomic)
+}

package/native/core/programmers/iterate/json_schema_template.go

@@ -1,63 +1,63 @@
-package iterate
-
-import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-
-func json_schema_templates(metadata *nativemetadata.MetadataSchema) []JsonSchema {
-  pureTemplates := []*nativemetadata.MetadataTemplate{}
-  taggedTemplates := []*nativemetadata.MetadataTemplate{}
-  for _, tpl := range metadata.Templates {
-    if json_schema_template_isPure(tpl.Tags) {
-      pureTemplates = append(pureTemplates, tpl)
-    } else {
-      taggedTemplates = append(taggedTemplates, tpl)
-    }
-  }
-
-  output := []JsonSchema{}
-  if len(pureTemplates) != 0 {
-    meta := nativemetadata.MetadataSchema_initialize()
-    meta.Templates = pureTemplates
-    output = append(output, JsonSchema{
-      "type": "string",
-      "pattern": metadata_to_pattern(struct {
-        top      bool
-        metadata *nativemetadata.MetadataSchema
-      }{
-        top:      true,
-        metadata: meta,
-      }),
-    })
-  }
-  for _, tpl := range taggedTemplates {
-    meta := nativemetadata.MetadataSchema_initialize()
-    meta.Templates = []*nativemetadata.MetadataTemplate{tpl}
-    output = append(output, json_schema_plugin(struct {
-      schema JsonSchema
-      tags   [][]nativemetadata.IMetadataTypeTag
-    }{
-      schema: JsonSchema{
-        "type": "string",
-        "pattern": metadata_to_pattern(struct {
-          top      bool
-          metadata *nativemetadata.MetadataSchema
-        }{
-          top:      false,
-          metadata: meta,
-        }),
-      },
-      tags: tpl.Tags,
-    })...)
-  }
-  return output
-}
-
-func json_schema_template_isPure(matrix [][]nativemetadata.IMetadataTypeTag) bool {
-  for _, tags := range matrix {
-    for _, tag := range tags {
-      if tag.Schema != nil {
-        return false
-      }
-    }
-  }
-  return true
-}
+package iterate
+
+import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+func json_schema_templates(metadata *nativemetadata.MetadataSchema) []JsonSchema {
+  pureTemplates := []*nativemetadata.MetadataTemplate{}
+  taggedTemplates := []*nativemetadata.MetadataTemplate{}
+  for _, tpl := range metadata.Templates {
+    if json_schema_template_isPure(tpl.Tags) {
+      pureTemplates = append(pureTemplates, tpl)
+    } else {
+      taggedTemplates = append(taggedTemplates, tpl)
+    }
+  }
+
+  output := []JsonSchema{}
+  if len(pureTemplates) != 0 {
+    meta := nativemetadata.MetadataSchema_initialize()
+    meta.Templates = pureTemplates
+    output = append(output, JsonSchema{
+      "type": "string",
+      "pattern": metadata_to_pattern(struct {
+        top      bool
+        metadata *nativemetadata.MetadataSchema
+      }{
+        top:      true,
+        metadata: meta,
+      }),
+    })
+  }
+  for _, tpl := range taggedTemplates {
+    meta := nativemetadata.MetadataSchema_initialize()
+    meta.Templates = []*nativemetadata.MetadataTemplate{tpl}
+    output = append(output, json_schema_plugin(struct {
+      schema JsonSchema
+      tags   [][]nativemetadata.IMetadataTypeTag
+    }{
+      schema: JsonSchema{
+        "type": "string",
+        "pattern": metadata_to_pattern(struct {
+          top      bool
+          metadata *nativemetadata.MetadataSchema
+        }{
+          top:      false,
+          metadata: meta,
+        }),
+      },
+      tags: tpl.Tags,
+    })...)
+  }
+  return output
+}
+
+func json_schema_template_isPure(matrix [][]nativemetadata.IMetadataTypeTag) bool {
+  for _, tags := range matrix {
+    for _, tag := range tags {
+      if tag.Schema != nil {
+        return false
+      }
+    }
+  }
+  return true
+}