Using enum as property of Realm model

Question

Is it possible to use an Enum as a property for my model? I currently have a class like this:

class Checkin: RLMObject {
  dynamic var id: Int = 0
  dynamic var kind: String = "checked_in"
  var kindEnum: Kind = .CheckedIn {
    willSet { self.kind = newValue.rawValue }
  }

  enum Kind: String {
    case CheckedIn = "checked_in"
    case EnRoute = "en_route"
    case DroppedOff = "dropped_off"
  }
  ....
}

It works okay, but I'd like to be able to have the kind property be the Enum and have Realm automatically call .rawValue on the property when it is saving an object to the store. Is this possible in Realm or is there a feature request already out there for it?

score 96 · Accepted Answer · edited Feb 21 '19 at 13:37

96

You should override your kindEnum's setter and getter for this case:

enum Kind: String {
  case CheckedIn
  case EnRoute
  case DroppedOff
}

class Checkin: Object {
  @objc dynamic var id = 0
  var kind = Kind.CheckedIn.rawValue
  var kindEnum: Kind {
    get {
      return Kind(rawValue: kind)!
    }
    set {
      kind = newValue.rawValue
    }
  }
}

edited Feb 21 '19 at 13:37

Lepidopteron

6,056
5
41
53

answered Mar 19 '15 at 15:55

jpsim

14,329
6
51
68

1

Will be great if you could add this sample to your official examples. – Shmidt May 18 '15 at 13:44
This is not great. Why can't you do this?: http://stackoverflow.com/questions/26900302/swift-storing-states-in-coredata-with-enums (the Martin Krenek answer)? – Rob Oct 20 '15 at 23:19
1

You can use `@objc` enums directly with Realm too, but that won't work for Swift enums with `String` associated values. – jpsim Oct 21 '15 at 00:09
In the absence of "official" support from Realm (if it's even possible), this is very useful. Thank you. – Stephen Watson Nov 02 '15 at 14:13
2

You could set kind variable as private, so you could only change its value with kindEnum. – Nuno Vieira Aug 22 '16 at 09:43
just a suggestion: as I use the enum more than raw value in my code, I named them `kindRaw` and `kind` – 0xKayvan Dec 12 '16 at 06:16
Looks really awful – imike Apr 28 '18 at 18:33

score 53 · Answer 2 · edited Jun 27 '16 at 21:44

53

I've refined this model a little further.

enum Thing: String {
    case Thing1
    case Thing2
    case Thing3
}

then in my Realm class object:

class myClass : Object {
    private dynamic var privateThing = Thing.Thing1.rawValue
    var thing: Thing {
        get { return Thing(rawValue: privateThing)! }
        set { privateThing = newValue.rawValue }
    }
}

This allows us to write

myClassInstance.thing = .Thing1

(storing "Thing1" into privateThing), but prevents typing of

myClassInstance.privateThing = "Thing4"

which is not a valid value so preserving data integrity.

edited Jun 27 '16 at 21:44

Victor Gomes

463
6
15

answered Nov 02 '15 at 15:11

Stephen Watson

1,700
16
17

Update: I've edited my original code because the the = "Thing1" etc. is redundant as Swift uses a String literal equivalent of the case for its rawValue, which is even better and we can use the rawValue to set the default which is more reliable and cleaner. :-) – Stephen Watson Nov 02 '15 at 15:33
Thanks for this addition, I really like this answer. +1 – dehlen May 27 '16 at 08:16

score 33 · Answer 3 · answered Dec 31 '21 at 04:07

33

Realm 10.0.0 introduces PersistableEnum Protocol that makes it easy to persist enum values without any third-party extensions.

enum TaskStatusEnum: String, PersistableEnum {
    case notStarted
    case inProgress
    case complete
}
// To use the enum:
class Task: Object {
    // Required enum property
    @Persisted var status = TaskStatusEnum.notStarted 
    // Optional enum property
    @Persisted var optionalTaskStatusEnumProperty: TaskStatusEnum? 
}

answered Dec 31 '21 at 04:07

Mohamed Salah

868
1
15
34

3

This should be accepted answer in 2022. – Łukasz Duda Jan 12 '22 at 10:45
This should be the accepted answer in 2022!!! – XY L Feb 05 '22 at 05:30
1

This is the real right answer! – AntonioWar Jan 12 '23 at 15:19

score 20 · Answer 4 · answered Dec 26 '16 at 22:32

20

Since Realm support Objective-C enums and they are representable by Int you can use this:

class Checkin: Object {
  dynamic var id: Int = 0
  dynamic var kind: Kind = .checkedIn

  @objc enum Kind: Int {
    case checkedIn
    case enRoute
    case droppedOff
  }
  ....
}

If you need to parse to/from String you can use a custom initializer for Kind and an toString function.

There is a discussion about this in GitHub

This works with Swift 3.0 and Realm 2.0.2

answered Dec 26 '16 at 22:32

Diogo T

2,591
1
29
39

Nice solution if you have an `Int` enum, but it don't see how it can work with a `String` instead. `Kind` is converted to an Objective-C enum which doesn't support custom initializers or stored properties.. ? – Anders Friis Feb 06 '17 at 13:21
Indeed, I haven't found a solution that work with any type but `Int` – Diogo T Feb 07 '17 at 15:14
Thank you for this information. I changed my enum to conform to an int. If you need a string value you can make your own computed property in the enum and return the proper value for the different cases. – dan Apr 02 '18 at 20:45
1

Note that any migrations you do involving Int enums will need to assign the raw value: obj["propertyName"] = Kind.checkedIn.rawValue – Eli Burke Mar 20 '19 at 18:32

Pei · Answer 5 · 2020-05-26T23:28:29.873

13

Diogo T's solution worked before recent updates of RealmSwift. Eventually we now have to conform to RealmEnum protocol to be able to be a managed property of Realm Object.

@objc enum MyEnum: Int, RealmEnum {
    ...
}

Or add below in some place:

extension MyEnum: RealmEnum { }

RealmSwift documentation for it

edited May 26 '20 at 23:28

answered Feb 04 '20 at 02:17

Pei

11,452
5
41
45

score 9 · Answer 6 · answered Jan 17 '22 at 22:31

Clean & Easy solution

From Realm version >= 10.10.0 you can do this:

// Define the enum
enum StatusEnum: String, PersistableEnum {
    case notStarted
    case inProgress
    case complete
}

// To use the enum:
class Task: Object {
    @Persisted var status = StatusEnum.notStarted 
}

score 0 · Answer 7 · answered Oct 14 '20 at 18:25

Example with RealmEnum and RealmOptional

@objc enum MyEnum: Int, RealmEnum {
    case first
    case second
}

final class MyEntry: Object {
    //It should be let
    let someVariable = RealmOptional<CRUD>()
}

//using
myEntry.someVariable.value = MyEnum.first

railwayparade · Answer 8 · 2021-02-12T00:57:07.120

Alternate solution to avoid the force un-wrap get { return Thing(rawValue: privateThing)! }

enum Kind: String, CaseIterable {
      case CheckedIn
      case EnRoute
      case DroppedOff
    }

    @objc dynamic var kindRaw = Kind.CheckedIn.rawValue
    var kind: Kind {
        get {
            for kind in Kind.allCases where kindRaw == kind.rawValue {
                return kind
            }
            return .CheckedIn //default
        }
        set {
            kindRaw = newValue.rawValue
        }
    }

Using enum as property of Realm model

8 Answers8

Clean & Easy solution

Linked