loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

[swift6] Add typed throws to Validation functions (#20903)

Browse Source
This commit is contained in:
Lennard Sprong 2025-03-17 16:11:25 +01:00 committed by GitHub
parent 02307dbf0c
commit 1eb8c58446
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 105 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
modules/openapi-generator/src/main/resources/swift6/Validation.mustache vendored
View File

@ -48,9 +48,8 @@ extension NumericRule: Sendable where T: Sendable {}
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ extension NumericRule: Sendable where T: Sendable {}
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ extension NumericRule: Sendable where T: Sendable {}
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ extension NumericRule: Sendable where T: Sendable {}
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ extension NumericRule: Sendable where T: Sendable {}
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/alamofireLibrary/Sources/PetstoreClient/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/apiNonStaticMethod/Sources/PetstoreClient/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/asyncAwaitLibrary/Sources/PetstoreClient/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/combineDeferredLibrary/PetstoreClient/Classes/OpenAPIs/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/combineLibrary/Sources/CombineLibrary/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/default/Sources/PetstoreClient/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/objcCompatible/Sources/PetstoreClient/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/oneOf/PetstoreClient/Classes/OpenAPIs/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/promisekitLibrary/PetstoreClient/Classes/OpenAPIs/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/resultLibrary/PetstoreClient/Classes/OpenAPIs/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ internal struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. internal static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
internal static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ internal struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ internal struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
internal static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { internal static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ internal struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
internal static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { internal static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ internal struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
internal static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { internal static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/rxswiftLibrary/PetstoreClient/Classes/OpenAPIs/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/urlsessionLibrary/Sources/PetstoreClient/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/validation/PetstoreClient/Classes/OpenAPIs/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)

15
samples/client/petstore/swift6/vaporLibrary/Sources/PetstoreClient/Infrastructure/Validation.swift
View File

@ -48,9 +48,8 @@ public struct Validator {
/// - Parameter string: The String you wish to validate. /// - Parameter string: The String you wish to validate.
/// - Parameter rule: The StringRule you wish to use for validation. /// - Parameter rule: The StringRule you wish to use for validation.
/// - Returns: A validated string. /// - Returns: A validated string.
/// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule, /// - Throws: `ValidationError<StringValidationErrorKind>` if the string is invalid against the rule or if the rule.pattern is invalid.
/// `NSError` if the rule.pattern is invalid. public static func validate(_ string: String, against rule: StringRule) throws(ValidationError<StringValidationErrorKind>) -> String {
public static func validate(_ string: String, against rule: StringRule) throws -> String {
var error = ValidationError<StringValidationErrorKind>(kinds: []) var error = ValidationError<StringValidationErrorKind>(kinds: [])
if let minLength = rule.minLength, !(minLength <= string.count) { if let minLength = rule.minLength, !(minLength <= string.count) {
error.kinds.insert(.minLength) error.kinds.insert(.minLength)
@ -59,9 +58,9 @@ public struct Validator {
error.kinds.insert(.maxLength) error.kinds.insert(.maxLength)
} }
if let pattern = rule.pattern { if let pattern = rule.pattern {
let matches = try NSRegularExpression(pattern: pattern, options: .caseInsensitive) let matches = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive)
.matches(in: string, range: .init(location: 0, length: string.utf16.count)) .matches(in: string, range: .init(location: 0, length: string.utf16.count))
if matches.isEmpty { if matches?.isEmpty != false {
error.kinds.insert(.pattern) error.kinds.insert(.pattern)
} }
} }
@ -76,7 +75,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated integer. /// - Returns: A validated integer.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & BinaryInteger>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -108,7 +107,7 @@ public struct Validator {
/// - Parameter rule: The NumericRule you wish to use for validation. /// - Parameter rule: The NumericRule you wish to use for validation.
/// - Returns: A validated fractional number. /// - Returns: A validated fractional number.
/// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule. /// - Throws: `ValidationError<NumericValidationErrorKind>` if the numeric is invalid against the rule.
public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws -> T { public static func validate<T: Comparable & FloatingPoint>(_ numeric: T, against rule: NumericRule<T>) throws(ValidationError<NumericValidationErrorKind>) -> T {
var error = ValidationError<NumericValidationErrorKind>(kinds: []) var error = ValidationError<NumericValidationErrorKind>(kinds: [])
if let minimum = rule.minimum { if let minimum = rule.minimum {
if !rule.exclusiveMinimum, minimum > numeric { if !rule.exclusiveMinimum, minimum > numeric {
@ -140,7 +139,7 @@ public struct Validator {
/// - Parameter rule: The ArrayRule you wish to use for validation. /// - Parameter rule: The ArrayRule you wish to use for validation.
/// - Returns: A validated array. /// - Returns: A validated array.
/// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule. /// - Throws: `ValidationError<ArrayValidationErrorKind>` if the string is invalid against the rule.
public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws -> Array<AnyHashable> { public static func validate(_ array: Array<AnyHashable>, against rule: ArrayRule) throws(ValidationError<ArrayValidationErrorKind>) -> Array<AnyHashable> {
var error = ValidationError<ArrayValidationErrorKind>(kinds: []) var error = ValidationError<ArrayValidationErrorKind>(kinds: [])
if let minItems = rule.minItems, !(minItems <= array.count) { if let minItems = rule.minItems, !(minItems <= array.count) {
error.kinds.insert(.minItems) error.kinds.insert(.minItems)