Storing Enum type in Swift

Question

I am working on Enum serialization for my library (https://github.com/JiriTrecak/Warp) and I got little stuck on storing the enum type in the property (I need to know that type so I can serialize / deserialize it on demand).

I have a struct that contains description of all the properties that you can have, including their type, remote keys etc., and I'd like to store one more optional information if that is enum, which is the Enum type to be created when the key is found (say, Gender).

I've tried two approaches, both of which are not usable:

A) Declare the generic type in the container definition

public struct WRPProperty<T: RawRepresentable> {
    var enumType : T?

    public init(remote : String, enumType: T) {
        self.enumType = enumType
    }
}

This works, the problem with this approach is that I don't want every WRPProperty to have enum. By declaring it like this, it forces user to always add data type when creating the property, which is unwanted behavior. I can also create object that would be WRPEnumProperty, but that is not usable due to how the library handles those definitions and how user defines them.

B) Declare the generic type in the init method

public struct WRPProperty {
    var enumType : RawRepresentable

    public init<T: RawRepresentable>(remote : String, enumType: T) {
        self.enumType = enumType
    }
}

Which does not work, because RawRepresentable can only be used as generic constraint.

So my question is, how can I store the enum type, so I can then create any Enum of that type at any point? (Also, I am using Swift 2.2)

sketchyTech · Accepted Answer · 2016-06-21T11:18:08.713

1

In your example (B) even if the compiler allowed it, there would be no way to guarantee that the init enumType was the same as the enumType property.

The only solution that I can think of in this situation would be to ignore type safety and use Any

public struct WRPProperty {
    var enumType:Any?
    public init<T:RawRepresentable>(remote : String, enumType: T) {
        self.enumType = enumType
    }
}

unless you can find some clever way of wrapping your values or employing a more sophisticated type erasure. This provides you with the dynamic ability you are looking for (although the best solution is probably to restructure your approach so that the enum Type can be set at instantiation if at all possible).

edited Jun 21 '16 at 11:18

answered Jun 21 '16 at 10:15

sketchyTech

5,746
1
33
56

But then, when I store it as Any, I cannot allocate it with raw value, because it does not have the initializer (as I does not know that it should conform to that protocol) and I cannot force-type cast it, becaues Any cannot be converted this way. I am missing something? – Jiri Trecak Jun 21 '16 at 20:27
I'm not clear on exactly what you mean here. You can cast like so: `wrp.enumType as? WRPEnum` you can also assign `wrp.enumType = WRPEnum(rawValue: 1)`. What doesn't happen is a leveraging of generics to ensure that enumType is always the same as the init type T. Instead you are left to test what type the enumType is. – sketchyTech Jun 21 '16 at 20:38
Thank you, it was very helpful. I will have to rethink how some things are handled, which will require some heavy tinkering with how it is done currently. The solution would work but it is very hacky and I will rather spend more time making it better, even if that means that some core concepts will change. – Jiri Trecak Jun 21 '16 at 21:36

Storing Enum type in Swift

1 Answers1