Swift - Nested Enums default values

Question

I have an enum as follows

enum AccountForm: String {

    case Profile

    enum Content: String {
        case Feedback
        case Likes
    }

    enum Actions: String {
        case Redeem
        case Help
    }
}

This represents a form, where profile content and actions are sections and the cases are rows.

These resolve to strings and work as expected

AccountForm.Profile.rawValue returns "Profile"

AccountForm.Content.Feedback.rawValue returns "Feedback"

However, I'd like AccountForm.Content.rawValue to return "Content"

Is this possible? Or is there a better way besides enums to achieve this?

Answer 1

I'm guessing you've got an answer to this by now but just in case you didn't try this:

enum AccountForm : String {
    case profile

    enum Content: String {
        static let rawValue = "Content"

        case feedback = "Feedback"
        case likes = "Likes"
    }

    enum Actions : String {
        static let rawValue = "Actions"

        case redeem = "Redeem"
        case help = "Help"
    }
}

Static properties on both the Content and Actions enumerations should achieve what you want. A word of warning though. By calling the properties rawValue you're obviously implying the returned values are raw values when technically they aren't. If you can I'd think of a better name (maybe sectionTitle ?).

Couple of other things to note.

First, you have to define the properties as static as it sounds like you want to call them on the enumeration type (eg AccountForm.Content.rawValue ) rather than on an individual enumeration case (eg AccountForm.Content.feedback.rawValue ). I'll leave you to decide whether that makes sense in your context.

Secondly, when Swift 3.0 arrives, the recommendation for enumeration cases is going to be that case labels follow a lowerCamelCase naming convention rather than the UpperCamelCase convention that was recommended in Swift 2.2.

I've followed the Swift 3.0 recommendation here but the result is that explicit raw-value assignments is needed as you won't be able to rely on using the implicit raw-value assignment mechanism assigning a string with an UpperCamelCase representation which is kind of annoying but those are the implications.

Anyway, hope it helps.

Answer 2

enum Typo {
    case Bold
    case Normal
    case Italic
    case All
}
enum Format: CustomStringConvertible {
    case Header(Typo)
    case Text(Typo)
    var description:String {
        switch self {
        case .Header(let value) where value != .All:
            return "Header.\(value)"
        case .Header(let value) where value == .All:
            return "Header"
        case .Text(let value) where value == .All:
            return "Text"
        case .Text(let value) where value != .All:
            return "Text.\(value)"
        default:
            return ""
        }
    }
}

let a:Format = .Header(.Bold)
let b:Format = .Text(.Italic)

Format.Header(.All)   // Header
Format.Text(.Bold)    // Text.Bold
Format.Text(.All)     // Text