public TripField(string name, TripType type, long identifier, Required required)
 {
     Name = Enforce.IsNotNull<string>(name, "name");
     Type = Enforce.IsNotNull<TripType>(type, "type");
     Identifier = identifier;
     Required = required;
 }

            private JSchema CreateSchemaWithFormat(Type type, Required required, string format)
            {
                JSchemaGenerator generator = new JSchemaGenerator();
                JSchema schema = generator.Generate(type, required != Required.Always);
                schema.Format = format;

                return schema;
            }

 /// <summary>
 /// Initializes a new instance of the <see cref="JSchemaTypeGenerationContext"/> class.
 /// </summary>
 /// <param name="objectType">The object type.</param>
 /// <param name="required">The required state.</param>
 /// <param name="memberProperty">The member property.</param>
 /// <param name="parentContract">The parent contract.</param>
 /// <param name="generator">The current <see cref="JSchemaGenerator"/>.</param>
 public JSchemaTypeGenerationContext(Type objectType, Required required, JsonProperty memberProperty, JsonContainerContract parentContract, JSchemaGenerator generator)
 {
     _objectType = objectType;
     _required = required;
     _memberProperty = memberProperty;
     _parentContract = parentContract;
     _generator = generator;
 }

 public void Should_fix_all_args()
 {
     var pattern = new Required(new Argument("N"), new Argument("N"));
     Assert.AreEqual(pattern.Children[0], pattern.Children[1]);
     Assert.AreNotSame(pattern.Children[0], pattern.Children[1]);
     pattern.FixIdentities();
     Assert.AreSame(pattern.Children[0], pattern.Children[1]);
 }

        public void When_Required_And_StringValue_Is_Null()
        {
            var customer = new Customer();

            var validator = new Required<Customer, string>();
            var context = new RuleValidatorContext<Customer, string>(customer, "Name", customer.Name, null, null);

            //Validate the validator only, return true of no error returned
            var result = validator.Validate(context, null);

            Assert.IsNotEmpty(result.Message);
        }

        public void When_Required_And_CollectionValue_Is_Null()
        {
            var customer = new Customer();

            var validator = new Required<Customer, IEnumerable>();
            var context = new RuleValidatorContext<Customer, IEnumerable>(customer, "Contacts", customer.Contacts, null, null);

            //Validate the validator only, return true of no error returned
            var result = validator.Validate(context, null);

            Assert.IsNotEmpty(result.Message);
        }

        public void When_Required_And_CollectionValue_Is_Empty_IsInvalid()
        {
            var customer = new Customer() {Contacts = new List<Contact>()};

            var validator = new Required<Customer, IEnumerable>();
            var context = new RuleValidatorContext<Customer, IEnumerable>(customer, "Contacts", customer.Contacts, null, ValidationLevelType.Error, null);

            var notification = new ValidationNotification();

            //Validate the validator only, return true of no error returned
            validator.Validate(context, null, notification);

            Assert.IsNotEmpty(notification.Errors[0].Message);
        }

        public void When_Required_And_StringValue_Is_Null()
        {
            var customer = new Customer();

            var validator = new Required<Customer, string>();
            var context = new RuleValidatorContext<Customer, string>(customer, "Name", customer.Name, null, ValidationLevelType.Error, null);

            var notification = new ValidationNotification();

            //Validate the validator only, return true of no error returned
            validator.Validate(context, null, notification);

            Assert.IsNotEmpty(notification.Errors[0].Message);
        }

        public JSchema Generate(Type type, Required required)
        {
            JSchema schema = GenerateInternal(type, required, null, null);

            if (_generator.SchemaLocationHandling == SchemaLocationHandling.Definitions)
            {
                if (_typeSchemas.Count > 1)
                {
                    JToken definitions;
                    if (!schema.ExtensionData.TryGetValue("definitions", out definitions))
                    {
                        definitions = new JObject();
                        schema.ExtensionData["definitions"] = definitions;
                    }

                    foreach (TypeSchema t in _typeSchemas)
                    {
                        if (t.Schema == schema)
                        {
                            continue;
                        }

                        string id;
                        if (t.Schema.Id != null)
                        {
                            id = t.Schema.Id.OriginalString;
                        }
                        else
                        {
                            id = t.Key.Type.Name;
                            int i = 1;
                            while (definitions[id] != null)
                            {
                                id = t.Key.Type.Name + "-" + i;
                                i++;
                            }
                        }

                        definitions[id] = t.Schema;
                    }
                }
            }

            return schema;
        }

        private JSchemaType AddNullType(JSchemaType type, Required valueRequired)
        {
            if (valueRequired == Required.Default || valueRequired == Required.AllowNull)
            {
                return type | JSchemaType.Null;
            }

            return type;
        }

        private static TypeSchemaKey CreateKey(Required valueRequired, JsonProperty memberProperty, JsonContract contract)
        {
            int? minLength = DataAnnotationHelpers.GetMinLength(memberProperty);
            int? maxLength = DataAnnotationHelpers.GetMaxLength(memberProperty);

            Required resolvedRequired;
            switch (valueRequired)
            {
                case Required.Default:
                case Required.AllowNull:
                    resolvedRequired = Required.AllowNull;
                    break;
                case Required.Always:
                case Required.DisallowNull:
                    resolvedRequired = Required.DisallowNull;
                    break;
                default:
                    throw new ArgumentOutOfRangeException("valueRequired");
            }

            TypeSchemaKey key = new TypeSchemaKey(contract.UnderlyingType, resolvedRequired, minLength, maxLength);

            return key;
        }

 // Token: 0x06000B87 RID: 2951
 // RVA: 0x00042BE0 File Offset: 0x00040DE0
 private JsonSchema GenerateInternal(Type type, Required valueRequired, bool required)
 {
     ValidationUtils.ArgumentNotNull(type, "type");
     string typeId = this.GetTypeId(type, false);
     string typeId2 = this.GetTypeId(type, true);
     if (!string.IsNullOrEmpty(typeId))
     {
         JsonSchema schema = this._resolver.GetSchema(typeId);
         if (schema != null)
         {
             if (valueRequired != Required.Always && !JsonSchemaGenerator.HasFlag(schema.Type, JsonSchemaType.Null))
             {
                 schema.Type |= JsonSchemaType.Null;
             }
             if (required && schema.Required != true)
             {
                 schema.Required = new bool?(true);
             }
             return schema;
         }
     }
     if (Enumerable.Any<JsonSchemaGenerator.TypeSchema>(this._stack, (JsonSchemaGenerator.TypeSchema tc) => tc.Type == type))
     {
         throw new JsonException(StringUtils.FormatWith("Unresolved circular reference for type '{0}'. Explicitly define an Id for the type using a JsonObject/JsonArray attribute or automatically generate a type Id using the UndefinedSchemaIdHandling property.", CultureInfo.InvariantCulture, type));
     }
     JsonContract jsonContract = this.ContractResolver.ResolveContract(type);
     JsonConverter jsonConverter;
     if ((jsonConverter = jsonContract.Converter) != null || (jsonConverter = jsonContract.InternalConverter) != null)
     {
         JsonSchema schema2 = jsonConverter.GetSchema();
         if (schema2 != null)
         {
             return schema2;
         }
     }
     this.Push(new JsonSchemaGenerator.TypeSchema(type, new JsonSchema()));
     if (typeId2 != null)
     {
         this.CurrentSchema.Id = typeId2;
     }
     if (required)
     {
         this.CurrentSchema.Required = new bool?(true);
     }
     this.CurrentSchema.Title = this.GetTitle(type);
     this.CurrentSchema.Description = this.GetDescription(type);
     if (jsonConverter == null)
     {
         switch (jsonContract.ContractType)
         {
         case JsonContractType.Object:
             this.CurrentSchema.Type = new JsonSchemaType?(this.AddNullType(JsonSchemaType.Object, valueRequired));
             this.CurrentSchema.Id = this.GetTypeId(type, false);
             this.GenerateObjectSchema(type, (JsonObjectContract)jsonContract);
             goto IL_4C4;
         case JsonContractType.Array:
         {
             this.CurrentSchema.Type = new JsonSchemaType?(this.AddNullType(JsonSchemaType.Array, valueRequired));
             this.CurrentSchema.Id = this.GetTypeId(type, false);
             JsonArrayAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute<JsonArrayAttribute>(type);
             bool flag = cachedAttribute == null || cachedAttribute.AllowNullItems;
             Type collectionItemType = ReflectionUtils.GetCollectionItemType(type);
             if (collectionItemType != null)
             {
                 this.CurrentSchema.Items = new List<JsonSchema>();
                 this.CurrentSchema.Items.Add(this.GenerateInternal(collectionItemType, (!flag) ? Required.Always : Required.Default, false));
                 goto IL_4C4;
             }
             goto IL_4C4;
         }
         case JsonContractType.Primitive:
         {
             this.CurrentSchema.Type = new JsonSchemaType?(this.GetJsonSchemaType(type, valueRequired));
             if (!(this.CurrentSchema.Type == JsonSchemaType.Integer) || !TypeExtensions.IsEnum(type) || type.IsDefined(typeof(FlagsAttribute), true))
             {
                 goto IL_4C4;
             }
             this.CurrentSchema.Enum = new List<JToken>();
             IList<EnumValue<long>> namesAndValues = EnumUtils.GetNamesAndValues<long>(type);
             using (IEnumerator<EnumValue<long>> enumerator = namesAndValues.GetEnumerator())
             {
                 while (enumerator.MoveNext())
                 {
                     EnumValue<long> current = enumerator.Current;
                     JToken item = JToken.FromObject(current.Value);
                     this.CurrentSchema.Enum.Add(item);
                 }
                 goto IL_4C4;
             }
             break;
         }
         case JsonContractType.String:
             break;
         case JsonContractType.Dictionary:
         {
             this.CurrentSchema.Type = new JsonSchemaType?(this.AddNullType(JsonSchemaType.Object, valueRequired));
             Type type2;
             Type type3;
//.........这里部分代码省略.........

    private JsonSchemaType GetJsonSchemaType(Type type, Required valueRequired)
    {
      JsonSchemaType schemaType = JsonSchemaType.None;
      if (valueRequired != Required.Always && ReflectionUtils.IsNullable(type))
      {
        schemaType = JsonSchemaType.Null;
        if (ReflectionUtils.IsNullableType(type))
          type = Nullable.GetUnderlyingType(type);
      }

      TypeCode typeCode = Type.GetTypeCode(type);

      switch (typeCode)
      {
        case TypeCode.Empty:
        case TypeCode.Object:
          return schemaType | JsonSchemaType.String;
        case TypeCode.DBNull:
          return schemaType | JsonSchemaType.Null;
        case TypeCode.Boolean:
          return schemaType | JsonSchemaType.Boolean;
        case TypeCode.Char:
          return schemaType | JsonSchemaType.String;
        case TypeCode.SByte:
        case TypeCode.Byte:
        case TypeCode.Int16:
        case TypeCode.UInt16:
        case TypeCode.Int32:
        case TypeCode.UInt32:
        case TypeCode.Int64:
        case TypeCode.UInt64:
          return schemaType | JsonSchemaType.Integer;
        case TypeCode.Single:
        case TypeCode.Double:
        case TypeCode.Decimal:
          return schemaType | JsonSchemaType.Float;
        // convert to string?
        case TypeCode.DateTime:
          return schemaType | JsonSchemaType.String;
        case TypeCode.String:
          return schemaType | JsonSchemaType.String;
        default:
          throw new Exception("Unexpected type code '{0}' for type '{1}'.".FormatWith(CultureInfo.InvariantCulture, typeCode, type));
      }
    }

        private JsonSchemaType GetJsonSchemaType(Type type, Required valueRequired)
        {
            JsonSchemaType schemaType = JsonSchemaType.None;
            if (valueRequired != Required.Always && ReflectionUtils.IsNullable(type))
            {
                schemaType = JsonSchemaType.Null;
                if (ReflectionUtils.IsNullableType(type))
                    type = Nullable.GetUnderlyingType(type);
            }

            PrimitiveTypeCode typeCode = ConvertUtils.GetTypeCode(type);

            switch (typeCode)
            {
                case PrimitiveTypeCode.Empty:
                case PrimitiveTypeCode.Object:
                    return schemaType | JsonSchemaType.String;
#if !(NETFX_CORE || PORTABLE)
                case PrimitiveTypeCode.DBNull:
                    return schemaType | JsonSchemaType.Null;
#endif
                case PrimitiveTypeCode.Boolean:
                    return schemaType | JsonSchemaType.Boolean;
                case PrimitiveTypeCode.Char:
                    return schemaType | JsonSchemaType.String;
                case PrimitiveTypeCode.SByte:
                case PrimitiveTypeCode.Byte:
                case PrimitiveTypeCode.Int16:
                case PrimitiveTypeCode.UInt16:
                case PrimitiveTypeCode.Int32:
                case PrimitiveTypeCode.UInt32:
                case PrimitiveTypeCode.Int64:
                case PrimitiveTypeCode.UInt64:
#if !(PORTABLE || NET35 || NET20)
                case PrimitiveTypeCode.BigInteger:
#endif
                    return schemaType | JsonSchemaType.Integer;
                case PrimitiveTypeCode.Single:
                case PrimitiveTypeCode.Double:
                case PrimitiveTypeCode.Decimal:
                    return schemaType | JsonSchemaType.Float;
                    // convert to string?
                case PrimitiveTypeCode.DateTime:
#if !NET20
                case PrimitiveTypeCode.DateTimeOffset:
#endif
                    return schemaType | JsonSchemaType.String;
                case PrimitiveTypeCode.String:
                case PrimitiveTypeCode.Uri:
                case PrimitiveTypeCode.Guid:
                case PrimitiveTypeCode.TimeSpan:
                case PrimitiveTypeCode.Bytes:
                    return schemaType | JsonSchemaType.String;
                default:
                    throw new JsonException("Unexpected type code '{0}' for type '{1}'.".FormatWith(CultureInfo.InvariantCulture, typeCode, type));
            }
        }

 public ConsoleHelpAttribute(string helpText,Required requiredType = Required.NotReuired)
 {
     HelpText = helpText;
     RequiredType = requiredType;
 }

 public void Insert(Required required)
 {
     DbContext.Requireds.Add(required);
     Update();
 }

        private JsonSchemaType AddNullType(JsonSchemaType type, Required valueRequired)
        {
            if (valueRequired != Required.Always)
            {
                return type | JsonSchemaType.Null;
            }

            return type;
        }

        private JsonSchema GenerateInternal(Type type, Required valueRequired)
        {
            ValidationUtils.ArgumentNotNull(type, "type");

              string resolvedId = GetTypeId(type, false);
              string explicitId = GetTypeId(type, true);

              if (!string.IsNullOrEmpty(resolvedId))
              {
            JsonSchema resolvedSchema = _resolver.GetSchema(resolvedId);
            if (resolvedSchema != null)
              return resolvedSchema;
              }

              // test for unresolved circular reference
              if (_stack.Any(tc => tc.Type == type))
              {
            throw new Exception("Unresolved circular reference for type '{0}'. Explicitly define an Id for the type using a JsonObject/JsonArray attribute or automatically generate a type Id using the UndefinedSchemaIdHandling property.".FormatWith(CultureInfo.InvariantCulture, type));
              }

              Push(new TypeSchema(type, new JsonSchema()));

              if (explicitId != null)
            CurrentSchema.Id = explicitId;

              CurrentSchema.Title = GetTitle(type);
              CurrentSchema.Description = GetDescription(type);

              if (CollectionUtils.IsDictionaryType(type))
              {
            // TODO: include null
            CurrentSchema.Type = JsonSchemaType.Object;

            Type keyType;
            Type valueType;
            ReflectionUtils.GetDictionaryKeyValueTypes(type, out keyType, out valueType);

            if (keyType != null)
            {
              // can be converted to a string
              if (typeof (IConvertible).IsAssignableFrom(keyType))
              {
            CurrentSchema.AdditionalProperties = GenerateInternal(valueType, Required.Default);
              }
            }
              }
              else if (CollectionUtils.IsCollectionType(type))
              {
            // TODO: include null
            CurrentSchema.Type = JsonSchemaType.Array;

            CurrentSchema.Id = GetTypeId(type, false);

            JsonArrayAttribute arrayAttribute = JsonTypeReflector.GetJsonContainerAttribute(type) as JsonArrayAttribute;
            bool allowNullItem = (arrayAttribute != null) ? arrayAttribute.AllowNullItems : false;

            Type collectionItemType = ReflectionUtils.GetCollectionItemType(type);
            if (collectionItemType != null)
            {
              CurrentSchema.Items = new List<JsonSchema>();
              CurrentSchema.Items.Add(GenerateInternal(collectionItemType, (!allowNullItem) ? Required.Always : Required.Default));
            }
              }
              else
              {
            CurrentSchema.Type = GetJsonSchemaType(type, valueRequired);

            if (HasFlag(CurrentSchema.Type, JsonSchemaType.Object))
            {
              CurrentSchema.Id = GetTypeId(type, false);

              JsonObjectContract contract = ContractResolver.ResolveContract(type) as JsonObjectContract;

              if (contract == null)
            throw new Exception("Could not resolve contract for '{0}'.".FormatWith(CultureInfo.InvariantCulture, type));

              CurrentSchema.Properties = new Dictionary<string, JsonSchema>();
              foreach (JsonProperty property in contract.Properties)
              {
            if (!property.Ignored)
            {
              JsonSchema propertySchema = GenerateInternal(property.PropertyType, property.Required);

              if (property.DefaultValue != null)
                propertySchema.Default = JToken.FromObject(property.DefaultValue);

              CurrentSchema.Properties.Add(property.PropertyName, propertySchema);
            }
              }

              if (type.IsSealed)
            CurrentSchema.AllowAdditionalProperties = false;
            }
            else if (CurrentSchema.Type == JsonSchemaType.Integer && type.IsEnum && !type.IsDefined(typeof(FlagsAttribute), true))
            {
              CurrentSchema.Enum = new List<JToken>();
              CurrentSchema.Options = new Dictionary<JToken, string>();

              EnumValues<long> enumValues = EnumUtils.GetNamesAndValues<long>(type);
              foreach (EnumValue<long> enumValue in enumValues)
//.........这里部分代码省略.........

        private static TypeSchemaKey CreateKey(Required valueRequired, JsonProperty memberProperty, JsonContract contract)
        {
            int? minLength = DataAnnotationHelpers.GetMinLength(memberProperty);
            int? maxLength = DataAnnotationHelpers.GetMaxLength(memberProperty);

            TypeSchemaKey key = new TypeSchemaKey(contract.UnderlyingType, valueRequired, minLength, maxLength);
            return key;
        }

    private JsonSchema GenerateInternal(Type type, Required valueRequired, bool required)
    {
      ValidationUtils.ArgumentNotNull(type, "type");

      string resolvedId = GetTypeId(type, false);
      string explicitId = GetTypeId(type, true);

      if (!string.IsNullOrEmpty(resolvedId))
      {
        JsonSchema resolvedSchema = _resolver.GetSchema(resolvedId);
        if (resolvedSchema != null)
        {
          // resolved schema is not null but referencing member allows nulls
          // change resolved schema to allow nulls. hacky but what are ya gonna do?
          if (valueRequired != Required.Always && !HasFlag(resolvedSchema.Type, JsonSchemaType.Null))
            resolvedSchema.Type |= JsonSchemaType.Null;
          if (required && resolvedSchema.Required != true)
            resolvedSchema.Required = true;

          return resolvedSchema;
        }
      }

      // test for unresolved circular reference
      if (_stack.Any(tc => tc.Type == type))
      {
        throw new Exception("Unresolved circular reference for type '{0}'. Explicitly define an Id for the type using a JsonObject/JsonArray attribute or automatically generate a type Id using the UndefinedSchemaIdHandling property.".FormatWith(CultureInfo.InvariantCulture, type));
      }

      JsonContract contract = ContractResolver.ResolveContract(type);
      JsonConverter converter;
      if ((converter = contract.Converter) != null || (converter = contract.InternalConverter) != null)
      {
        JsonSchema converterSchema = converter.GetSchema();
        if (converterSchema != null)
          return converterSchema;
      }

      Push(new TypeSchema(type, new JsonSchema()));

      if (explicitId != null)
        CurrentSchema.Id = explicitId;

      if (required)
        CurrentSchema.Required = true;
      CurrentSchema.Title = GetTitle(type);
      CurrentSchema.Description = GetDescription(type);

      if (converter != null)
      {
        // todo: Add GetSchema to JsonConverter and use here?
        CurrentSchema.Type = JsonSchemaType.Any;
      }
      else
      {
        switch (contract.ContractType)
        {
          case JsonContractType.Object:
            CurrentSchema.Type = AddNullType(JsonSchemaType.Object, valueRequired);
            CurrentSchema.Id = GetTypeId(type, false);
            GenerateObjectSchema(type, (JsonObjectContract) contract);
            break;
          case JsonContractType.Array:
            CurrentSchema.Type = AddNullType(JsonSchemaType.Array, valueRequired);

            CurrentSchema.Id = GetTypeId(type, false);

            JsonArrayAttribute arrayAttribute = JsonTypeReflector.GetJsonContainerAttribute(type) as JsonArrayAttribute;
            bool allowNullItem = (arrayAttribute == null || arrayAttribute.AllowNullItems);

            Type collectionItemType = ReflectionUtils.GetCollectionItemType(type);
            if (collectionItemType != null)
            {
              CurrentSchema.Items = new List<JsonSchema>();
              CurrentSchema.Items.Add(GenerateInternal(collectionItemType, (!allowNullItem) ? Required.Always : Required.Default, false));
            }
            break;
          case JsonContractType.Primitive:
            CurrentSchema.Type = GetJsonSchemaType(type, valueRequired);

            if (CurrentSchema.Type == JsonSchemaType.Integer && type.IsEnum && !type.IsDefined(typeof (FlagsAttribute), true))
            {
              CurrentSchema.Enum = new List<JToken>();
              CurrentSchema.Options = new Dictionary<JToken, string>();

              EnumValues<long> enumValues = EnumUtils.GetNamesAndValues<long>(type);
              foreach (EnumValue<long> enumValue in enumValues)
              {
                JToken value = JToken.FromObject(enumValue.Value);

                CurrentSchema.Enum.Add(value);
                CurrentSchema.Options.Add(value, enumValue.Name);
              }
            }
            break;
          case JsonContractType.String:
            JsonSchemaType schemaType = (!ReflectionUtils.IsNullable(contract.UnderlyingType))
                                          ? JsonSchemaType.String
                                          : AddNullType(JsonSchemaType.String, valueRequired);

//.........这里部分代码省略.........