JsonSchema
public class JsonSchema : JsonReferenceBase<JsonSchema>, IDocumentPathProvider, IJsonReference, IJsonReferenceBase, IJsonExtensionObject
A base class for describing a JSON schema.
using Namotion.Reflection;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NJsonSchema.Collections;
using NJsonSchema.Generation;
using NJsonSchema.Infrastructure;
using NJsonSchema.References;
using NJsonSchema.Validation;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
namespace NJsonSchema
{
[System.Runtime.CompilerServices.NullableContext(2)]
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
[JsonConverter(typeof(ExtensionDataDeserializationConverter))]
public class JsonSchema : JsonReferenceBase<JsonSchema>, IDocumentPathProvider, IJsonReference, IJsonReferenceBase, IJsonExtensionObject
{
[System.Runtime.CompilerServices.Nullable(1)]
internal static readonly HashSet<string> JsonSchemaPropertiesCache = new HashSet<string>((from p in ContextualTypeExtensions.GetContextualProperties(typeof(JsonSchema))
select p.get_Name()).ToArray());
private const SchemaType SerializationSchemaType = SchemaType.JsonSchema;
[System.Runtime.CompilerServices.Nullable(1)]
private static readonly Lazy<PropertyRenameAndIgnoreSerializerContractResolver> ContractResolver = new Lazy<PropertyRenameAndIgnoreSerializerContractResolver>(() => CreateJsonSerializerContractResolver(SchemaType.JsonSchema));
[System.Runtime.CompilerServices.Nullable(1)]
private ObservableDictionary<string, JsonSchemaProperty> _properties;
[System.Runtime.CompilerServices.Nullable(1)]
private ObservableDictionary<string, JsonSchemaProperty> _patternProperties;
[System.Runtime.CompilerServices.Nullable(1)]
private ObservableDictionary<string, JsonSchema> _definitions;
[System.Runtime.CompilerServices.Nullable(1)]
internal ObservableCollection<JsonSchema> _allOf;
[System.Runtime.CompilerServices.Nullable(1)]
internal ObservableCollection<JsonSchema> _anyOf;
[System.Runtime.CompilerServices.Nullable(1)]
internal ObservableCollection<JsonSchema> _oneOf;
private JsonSchema _not;
private JsonSchema _dictionaryKey;
private JsonObjectType _type;
private JsonSchema _item;
[System.Runtime.CompilerServices.Nullable(1)]
internal ObservableCollection<JsonSchema> _items;
private bool _allowAdditionalItems = true;
private JsonSchema _additionalItemsSchema;
private bool _allowAdditionalProperties = true;
private JsonSchema _additionalPropertiesSchema;
[System.Runtime.CompilerServices.Nullable(1)]
private static readonly string version = typeof(JsonSchema).GetTypeInfo().Assembly.GetName().Version?.ToString() + " (Newtonsoft.Json v" + typeof(JToken).GetTypeInfo().Assembly.GetName().Version?.ToString() + ")";
[JsonIgnore]
private JsonXmlObject _xmlObject;
[System.Runtime.CompilerServices.Nullable(1)]
private static readonly JsonObjectType[] _jsonObjectTypeValues = (from v in Enum.GetValues(typeof(JsonObjectType)).OfType<JsonObjectType>()
where (int)v > 0
select v).ToArray();
[System.Runtime.CompilerServices.Nullable(1)]
private readonly NotifyCollectionChangedEventHandler _initializeSchemaCollectionEventHandler;
private Lazy<object> _typeRaw;
[System.Runtime.CompilerServices.Nullable(1)]
public static string ToolchainVersion {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return version;
}
}
[JsonIgnore]
public bool IsBinary {
get {
if (!Type.IsFile()) {
if (Type.IsString())
return Format == "binary";
return false;
}
return true;
}
}
[JsonIgnore]
public JsonSchema InheritedSchema {
get {
if (_allOf == null || _allOf.Count == 0 || HasReference)
return null;
if (_allOf.Count == 1)
return _allOf[0].ActualSchema;
JsonSchema jsonSchema = _allOf.FirstOrDefault((JsonSchema s) => s.HasReference);
if (jsonSchema != null)
return jsonSchema.ActualSchema;
JsonSchema jsonSchema2 = _allOf.FirstOrDefault((JsonSchema s) => s.Type.IsObject());
if (jsonSchema2 != null)
return jsonSchema2.ActualSchema;
return _allOf.FirstOrDefault()?.ActualSchema;
}
}
[JsonIgnore]
public JsonSchema InheritedTypeSchema {
get {
if (InheritedSchema == null && (ActualTypeSchema.IsDictionary || ActualTypeSchema.IsArray || ActualTypeSchema.IsTuple))
return ActualTypeSchema;
return InheritedSchema;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public IReadOnlyCollection<JsonSchema> AllInheritedSchemas {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
List<JsonSchema> list = (InheritedSchema != null) ? new List<JsonSchema> {
InheritedSchema
} : new List<JsonSchema>();
return list.Concat(list.SelectMany((JsonSchema s) => s.AllInheritedSchemas)).ToList();
}
}
[JsonIgnore]
public OpenApiDiscriminator ResponsibleDiscriminatorObject {
get {
object openApiDiscriminator = ActualDiscriminatorObject;
if (openApiDiscriminator == null) {
JsonSchema inheritedSchema = InheritedSchema;
if (inheritedSchema == null)
return null;
openApiDiscriminator = inheritedSchema.ActualSchema.ResponsibleDiscriminatorObject;
}
return (OpenApiDiscriminator)openApiDiscriminator;
}
}
[JsonIgnore]
public bool HasActualProperties {
get {
if (_properties.Count > 0)
return true;
for (int i = 0; i < _allOf.Count; i++) {
JsonSchema jsonSchema = _allOf[i];
if (jsonSchema.ActualSchema != InheritedSchema && jsonSchema.ActualSchema.HasActualProperties)
return true;
}
return false;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public IReadOnlyDictionary<string, JsonSchemaProperty> ActualProperties {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
if (_allOf.Count != 0) {
IEnumerable<KeyValuePair<string, JsonSchemaProperty>> source = _properties.Union((from s in _allOf
where s.ActualSchema != InheritedSchema
select s).SelectMany((JsonSchema s) => s.ActualSchema.ActualProperties));
try {
return source.ToDictionary((KeyValuePair<string, JsonSchemaProperty> p) => p.Key, (KeyValuePair<string, JsonSchemaProperty> p) => p.Value);
} catch (ArgumentException) {
IEnumerable<IGrouping<string, KeyValuePair<string, JsonSchemaProperty>>> source2 = from p in source
group p by p.Key into g
where g.Count() > 1
select g;
throw new InvalidOperationException("The properties " + string.Join(", ", from g in source2
select "'" + g.Key + "'") + " are defined multiple times.");
}
}
return new Dictionary<string, JsonSchemaProperty>(_properties);
}
}
[JsonProperty("$schema", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate, Order = -99)]
public string SchemaVersion { get; set; }
[JsonProperty("id", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate, Order = -98)]
public string Id { get; set; }
[JsonProperty("title", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate, Order = -97)]
public string Title { get; set; }
[JsonIgnore]
public bool HasTypeNameTitle {
get {
if (!string.IsNullOrEmpty(Title))
return Regex.IsMatch(Title, "^[a-zA-Z0-9_]*$");
return false;
}
}
[JsonProperty("description", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public virtual string Description { get; set; }
[JsonIgnore]
public JsonObjectType Type {
get {
return _type;
}
set {
_type = value;
ResetTypeRaw();
}
}
[JsonIgnore]
public JsonSchema ParentSchema {
get {
return Parent as JsonSchema;
}
}
[JsonIgnore]
public virtual object Parent { get; set; }
[JsonProperty("format", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public string Format { get; set; }
[JsonProperty("default", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public object Default { get; set; }
[JsonProperty("multipleOf", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public decimal? MultipleOf { get; set; }
[JsonProperty("maximum", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public decimal? Maximum { get; set; }
[JsonIgnore]
public decimal? ExclusiveMaximum { get; set; }
[JsonIgnore]
public bool IsExclusiveMaximum { get; set; }
[JsonProperty("minimum", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public decimal? Minimum { get; set; }
[JsonIgnore]
public decimal? ExclusiveMinimum { get; set; }
[JsonIgnore]
public bool IsExclusiveMinimum { get; set; }
[JsonProperty("maxLength", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public int? MaxLength { get; set; }
[JsonProperty("minLength", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public int? MinLength { get; set; }
[JsonProperty("pattern", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public string Pattern { get; set; }
[JsonProperty("maxItems", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public int MaxItems { get; set; }
[JsonProperty("minItems", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public int MinItems { get; set; }
[JsonProperty("uniqueItems", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public bool UniqueItems { get; set; }
[JsonProperty("maxProperties", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public int MaxProperties { get; set; }
[JsonProperty("minProperties", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public int MinProperties { get; set; }
[JsonProperty("x-deprecated", DefaultValueHandling = DefaultValueHandling.Ignore)]
public bool IsDeprecated { get; set; }
[JsonProperty("x-deprecatedMessage", DefaultValueHandling = DefaultValueHandling.Ignore)]
public string DeprecatedMessage { get; set; }
[JsonProperty("x-abstract", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public bool IsAbstract { get; set; }
[JsonProperty("x-nullable", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public bool? IsNullableRaw { get; set; }
[JsonProperty("x-example", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public object Example { get; set; }
[JsonProperty("x-enumFlags", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public bool IsFlagEnumerable { get; set; }
[System.Runtime.CompilerServices.Nullable(new byte[] {
1,
2
})]
[JsonIgnore]
[field: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
2
})]
public ICollection<object> Enumeration {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
2
})]
get;
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
2
})]
internal set;
}
[JsonIgnore]
public bool IsEnumeration {
get {
return Enumeration.Count > 0;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
[field: System.Runtime.CompilerServices.Nullable(1)]
public ICollection<string> RequiredProperties {
[System.Runtime.CompilerServices.NullableContext(1)]
get;
[System.Runtime.CompilerServices.NullableContext(1)]
internal set;
}
[JsonProperty("x-dictionaryKey", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public JsonSchema DictionaryKey {
get {
return _dictionaryKey;
}
set {
_dictionaryKey = value;
if (_dictionaryKey != null)
_dictionaryKey.Parent = this;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public IDictionary<string, JsonSchemaProperty> Properties {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return _properties;
}
[System.Runtime.CompilerServices.NullableContext(1)]
internal set {
if (_properties != value) {
ObservableDictionary<string, JsonSchemaProperty> observableDictionary = ToObservableDictionary(value);
RegisterProperties(_properties, observableDictionary);
_properties = observableDictionary;
}
}
}
[JsonProperty("xml", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public JsonXmlObject Xml {
get {
return _xmlObject;
}
set {
_xmlObject = value;
if (_xmlObject != null)
_xmlObject.ParentSchema = this;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public IDictionary<string, JsonSchemaProperty> PatternProperties {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return _patternProperties;
}
[System.Runtime.CompilerServices.NullableContext(1)]
internal set {
if (_patternProperties != value) {
ObservableDictionary<string, JsonSchemaProperty> observableDictionary = ToObservableDictionary(value);
RegisterSchemaDictionary(_patternProperties, observableDictionary);
_patternProperties = observableDictionary;
}
}
}
[JsonIgnore]
public JsonSchema Item {
get {
return _item;
}
set {
if (_item != value) {
_item = value;
if (_item != null) {
_item.Parent = this;
Items.Clear();
}
}
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public ICollection<JsonSchema> Items {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return _items;
}
[System.Runtime.CompilerServices.NullableContext(1)]
internal set {
if (_items != value) {
ObservableCollection<JsonSchema> observableCollection = ToObservableCollection(value);
RegisterSchemaCollection(_items, observableCollection);
_items = observableCollection;
if (_items != null)
Item = null;
}
}
}
[JsonProperty("not", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
public JsonSchema Not {
get {
return _not;
}
set {
_not = value;
if (_not != null)
_not.Parent = this;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public IDictionary<string, JsonSchema> Definitions {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return _definitions;
}
[System.Runtime.CompilerServices.NullableContext(1)]
internal set {
if (_definitions != value) {
ObservableDictionary<string, JsonSchema> observableDictionary = ToObservableDictionary(value);
RegisterSchemaDictionary(_definitions, observableDictionary);
_definitions = observableDictionary;
}
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public ICollection<JsonSchema> AllOf {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return _allOf;
}
[System.Runtime.CompilerServices.NullableContext(1)]
internal set {
if (_allOf != value) {
ObservableCollection<JsonSchema> observableCollection = ToObservableCollection(value);
RegisterSchemaCollection(_allOf, observableCollection);
_allOf = observableCollection;
}
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public ICollection<JsonSchema> AnyOf {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return _anyOf;
}
[System.Runtime.CompilerServices.NullableContext(1)]
internal set {
if (_anyOf != value) {
ObservableCollection<JsonSchema> observableCollection = ToObservableCollection(value);
RegisterSchemaCollection(_anyOf, observableCollection);
_anyOf = observableCollection;
}
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public ICollection<JsonSchema> OneOf {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return _oneOf;
}
[System.Runtime.CompilerServices.NullableContext(1)]
internal set {
if (_oneOf != value) {
ObservableCollection<JsonSchema> observableCollection = ToObservableCollection(value);
RegisterSchemaCollection(_oneOf, observableCollection);
_oneOf = observableCollection;
}
}
}
[JsonIgnore]
public bool AllowAdditionalItems {
get {
return _allowAdditionalItems;
}
set {
if (_allowAdditionalItems != value) {
_allowAdditionalItems = value;
if (!_allowAdditionalItems)
AdditionalItemsSchema = null;
}
}
}
[JsonIgnore]
public JsonSchema AdditionalItemsSchema {
get {
return _additionalItemsSchema;
}
set {
if (_additionalItemsSchema != value) {
_additionalItemsSchema = value;
if (_additionalItemsSchema != null)
AllowAdditionalItems = true;
}
}
}
[JsonIgnore]
public bool AllowAdditionalProperties {
get {
return _allowAdditionalProperties;
}
set {
if (_allowAdditionalProperties != value) {
_allowAdditionalProperties = value;
if (!_allowAdditionalProperties)
AdditionalPropertiesSchema = null;
}
}
}
[JsonIgnore]
public JsonSchema AdditionalPropertiesSchema {
get {
return _additionalPropertiesSchema;
}
set {
if (_additionalPropertiesSchema != value) {
_additionalPropertiesSchema = value;
if (_additionalPropertiesSchema != null)
AllowAdditionalProperties = true;
}
}
}
[JsonIgnore]
public bool IsObject {
get {
return Type.IsObject();
}
}
[JsonIgnore]
public bool IsArray {
get {
if (Type.IsArray()) {
if (Items != null)
return Items.Count == 0;
return true;
}
return false;
}
}
[JsonIgnore]
public bool IsTuple {
get {
if (Type.IsArray()) {
ICollection<JsonSchema> items = Items;
if (items == null)
return false;
return items.Count > 0;
}
return false;
}
}
[JsonIgnore]
public bool IsDictionary {
get {
if (Type.IsObject() && !HasActualProperties) {
if (AdditionalPropertiesSchema == null)
return PatternProperties.Any();
return true;
}
return false;
}
}
[JsonIgnore]
public bool IsAnyType {
get {
if ((Type.IsObject() || (int)Type == 0) && Reference == null && _allOf.Count == 0 && _anyOf.Count == 0 && _oneOf.Count == 0 && !HasActualProperties && _patternProperties.Count == 0 && AdditionalPropertiesSchema == null && !MultipleOf.HasValue)
return !IsEnumeration;
return false;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public virtual JsonSchema ActualSchema {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return GetActualSchema(new List<JsonSchema>());
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
public virtual JsonSchema ActualTypeSchema {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
JsonSchema jsonSchema = (Reference != null) ? Reference : this;
if (jsonSchema._allOf.Count > 1 && jsonSchema._allOf.Count(delegate(JsonSchema s) {
if (!s.HasReference)
return !s.IsDictionary;
return false;
}) == 1)
return jsonSchema._allOf.First(delegate(JsonSchema s) {
if (!s.HasReference)
return !s.IsDictionary;
return false;
}).ActualSchema;
return jsonSchema._oneOf.FirstOrDefault((JsonSchema o) => !o.IsNullable(SchemaType.JsonSchema))?.ActualSchema ?? ActualSchema;
}
}
[JsonIgnore]
public bool HasReference {
get {
if (Reference == null && !HasAllOfSchemaReference && !HasOneOfSchemaReference)
return HasAnyOfSchemaReference;
return true;
}
}
[JsonIgnore]
public bool HasAllOfSchemaReference {
get {
if ((int)Type == 0 && _anyOf.Count == 0 && _oneOf.Count == 0 && _properties.Count == 0 && _patternProperties.Count == 0 && AdditionalPropertiesSchema == null && !MultipleOf.HasValue && !IsEnumeration && _allOf.Count == 1)
return _allOf.Any((JsonSchema s) => s.HasReference);
return false;
}
}
[JsonIgnore]
public bool HasOneOfSchemaReference {
get {
if ((int)Type == 0 && _anyOf.Count == 0 && _allOf.Count == 0 && _properties.Count == 0 && _patternProperties.Count == 0 && AdditionalPropertiesSchema == null && !MultipleOf.HasValue && !IsEnumeration && _oneOf.Count == 1)
return _oneOf.Any((JsonSchema s) => s.HasReference);
return false;
}
}
[JsonIgnore]
public bool HasAnyOfSchemaReference {
get {
if ((int)Type == 0 && _allOf.Count == 0 && _oneOf.Count == 0 && _properties.Count == 0 && _patternProperties.Count == 0 && AdditionalPropertiesSchema == null && !MultipleOf.HasValue && !IsEnumeration && _anyOf.Count == 1)
return _anyOf.Any((JsonSchema s) => s.HasReference);
return false;
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
IJsonReference IJsonReference.ActualObject {
[System.Runtime.CompilerServices.NullableContext(1)]
get {
return ActualSchema;
}
}
[JsonIgnore]
object IJsonReference.PossibleRoot {
get {
return Parent;
}
}
[JsonIgnore]
public override JsonSchema Reference {
get {
return base.Reference;
}
set {
base.Reference = value;
if (value != null)
Type = 0;
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
2
})]
[JsonExtensionData]
[field: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
2
})]
public IDictionary<string, object> ExtensionData {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
2
})]
get;
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
2
})]
set;
}
[JsonIgnore]
public string ActualDiscriminator {
get {
return ActualTypeSchema.Discriminator;
}
}
[JsonIgnore]
public string Discriminator {
get {
return DiscriminatorObject?.PropertyName;
}
set {
if (!string.IsNullOrEmpty(value))
DiscriminatorObject = new OpenApiDiscriminator {
PropertyName = value
};
else
DiscriminatorObject = null;
}
}
[JsonIgnore]
public OpenApiDiscriminator ActualDiscriminatorObject {
get {
return DiscriminatorObject ?? ActualTypeSchema.DiscriminatorObject;
}
}
[JsonIgnore]
public OpenApiDiscriminator DiscriminatorObject { get; set; }
[JsonProperty("discriminator", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate, Order = -95)]
internal object DiscriminatorRaw {
get {
if (JsonSchemaSerialization.CurrentSchemaType != SchemaType.Swagger2)
return DiscriminatorObject;
return Discriminator;
}
set {
if (value is string)
Discriminator = (string)value;
else if (value != null) {
DiscriminatorObject = ((JObject)value).ToObject<OpenApiDiscriminator>();
}
}
}
[System.Runtime.CompilerServices.Nullable(1)]
[JsonIgnore]
[field: System.Runtime.CompilerServices.Nullable(1)]
public Collection<string> EnumerationNames {
[System.Runtime.CompilerServices.NullableContext(1)]
get;
[System.Runtime.CompilerServices.NullableContext(1)]
set;
}
[JsonProperty("exclusiveMaximum", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal object ExclusiveMaximumRaw {
get {
decimal? exclusiveMaximum = ExclusiveMaximum;
if (!exclusiveMaximum.HasValue) {
if (!IsExclusiveMaximum)
return null;
return true;
}
return exclusiveMaximum.GetValueOrDefault();
}
set {
if (value is bool)
IsExclusiveMaximum = (bool)value;
else if (value != null && (value.Equals("true") || value.Equals("false"))) {
IsExclusiveMaximum = value.Equals("true");
} else if (value != null) {
ExclusiveMaximum = Convert.ToDecimal(value, CultureInfo.InvariantCulture);
}
}
}
[JsonProperty("exclusiveMinimum", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal object ExclusiveMinimumRaw {
get {
decimal? exclusiveMinimum = ExclusiveMinimum;
if (!exclusiveMinimum.HasValue) {
if (!IsExclusiveMinimum)
return null;
return true;
}
return exclusiveMinimum.GetValueOrDefault();
}
set {
if (value is bool)
IsExclusiveMinimum = (bool)value;
else if (value != null && (value.Equals("true") || value.Equals("false"))) {
IsExclusiveMinimum = value.Equals("true");
} else if (value != null) {
ExclusiveMinimum = Convert.ToDecimal(value, CultureInfo.InvariantCulture);
}
}
}
[JsonProperty("additionalItems", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal object AdditionalItemsRaw {
get {
if (AdditionalItemsSchema != null)
return AdditionalItemsSchema;
if (!AllowAdditionalItems)
return false;
return null;
}
set {
if (value is bool)
AllowAdditionalItems = (bool)value;
else if (value != null && (value.Equals("true") || value.Equals("false"))) {
AllowAdditionalItems = value.Equals("true");
} else if (value != null) {
AdditionalItemsSchema = FromJsonWithCurrentSettings(value);
}
}
}
[JsonProperty("additionalProperties", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal object AdditionalPropertiesRaw {
get {
if (AdditionalPropertiesSchema != null)
return AdditionalPropertiesSchema;
if (JsonSchemaSerialization.CurrentSchemaType == SchemaType.Swagger2) {
if (AllowAdditionalProperties && (Type.IsObject() || (int)Type == 0) && !HasReference && !_allOf.Any() && !TypeExtensions.IsAssignableToTypeName(GetType(), "OpenApiParameter", 0))
return new JObject();
return null;
}
if (!AllowAdditionalProperties)
return false;
return null;
}
set {
if (value is bool)
AllowAdditionalProperties = (bool)value;
else if (value != null && (value.Equals("true") || value.Equals("false"))) {
AllowAdditionalProperties = value.Equals("true");
} else if (value != null) {
AdditionalPropertiesSchema = FromJsonWithCurrentSettings(value);
}
}
}
[JsonProperty("items", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal object ItemsRaw {
get {
if (Item != null)
return Item;
if (Items.Count > 0)
return Items;
return null;
}
set {
if (value is JArray)
Items = new ObservableCollection<JsonSchema>(from t in (JArray)value
select FromJsonWithCurrentSettings(t));
else if (value != null) {
Item = FromJsonWithCurrentSettings(value);
}
}
}
[JsonProperty("type", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate, Order = -97)]
internal object TypeRaw {
get {
if (_typeRaw == null)
ResetTypeRaw();
return _typeRaw.Value;
}
set {
if (value is JArray)
Type = ((JArray)value).Aggregate<JToken, JsonObjectType>(0, (JsonObjectType type, JToken token) => type | ConvertStringToJsonObjectType(token.ToString()));
else
Type = ConvertStringToJsonObjectType(value as string);
ResetTypeRaw();
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
[JsonProperty("required", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal ICollection<string> RequiredPropertiesRaw {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
get {
if (RequiredProperties == null || RequiredProperties.Count <= 0)
return null;
return RequiredProperties;
}
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
set {
RequiredProperties = (value ?? new List<string>());
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
[JsonProperty("properties", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal IDictionary<string, JsonSchemaProperty> PropertiesRaw {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
get {
if (_properties == null || _properties.Count <= 0)
return null;
return Properties;
}
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
set {
Properties = ((value != null) ? new ObservableDictionary<string, JsonSchemaProperty>(value) : new ObservableDictionary<string, JsonSchemaProperty>());
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
[JsonProperty("patternProperties", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal IDictionary<string, JsonSchemaProperty> PatternPropertiesRaw {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
get {
if (_patternProperties == null || _patternProperties.Count <= 0)
return null;
return PatternProperties.ToDictionary((KeyValuePair<string, JsonSchemaProperty> p) => p.Key, (KeyValuePair<string, JsonSchemaProperty> p) => p.Value);
}
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
set {
PatternProperties = ((value != null) ? new ObservableDictionary<string, JsonSchemaProperty>(value) : new ObservableDictionary<string, JsonSchemaProperty>());
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
[JsonProperty("definitions", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal IDictionary<string, JsonSchema> DefinitionsRaw {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
get {
if (Definitions == null || Definitions.Count <= 0)
return null;
return Definitions;
}
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})]
set {
Definitions = ((value != null) ? new ObservableDictionary<string, JsonSchema>(value) : new ObservableDictionary<string, JsonSchema>());
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
[JsonProperty("x-enumNames", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal Collection<string> EnumerationNamesRaw {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
get {
if (EnumerationNames == null || EnumerationNames.Count <= 0)
return null;
return EnumerationNames;
}
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
set {
EnumerationNames = ((value != null) ? new ObservableCollection<string>(value) : new ObservableCollection<string>());
}
}
[JsonProperty("enum", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal ICollection<object> EnumerationRaw {
get {
if (Enumeration == null || Enumeration.Count <= 0)
return null;
return Enumeration;
}
set {
Enumeration = ((value != null) ? new ObservableCollection<object>(value) : new ObservableCollection<object>());
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
[JsonProperty("allOf", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal ICollection<JsonSchema> AllOfRaw {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
get {
if (_allOf == null || _allOf.Count <= 0)
return null;
return AllOf;
}
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
set {
AllOf = ((value != null) ? new ObservableCollection<JsonSchema>(value) : new ObservableCollection<JsonSchema>());
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
[JsonProperty("anyOf", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal ICollection<JsonSchema> AnyOfRaw {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
get {
if (_anyOf == null || _anyOf.Count <= 0)
return null;
return AnyOf;
}
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
set {
AnyOf = ((value != null) ? new ObservableCollection<JsonSchema>(value) : new ObservableCollection<JsonSchema>());
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
[JsonProperty("oneOf", DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate)]
internal ICollection<JsonSchema> OneOfRaw {
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
get {
if (_oneOf == null || _oneOf.Count <= 0)
return null;
return OneOf;
}
[param: System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
set {
OneOf = ((value != null) ? new ObservableCollection<JsonSchema>(value) : new ObservableCollection<JsonSchema>());
}
}
public JsonSchema()
{
_initializeSchemaCollectionEventHandler = InitializeSchemaCollection;
Initialize();
if (JsonSchemaSerialization.CurrentSchemaType == SchemaType.Swagger2)
_allowAdditionalProperties = false;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static JsonSchema CreateAnySchema()
{
return new JsonSchema();
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static TSchemaType CreateAnySchema<[System.Runtime.CompilerServices.Nullable(0)] TSchemaType>() where TSchemaType : JsonSchema, new
{
return new TSchemaType();
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static Task<JsonSchema> FromFileAsync(string filePath, CancellationToken cancellationToken = default(CancellationToken))
{
Func<JsonSchema, JsonReferenceResolver> referenceResolverFactory = JsonReferenceResolver.CreateJsonReferenceResolverFactory(new DefaultTypeNameGenerator());
return FromFileAsync(filePath, referenceResolverFactory, cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static Task<JsonSchema> FromFileAsync(string filePath, Func<JsonSchema, JsonReferenceResolver> referenceResolverFactory, CancellationToken cancellationToken = default(CancellationToken))
{
using (FileStream stream = File.OpenRead(filePath))
return FromJsonAsync(stream, filePath, referenceResolverFactory, cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static Task<JsonSchema> FromUrlAsync(string url, CancellationToken cancellationToken = default(CancellationToken))
{
Func<JsonSchema, JsonReferenceResolver> referenceResolverFactory = JsonReferenceResolver.CreateJsonReferenceResolverFactory(new DefaultTypeNameGenerator());
return FromUrlAsync(url, referenceResolverFactory, cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
[AsyncStateMachine(typeof(<FromUrlAsync>d__27))]
public static Task<JsonSchema> FromUrlAsync(string url, Func<JsonSchema, JsonReferenceResolver> referenceResolverFactory, CancellationToken cancellationToken = default(CancellationToken))
{
<FromUrlAsync>d__27 stateMachine = default(<FromUrlAsync>d__27);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<JsonSchema>.Create();
stateMachine.url = url;
stateMachine.referenceResolverFactory = referenceResolverFactory;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static Task<JsonSchema> FromJsonAsync(string data, CancellationToken cancellationToken = default(CancellationToken))
{
return FromJsonAsync(data, null, cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static Task<JsonSchema> FromJsonAsync(Stream stream, CancellationToken cancellationToken = default(CancellationToken))
{
Func<JsonSchema, JsonReferenceResolver> referenceResolverFactory = JsonReferenceResolver.CreateJsonReferenceResolverFactory(new DefaultTypeNameGenerator());
return FromJsonAsync(stream, null, referenceResolverFactory, cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static Task<JsonSchema> FromJsonAsync(string data, [System.Runtime.CompilerServices.Nullable(2)] string documentPath, CancellationToken cancellationToken = default(CancellationToken))
{
Func<JsonSchema, JsonReferenceResolver> referenceResolverFactory = JsonReferenceResolver.CreateJsonReferenceResolverFactory(new DefaultTypeNameGenerator());
return FromJsonAsync(data, documentPath, referenceResolverFactory, cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static Task<JsonSchema> FromJsonAsync(string data, [System.Runtime.CompilerServices.Nullable(2)] string documentPath, Func<JsonSchema, JsonReferenceResolver> referenceResolverFactory, CancellationToken cancellationToken = default(CancellationToken))
{
return JsonSchemaSerialization.FromJsonAsync(data, SchemaType.JsonSchema, documentPath, referenceResolverFactory, ContractResolver.Value, cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static Task<JsonSchema> FromJsonAsync(Stream stream, [System.Runtime.CompilerServices.Nullable(2)] string documentPath, Func<JsonSchema, JsonReferenceResolver> referenceResolverFactory, CancellationToken cancellationToken = default(CancellationToken))
{
return JsonSchemaSerialization.FromJsonAsync(stream, SchemaType.JsonSchema, documentPath, referenceResolverFactory, ContractResolver.Value, cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static JsonSchema FromType<[System.Runtime.CompilerServices.Nullable(2)] TType>()
{
return FromType<TType>(new SystemTextJsonSchemaGeneratorSettings());
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static JsonSchema FromType(Type type)
{
return FromType(type, new SystemTextJsonSchemaGeneratorSettings());
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static JsonSchema FromType<[System.Runtime.CompilerServices.Nullable(2)] TType>(JsonSchemaGeneratorSettings settings)
{
JsonSchemaGenerator jsonSchemaGenerator = new JsonSchemaGenerator(settings);
return jsonSchemaGenerator.Generate(typeof(TType));
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static JsonSchema FromType(Type type, JsonSchemaGeneratorSettings settings)
{
JsonSchemaGenerator jsonSchemaGenerator = new JsonSchemaGenerator(settings);
return jsonSchemaGenerator.Generate(type);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static JsonSchema FromSampleJson(string data)
{
SampleJsonSchemaGenerator sampleJsonSchemaGenerator = new SampleJsonSchemaGenerator();
return sampleJsonSchemaGenerator.Generate(data);
}
[System.Runtime.CompilerServices.NullableContext(1)]
internal static JsonSchema FromJsonWithCurrentSettings(object obj)
{
string value = JsonConvert.SerializeObject(obj, JsonSchemaSerialization.CurrentSerializerSettings);
return JsonConvert.DeserializeObject<JsonSchema>(value, JsonSchemaSerialization.CurrentSerializerSettings);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public bool Inherits(JsonSchema schema)
{
schema = schema.ActualSchema;
if (InheritedSchema?.ActualSchema != schema)
return InheritedSchema?.Inherits(schema) ?? false;
return true;
}
public virtual bool IsNullable(SchemaType schemaType)
{
if (IsNullableRaw.GetValueOrDefault())
return true;
if (IsEnumeration && Enumeration.Contains(null))
return true;
if (Type.IsNull())
return true;
if (((int)Type == 0 || Type.IsNull()) && _oneOf.Any((JsonSchema o) => o.IsNullable(schemaType)))
return true;
JsonSchema actualSchema = ActualSchema;
if (actualSchema != this && actualSchema.IsNullable(schemaType))
return true;
JsonSchema actualTypeSchema = ActualTypeSchema;
if (actualTypeSchema != this && actualTypeSchema.IsNullable(schemaType))
return true;
object value;
if (ExtensionData != null && ExtensionData.TryGetValue("nullable", out value) && bool.TryParse(value?.ToString(), out bool result))
return result;
return false;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public string ToJson()
{
return ToJson(Formatting.Indented);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public string ToJson(Formatting formatting)
{
string schemaVersion = SchemaVersion;
SchemaVersion = "http://json-schema.org/draft-04/schema#";
string result = JsonSchemaSerialization.ToJson(this, SchemaType.JsonSchema, ContractResolver.Value, formatting);
SchemaVersion = schemaVersion;
return result;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public JToken ToSampleJson()
{
SampleJsonDataGenerator sampleJsonDataGenerator = new SampleJsonDataGenerator();
return sampleJsonDataGenerator.Generate(this);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public bool InheritsSchema(JsonSchema parentSchema)
{
if (parentSchema != null)
return ActualSchema.AllInheritedSchemas.Concat(new List<JsonSchema> {
this
}).Any((JsonSchema s) => s.ActualSchema == parentSchema.ActualSchema);
return false;
}
[System.Runtime.CompilerServices.NullableContext(1)]
public ICollection<ValidationError> Validate(string jsonData, [System.Runtime.CompilerServices.Nullable(2)] JsonSchemaValidatorSettings settings = null)
{
JsonSchemaValidator jsonSchemaValidator = new JsonSchemaValidator(settings);
return jsonSchemaValidator.Validate(jsonData, ActualSchema, SchemaType.JsonSchema);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public ICollection<ValidationError> Validate(JToken token, [System.Runtime.CompilerServices.Nullable(2)] JsonSchemaValidatorSettings settings = null)
{
JsonSchemaValidator jsonSchemaValidator = new JsonSchemaValidator(settings);
return jsonSchemaValidator.Validate(token, ActualSchema, SchemaType.JsonSchema);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public ICollection<ValidationError> Validate(string jsonData, SchemaType schemaType, [System.Runtime.CompilerServices.Nullable(2)] JsonSchemaValidatorSettings settings = null)
{
JsonSchemaValidator jsonSchemaValidator = new JsonSchemaValidator(settings);
return jsonSchemaValidator.Validate(jsonData, ActualSchema, schemaType);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public ICollection<ValidationError> Validate(JToken token, SchemaType schemaType, [System.Runtime.CompilerServices.Nullable(2)] JsonSchemaValidatorSettings settings = null)
{
JsonSchemaValidator jsonSchemaValidator = new JsonSchemaValidator(settings);
return jsonSchemaValidator.Validate(token, ActualSchema, schemaType);
}
private static JsonObjectType ConvertStringToJsonObjectType(string value)
{
if (value != null) {
switch (value.Length) {
case 7:
switch (value[0]) {
case 'b':
if (value == "boolean")
return 2;
break;
case 'i':
if (value == "integer")
return 4;
break;
}
break;
case 6:
switch (value[0]) {
case 'n':
if (value == "number")
return 16;
break;
case 'o':
if (value == "object")
return 32;
break;
case 's':
if (value == "string")
return 64;
break;
}
break;
case 4:
switch (value[0]) {
case 'n':
if (value == "null")
return 8;
break;
case 'f':
if (value == "file")
return 128;
break;
}
break;
case 5:
if (value == "array")
return 1;
break;
}
}
return 0;
}
[System.Diagnostics.CodeAnalysis.MemberNotNull("Items")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("_items")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("Properties")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("_properties")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("PatternProperties")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("_patternProperties")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("Definitions")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("_definitions")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("RequiredProperties")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("AllOf")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("_allOf")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("AnyOf")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("_anyOf")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("OneOf")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("_oneOf")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("Enumeration")]
[System.Diagnostics.CodeAnalysis.MemberNotNull("EnumerationNames")]
private void Initialize()
{
if (Items == null)
Items = new ObservableCollection<JsonSchema>();
if (Properties == null)
Properties = new ObservableDictionary<string, JsonSchemaProperty>();
if (PatternProperties == null)
PatternProperties = new ObservableDictionary<string, JsonSchemaProperty>();
if (Definitions == null)
Definitions = new ObservableDictionary<string, JsonSchema>();
if (RequiredProperties == null)
RequiredProperties = new Collection<string>();
if (AllOf == null)
AllOf = new ObservableCollection<JsonSchema>();
if (AnyOf == null)
AnyOf = new ObservableCollection<JsonSchema>();
if (OneOf == null)
OneOf = new ObservableCollection<JsonSchema>();
if (Enumeration == null)
Enumeration = new Collection<object>();
if (EnumerationNames == null)
EnumerationNames = new Collection<string>();
}
[System.Runtime.CompilerServices.NullableContext(1)]
private static ObservableCollection<T> ToObservableCollection<[System.Runtime.CompilerServices.Nullable(2)] T>(ICollection<T> value)
{
return (value as ObservableCollection<T>) ?? new ObservableCollection<T>((IEnumerable<T>)value);
}
[System.Runtime.CompilerServices.NullableContext(1)]
private static ObservableDictionary<string, T> ToObservableDictionary<[System.Runtime.CompilerServices.Nullable(2)] T>(IDictionary<string, T> value)
{
return (value as ObservableDictionary<string, T>) ?? new ObservableDictionary<string, T>(value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[System.Runtime.CompilerServices.NullableContext(1)]
private JsonSchema GetActualSchema(List<JsonSchema> checkedSchemas)
{
if (checkedSchemas.Contains(this))
<GetActualSchema>g__ThrowInvalidOperationException|264_0("Cyclic references detected.");
if (Reference == null && ((IJsonReferenceBase)this).ReferencePath != null)
<GetActualSchema>g__ThrowInvalidOperationException|264_0("The schema reference path '" + ((IJsonReferenceBase)this).ReferencePath + "' has not been resolved.");
if (HasReference)
return GetActualSchemaReferences(checkedSchemas) ?? this;
return this;
}
[System.Runtime.CompilerServices.NullableContext(1)]
[return: System.Runtime.CompilerServices.Nullable(2)]
private JsonSchema GetActualSchemaReferences(List<JsonSchema> checkedSchemas)
{
if (checkedSchemas == null)
checkedSchemas = new List<JsonSchema>();
checkedSchemas.Add(this);
if (HasAllOfSchemaReference)
return _allOf[0].GetActualSchema(checkedSchemas);
if (HasOneOfSchemaReference)
return _oneOf[0].GetActualSchema(checkedSchemas);
if (HasAnyOfSchemaReference)
return _anyOf[0].GetActualSchema(checkedSchemas);
return Reference?.GetActualSchema(checkedSchemas);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static PropertyRenameAndIgnoreSerializerContractResolver CreateJsonSerializerContractResolver(SchemaType schemaType)
{
IgnoreEmptyCollectionsContractResolver ignoreEmptyCollectionsContractResolver = new IgnoreEmptyCollectionsContractResolver();
switch (schemaType) {
case SchemaType.OpenApi3:
ignoreEmptyCollectionsContractResolver.RenameProperty(typeof(JsonSchemaProperty), "x-readOnly", "readOnly");
ignoreEmptyCollectionsContractResolver.RenameProperty(typeof(JsonSchemaProperty), "x-writeOnly", "writeOnly");
ignoreEmptyCollectionsContractResolver.RenameProperty(typeof(JsonSchema), "x-nullable", "nullable");
ignoreEmptyCollectionsContractResolver.RenameProperty(typeof(JsonSchema), "x-example", "example");
ignoreEmptyCollectionsContractResolver.RenameProperty(typeof(JsonSchema), "x-deprecated", "deprecated");
break;
case SchemaType.Swagger2:
ignoreEmptyCollectionsContractResolver.RenameProperty(typeof(JsonSchemaProperty), "x-readOnly", "readOnly");
ignoreEmptyCollectionsContractResolver.RenameProperty(typeof(JsonSchema), "x-example", "example");
break;
default:
ignoreEmptyCollectionsContractResolver.RenameProperty(typeof(JsonSchemaProperty), "x-readOnly", "readonly");
break;
}
return ignoreEmptyCollectionsContractResolver;
}
[OnDeserialized]
internal void OnDeserialized(StreamingContext ctx)
{
Initialize();
}
[System.Diagnostics.CodeAnalysis.MemberNotNull("_typeRaw")]
private void ResetTypeRaw()
{
_typeRaw = new Lazy<object>(delegate {
JsonObjectType[] array = (from v in _jsonObjectTypeValues
where ((Enum)Type).HasFlag((Enum)(object)v)
select v).ToArray();
if (array.Length > 1)
return new JArray(from f in array
select new JValue(((object)f).ToString().ToLowerInvariant()));
if (array.Length == 1)
return new JValue(((object)array[0]).ToString().ToLowerInvariant());
return null;
});
}
private void RegisterProperties([System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})] ObservableDictionary<string, JsonSchemaProperty> oldCollection, [System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})] ObservableDictionary<string, JsonSchemaProperty> newCollection)
{
if (oldCollection != null)
oldCollection.CollectionChanged -= _initializeSchemaCollectionEventHandler;
if (newCollection != null) {
newCollection.CollectionChanged += _initializeSchemaCollectionEventHandler;
InitializeSchemaCollection(newCollection, null);
}
}
[System.Runtime.CompilerServices.NullableContext(0)]
private void RegisterSchemaDictionary<T>([System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})] ObservableDictionary<string, T> oldCollection, [System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1,
1
})] ObservableDictionary<string, T> newCollection) where T : JsonSchema
{
if (oldCollection != null)
oldCollection.CollectionChanged -= _initializeSchemaCollectionEventHandler;
if (newCollection != null) {
newCollection.CollectionChanged += _initializeSchemaCollectionEventHandler;
InitializeSchemaCollection(newCollection, null);
}
}
private void RegisterSchemaCollection([System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})] ObservableCollection<JsonSchema> oldCollection, [System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})] ObservableCollection<JsonSchema> newCollection)
{
if (oldCollection != null)
oldCollection.CollectionChanged -= _initializeSchemaCollectionEventHandler;
if (newCollection != null) {
newCollection.CollectionChanged += _initializeSchemaCollectionEventHandler;
InitializeSchemaCollection(newCollection, null);
}
}
private void InitializeSchemaCollection(object sender, NotifyCollectionChangedEventArgs args)
{
ObservableDictionary<string, JsonSchemaProperty> observableDictionary = sender as ObservableDictionary<string, JsonSchemaProperty>;
if (observableDictionary != null) {
foreach (KeyValuePair<string, JsonSchemaProperty> item in observableDictionary) {
item.Value.Name = item.Key;
item.Value.Parent = this;
}
} else {
ObservableCollection<JsonSchema> observableCollection = sender as ObservableCollection<JsonSchema>;
if (observableCollection != null) {
foreach (JsonSchema item2 in observableCollection) {
item2.Parent = this;
}
} else {
ObservableDictionary<string, JsonSchema> observableDictionary2 = sender as ObservableDictionary<string, JsonSchema>;
if (observableDictionary2 != null) {
KeyValuePair<string, JsonSchema>[] array = observableDictionary2.ToArray();
for (int i = 0; i < array.Length; i++) {
KeyValuePair<string, JsonSchema> keyValuePair = array[i];
if (keyValuePair.Value == null)
observableDictionary2.Remove(keyValuePair.Key);
else
keyValuePair.Value.Parent = this;
}
}
}
}
}
}
}