New Realm Data Types: Dictionaries/Maps, Sets, Mixed, and UUIDs

1
import android.util.Log
2
import io.realm.Realm
3
import io.realm.RealmDictionary
4
import io.realm.RealmObject
5
import io.realm.kotlin.where
6
import kotlinx.coroutines.flow.Flow
7
import kotlinx.coroutines.flow.flow
8
import java.util.AbstractMap
9
10
open class Player : RealmObject() {
11
    var name: String? = null
12
    var email: String? = null
13
    var playerHandle: String? = null
14
    var gameplayStats: RealmDictionary<String> = RealmDictionary()
15
    var competitionStats: RealmDictionary<String> = RealmDictionary()
16
}
17
18
realm.executeTransactionAsync { r: Realm ->
19
    val player = Player()
20
    player.playerHandle = "iDubs"
21
    // get the RealmDictionary field from the object we just created and add stats
22
    player.gameplayStats = RealmDictionary(mapOf<String, String>())
23
            .apply {
24
                "mostCommonRole" to "Medic"
25
                "clan" to "Realmers"
26
                "favoriteMap" to "Scorpian Bay"
27
                "tagLine" to "Always be Healin"
28
                "nemesisHandle" to "snakeCase4Life"
29
            }
30
    player.competitionStats = RealmDictionary(mapOf<String, String>()).apply {
31
        "EastCoastInvitational" to "2nd Place"
32
        "TransAtlanticOpen" to "4th Place"
33
    }
34
    r.insert(player)
35
}
36
37
// Developer implements a Competitions View -
38
// emit all entries in the dictionary for view by the user
39
val player = realm.where<Player>().equalTo("name", "iDubs").findFirst()
40
player?.let {
41
    player.competitionStats.addChangeListener { map, changes ->
42
        val insertions = changes.insertions
43
        for (insertion in insertions) {
44
            Log.v("EXAMPLE", "Player placed at a new competition $insertion")
45
        }
46
    }
47
}
48
49
fun competitionFlow(): Flow<String> = flow {
50
    for ((competition, place) in player!!.competitionStats) {
51
        emit("$competition - $place")
52
    }
53
}
54
55
// Build a RealmQuery that searches the Dictionary type
56
val query = realm.where<Player>().equalTo("name", "iDubs")
57
val entry = AbstractMap.SimpleEntry("nemesisHandle", "snakeCase4Life")
58
val playerQuery = query.containsEntry("gameplayStats", entry).findFirst()
59
60
// remove player nemesis - they are friends now!
61
realm.executeTransaction { r: Realm ->
62
    playerQuery?.gameplayStats?.remove("nemesisHandle")
63
}

1
import android.util.Log
2
import io.realm.*
3
import io.realm.kotlin.where
4
5
open class Distributor : RealmObject() {
6
    var name: String = ""
7
    var transitPolicy: String = ""
8
}
9
10
open class Business : RealmObject() {
11
    var name: String = ""
12
    var deliveryMethod: String = ""
13
}
14
15
open class Individual : RealmObject() {
16
    var name: String = ""
17
    var salesTerritory: String = ""
18
}
19
20
open class Palette(var owner: RealmAny = RealmAny.nullValue()) : RealmObject() {
21
    var scanId: String? = null
22
    open fun ownerToString(): String {
23
        return when (owner.type) {
24
            RealmAny.Type.NULL -> {
25
                "no owner"
26
            }
27
            RealmAny.Type.STRING -> {
28
                owner.asString()
29
            }
30
            RealmAny.Type.OBJECT -> {
31
                when (owner.valueClass) {
32
                    is Business -> {
33
                        val business = owner.asRealmModel(Business::class.java)
34
                        business.name
35
                    }
36
                    is Distributor -> {
37
                        val distributor = owner.asRealmModel(Distributor::class.java)
38
                        distributor.name
39
                    }
40
                    is Individual -> {
41
                        val individual = owner.asRealmModel(Individual::class.java)
42
                        individual.name
43
                    }
44
                    else -> "unknown type"
45
                }
46
            }
47
            else -> {
48
                "unknown type"
49
            }
50
        }
51
    }
52
}
53
54
realm.executeTransaction { r: Realm ->
55
    val newDistributor = r.copyToRealm(Distributor().apply {
56
        name = "Warehouse R US"
57
        transitPolicy = "Onsite Truck Pickup"
58
    })
59
    val paletteOne = r.copyToRealm(Palette().apply {
60
        scanId = "A1"
61
    })
62
    // Add the owner of the palette as an object reference to another Realm class
63
    paletteOne.owner = RealmAny.valueOf(newDistributor)
64
    val newBusiness = r.copyToRealm(Business().apply {
65
        name = "Mom and Pop"
66
        deliveryMethod = "Cheapest Private Courier"
67
    })
68
    val paletteTwo = r.copyToRealm(Palette().apply {
69
        scanId = "B2"
70
        owner = RealmAny.valueOf(newBusiness)
71
    })
72
    val newIndividual = r.copyToRealm(Individual().apply {
73
        name = "Traveling Salesperson"
74
        salesTerritory = "DC Corridor"
75
    })
76
    val paletteThree = r.copyToRealm(Palette().apply {
77
        scanId = "C3"
78
        owner = RealmAny.valueOf(newIndividual)
79
    })
80
}
81
82
// Get a reference to palette one
83
val paletteOne = realm.where<Palette>()
84
        .equalTo("scanId", "A1")
