1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftNIO open source project
//
// Copyright (c) 2017-2020 Apple Inc. and the SwiftNIO project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
#if os(Windows)
import typealias WinSDK.DWORD
#endif
/// An `Error` for an IO operation.
public struct IOError: Swift.Error {
@available(*, deprecated, message: "NIO no longer uses FailureDescription.")
public enum FailureDescription {
case function(StaticString)
case reason(String)
}
/// The actual reason (in an human-readable form) for this `IOError`.
private var failureDescription: String
@available(*, deprecated, message: "NIO no longer uses FailureDescription, use IOError.description for a human-readable error description")
public var reason: FailureDescription {
return .reason(self.failureDescription)
}
private enum Error {
#if os(Windows)
case windows(DWORD)
case winsock(CInt)
#endif
case errno(CInt)
}
private let error: Error
/// The `errno` that was set for the operation.
public var errnoCode: CInt {
switch self.error {
case .errno(let code):
return code
#if os(Windows)
default:
fatalError("IOError domain is not `errno`")
#endif
}
}
#if os(Windows)
public init(windows code: DWORD, reason: String) {
self.error = .windows(code)
self.failureDescription = reason
}
public init(winsock code: CInt, reason: String) {
self.error = .winsock(code)
self.failureDescription = reason
}
#endif
/// Creates a new `IOError``
///
/// - parameters:
/// - errorCode: the `errno` that was set for the operation.
/// - reason: the actual reason (in an human-readable form).
public init(errnoCode code: CInt, reason: String) {
self.error = .errno(code)
self.failureDescription = reason
}
/// Creates a new `IOError``
///
/// - parameters:
/// - errorCode: the `errno` that was set for the operation.
/// - function: The function the error happened in, the human readable description will be generated automatically when needed.
@available(*, deprecated, renamed: "init(errnoCode:reason:)")
public init(errnoCode code: CInt, function: StaticString) {
self.error = .errno(code)
self.failureDescription = "\(function)"
}
}
/// Returns a reason to use when constructing a `IOError`.
///
/// - parameters:
/// - errorCode: the `errno` that was set for the operation.
/// - reason: what failed
/// - returns: the constructed reason.
private func reasonForError(errnoCode: CInt, reason: String) -> String {
if let errorDescC = strerror(errnoCode) {
return "\(reason): \(String(cString: errorDescC)) (errno: \(errnoCode))"
} else {
return "\(reason): Broken strerror, unknown error: \(errnoCode)"
}
}
internal extension IOResult where T: FixedWidthInteger {
var result: T {
switch self {
case .processed(let value):
return value
case .wouldBlock(_):
fatalError("cannot unwrap IOResult")
}
}
}
extension IOError: CustomStringConvertible {
public var description: String {
return self.localizedDescription
}
public var localizedDescription: String {
return reasonForError(errnoCode: self.errnoCode, reason: self.failureDescription)
}
}
/// An result for an IO operation that was done on a non-blocking resource.
enum IOResult<T: Equatable>: Equatable {
/// Signals that the IO operation could not be completed as otherwise we would need to block.
case wouldBlock(T)
/// Signals that the IO operation was completed.
case processed(T)
}
|
