[swift-users] Proper Way to make Errors in Swift 3

[Ronak]

Hi,

I’ve actually switched our implementation to:

/// The type of an error code.
@objc public enum FoundationErrorCode: Int {

    /// An ARCOperationCondition failed during evaluation
    case operationConditionFailed = 10000

    /// An ARCOperation failed during execution
    case operationExecutionFailed = 10001

    /// An unsupported HTTP Method was encountered
    case unsupportedHTTPMethod = 10002
}

/// The enumeration of the possible error codes in the Foundation error domain
@objc public class FoundationError: NSObject, CustomNSError {

    /// The underlying error code
    private let code: FoundationErrorCode

    /// The domain of the error.
    public static var errorDomain: String {
        return "FoundationError"
    }

    /// The error code within the given domain.
    public var errorCode: Int {
        return code.rawValue
    }

    /// The user-info dictionary.
    public let errorUserInfo: [String : Any]

    /// Initializes a new FoundationError with an empty userInfo dictionary
    ///
    /// - parameter code: one of the available error codes
    ///
    /// - returns: a new instance of FoundationError
    public convenience init(code: FoundationErrorCode) {
        self.init(code: code, userInfo: [:])
    }

    /// Initializes a new FoundationError with an userInfo dictionary
    ///
    /// - parameter code: one of the available error codes
    /// - parameter userInfo: the user-info dictionary
    ///
    /// - returns: a new instance of FoundationError
    public init(code: FoundationErrorCode, userInfo: [String : Any]) {
        self.code = code
        errorUserInfo = userInfo
    }

    /// Computes whether two FoundationErrors are equal
    ///
    /// - parameter object: a FoundationError
    ///
    /// - returns: true, if the two errors are equal
    public override func isEqual(_ object: Any?) -> Bool {
        guard let object = object as? FoundationError else { return false }

        return errorCode == object.errorCode && errorUserInfo.keys.elementsEqual(object.errorUserInfo.keys)
    }
}

I hope this is closer to the correct way to implement this.

Thanks!

Ronak


> On Sep 29, 2016, at 1:17 PM, Ronak via swift-users <swift-users at swift.org> wrote:
> 
> Hello all,
> 
> We are proceeding to update all of our Swift code to Swift 3 now and had a few questions about the proper way to implement Errors. We need these entities to be available in Objective-C and they are actively being used in Swift classes marked as @objc.
> 
> I read: https://github.com/apple/swift-evolution/blob/master/proposals/0112-nserror-bridging.md <https://github.com/apple/swift-evolution/blob/master/proposals/0112-nserror-bridging.md> completely and came up with this implementation:
> 
> 
> /// The enumeration of the possible error codes in the Foundation error domain
> @objc public class FoundationError: NSObject, CustomNSError {
> 
>     /// The underlying error code
>     private let code: FoundationError.Code
> 
>     /// The type of an error code.
>     @objc public enum Code: Int {
> 
>         /// An ARCOperationCondition failed during evaluation
>         case operationConditionFailed = 10000
> 
>         /// An ARCOperation failed during execution
>         case operationExecutionFailed = 10001
>     }
> 
>     /// The domain of the error.
>     public static var errorDomain: String {
>         return "FoundationError"
>     }
> 
>     /// The error code within the given domain.
>     public var errorCode: Int {
>         return code.rawValue
>     }
> 
>     /// The user-info dictionary.
>     public let errorUserInfo: [String : Any]
> 
>     /// Initializes a new FoundationError with an empty userInfo dictionary
>     ///
>     /// - parameter code: one of the available error codes
>     ///
>     /// - returns: a new instance of FoundationError
>     public convenience init(code: FoundationError.Code) {
>         self.init(code: code, userInfo: [:])
>     }
> 
>     /// Initializes a new FoundationError with an userInfo dictionary
>     ///
>     /// - parameter code: one of the available error codes
>     /// - parameter userInfo: the user-info dictionary
>     ///
>     /// - returns: a new instance of FoundationError
>     public init(code: FoundationError.Code, userInfo: [String : Any]) {
>         self.code = code
>         errorUserInfo = userInfo
>     }
> 
>     /// Computes whether two FoundationErrors are equal
>     ///
>     /// - parameter object: a FoundationError
>     ///
>     /// - returns: true, if the two errors are equal
>     public override func isEqual(_ object: Any?) -> Bool {
>         guard let object = object as? FoundationError else { return false }
> 
>         return errorCode == object.errorCode && errorUserInfo.keys.elementsEqual(object.errorUserInfo.keys)
>     }
> }
> 
> My question is whether this is the correct way to do this now; or is there another solution we should be doing? We would like to follow Swift Best Practices here, but unfortunately, the documentation is quite vague on this subject.
> 
> 
> Thanks for your help!
> 
> Ronak Patel
> _______________________________________________
> swift-users mailing list
> swift-users at swift.org
> https://lists.swift.org/mailman/listinfo/swift-users

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-users/attachments/20160929/d49e015a/attachment.html>