85
        .findFirst()!!
86
87
// Extract underlying Realm Object from RealmAny by casting it RealmAny.Type.OBJECT
88
val ownerPaletteOne: Palette = paletteOne.owner.asRealmModel(Palette::class.java)
89
Log.v("EXAMPLE", "Owner of Palette One: " + ownerPaletteOne.ownerToString())
90
91
// Get a reference to the palette owned by Traveling Salesperson
92
// so that you can remove ownership - they're broke!
93
val salespersonPalette = realm.where<Palette>()
94
        .equalTo("owner.name", "Traveling Salesperson")
95
        .findFirst()!!
96
97
val salesperson = realm.where<Individual>()
98
        .equalTo("name", "Traveling Salesperson")
99
        .findFirst()
100
101
realm.executeTransaction { r: Realm ->
102
    salespersonPalette.owner = RealmAny.nullValue()
103
}
104
105
val paletteTwo = realm.where<Palette>()
106
        .equalTo("scanId", "B2")
107
        .findFirst()!!
108
109
// Set up a listener to see when Ownership changes for relabeling of palettes
110
val listener = RealmObjectChangeListener { changedPalette: Palette, changeSet: ObjectChangeSet? ->
111
    if (changeSet != null && changeSet.changedFields.contains("owner")) {
112
        Log.i("EXAMPLE",
113
                "Palette $'paletteTwo.scanId' has changed ownership.")
114
    }
115
}
116
117
// Observe object notifications.
118
paletteTwo.addChangeListener(listener)

1
import android.util.Log
2
import io.realm.*
3
import io.realm.kotlin.where
4
5
open class Expert : RealmObject() {
6
    var name: String = ""
7
    var email: String = ""
8
    var disciplines: RealmSet<String> = RealmSet<String>()
9
}
10
11
open class Topic : RealmObject() {
12
    var name: String = ""
13
    var location: String = ""
14
    var discussionThemes: RealmSet<String> = RealmSet<String>()
15
    var panelists: RealmList<Expert> = RealmList()
16
}
17
18
realm.executeTransaction { r: Realm ->
19
    val newExpert = r.copyToRealm(Expert())
20
    newExpert.name = "Techno King"
21
    // get the RealmSet field from the object we just created
22
    val disciplineSet = newExpert.disciplines
23
    // add value to the RealmSet
24
    disciplineSet.add("Trance")
25
    disciplineSet.add("Meme Coins")
26
    val topic = realm.copyToRealm(Topic())
27
    topic.name = "Bitcoin Mining and Climate Change"
28
    val discussionThemes = topic.discussionThemes
29
    // Add a list of themes
30
    discussionThemes.addAll(listOf("Memes", "Blockchain", "Cloud Computing",
31
            "SNL", "Weather Disasters from Climate Change"))
32
}
33
34
// find experts for a discussion topic and add them to the panelists list
35
val experts: RealmResults<Expert> = realm.where<Expert>().findAll()
36
val topic = realm.where<Topic>()
37
        .equalTo("name", "Bitcoin Mining and Climate Change")
38
        .findFirst()!!
39
topic.discussionThemes.forEach { theme ->
40
    experts.forEach { expert ->
41
        if (expert.disciplines.contains(theme)) {
42
            topic.panelists.add(expert)
43
        }
44
    }
45
}
46
47
//observe the discussion themes set for any changes in the set
48
val discussionTopic = realm.where<Topic>()
49
        .equalTo("name", "Bitcoin Mining and Climate Change")
50
        .findFirst()
51
val anotherDiscussionThemes = discussionTopic?.discussionThemes
52
val changeListener = SetChangeListener { collection: RealmSet<String>,
53
                                         changeSet: SetChangeSet ->
54
    Log.v(
55
            "EXAMPLE",
56
            "New discussion themes has been added: ${changeSet.numberOfInsertions}"
57
    )
58
}
59
60
// Observe set notifications.
61
anotherDiscussionThemes?.addChangeListener(changeListener)
62
63
// Techno King is no longer into Meme Coins - remove the discipline
64
realm.executeTransaction {
65
    it.where<Expert>()
66
            .equalTo("name", "Techno King")
67
            .findFirst()?.let { expert ->
68
        expert.disciplines.remove("Meme Coins")
69
    }
70
}

1
import io.realm.Realm
2
import io.realm.RealmObject
3
import io.realm.annotations.PrimaryKey
4
import io.realm.annotations.RealmField
5
import java.util.UUID;
6
import io.realm.kotlin.where
7
8
open class Task: RealmObject() {
9
    @PrimaryKey
10
    @RealmField("_id")
11
    var id: UUID = UUID.randomUUID()
12
    var name: String = ""
13
    var owner: String= ""
14
}
15
16
realm.executeTransaction { r: Realm ->
17
    // UUID field is generated automatically in the class constructor
18
    val newTask = r.copyToRealm(Task())
19
    newTask.name = "Update to use new Data Types"
20
    newTask.owner = "Realm Developer"
21
}
22
23
val taskUUID: Task? = realm.where<Task>()
24
        .equalTo("_id", "38400000-8cf0-11bd-b23e-10b96e4ef00d")
25
        .findFirst()