Create Realm Objects - Kotlin SDK

// Open a write transaction
realm.write {
    // Instantiate a new unmanaged Frog object
    val unmanagedFrog = Frog().apply {
        name = "Kermit"
        age = 42
        owner = "Jim Henson"
    }
    assertFalse(unmanagedFrog.isManaged())
    // Copy the object to realm to return a managed instance
    val managedFrog = copyToRealm(unmanagedFrog)
    assertTrue(managedFrog.isManaged())
    // Work with the managed object ...
}

realm.write {
    // Instantiate a parent object with one embedded address
    val contact = Contact().apply {
        name = "Kermit"
        address = EmbeddedAddress().apply {
            propertyOwner = Contact().apply { name = "Mr. Frog" }
            street = "123 Pond St"
            country = EmbeddedCountry().apply { name = "United States" }
        }
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(contact)
}

realm.write {
    // Instantiate a parent object with multiple embedded addresses
    val localOffice = EmbeddedAddress().apply {
        propertyOwner = Contact().apply { name = "Michigan J. Frog" }
        street = "456 Lily Pad Ln"
        country = EmbeddedCountry().apply { name = "United States" }
    }
    val remoteOffice = EmbeddedAddress().apply {
        propertyOwner = Contact().apply { name = "Mr. Toad" }
        street = "789 Leaping Frog Ave"
        country = EmbeddedCountry().apply { name = "Ireland" }
    }
    val business = Business().apply {
        name = "Big Frog Corp."
        addresses = realmListOf(localOffice, remoteOffice)
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(business)
}

// Open a write transaction
realm.write {
    // Create a new asymmetric object
    val weatherSensor = WeatherSensor().apply {
        deviceId = "WX1278UIT"
        temperatureInFarenheit = 6.7F
        barometricPressureInHg = 29.65F
        windSpeedInMph = 2
    }
    // Insert the object into the realm with the insert() extension method
    insert(weatherSensor)
// WeatherSensor object is inserted into the realm, then synced to the
// App Services backend. You CANNOT access the object locally because it's
// deleted from the local realm after sync is complete.
}

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmInstant property
    val frog = Frog().apply {
        name = "Kermit"
        // Set an initial value with RealmInstant.from() or RealmInstant.now()
        birthdate = RealmInstant.from(1_577_996_800, 0)
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

realm.write {
    // Instantiate a new unmanaged Frog object with a MutableRealmInt property
    val frog = Frog().apply {
        name = "Michigan J. Frog"
        // Set an initial value with MutableRealmInt.create()
        fliesEaten = MutableRealmInt.create(200)
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmAny property
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial values with RealmAny.create()
        favoriteThings = realmListOf(
            RealmAny.create(42),
            RealmAny.create("rainbows"),
            RealmAny.create(Frog().apply {
                name = "Kermit Jr."
            })
        )
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmList property
    val frog = Frog().apply {
        name = "Kermit"
        // Set values for each unmanaged list
        favoritePonds.addAll(realmListOf(
            Pond().apply { name = "Picnic Pond" },
            Pond().apply { name = "Big Pond" }
        ))
        favoriteForests.add(EmbeddedForest().apply { name = "Hundred Acre Wood" })
        favoriteWeather = realmListOf("rain", "snow")
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

realm.write {
    // Instantiate a new unmanaged Frog object with RealmSet properties
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial values to each unmanaged set
        favoriteSnacks.addAll(setOf(
            Snack().apply { name = "flies" },
            Snack().apply { name = "crickets" },
            Snack().apply { name = "worms" }
        ))
        favoriteWeather.add("rain")
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

realm.write {
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial key-values to each unmanaged dictionary
        favoriteFriendsByPond = realmDictionaryOf(
            "Picnic Pond" to Frog().apply { name = "Froggy Jay" },
            "Big Pond" to Frog().apply { name = "Mr. Toad" }
        )
        favoriteTreesInForest["Maple"] = EmbeddedForest().apply {
            name = "Hundred Acre Wood"
        }
        favoritePondsByForest.putAll(
            mapOf(
                "Silver Pond" to "Big Forest",
                "Big Lake" to "Elm Wood",
                "Trout Pond" to "Sunny Wood"
            )
        )
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

// Percent encode . or $ characters to use them in map keys
val mapKey = "Hundred Acre Wood.Northeast"
val encodedMapKey = "Hundred Acre Wood%2ENortheast"

realm.write {
    // Instantiate a new unmanaged Frog object with to-one
    // relationship with a Realm object
    val frog = Frog().apply {
        name = "Kermit"
        age = 12
        favoritePond = Pond().apply { name = "Picnic Pond" }
        bestFriend = Frog().apply { name = "Froggy Jay" }
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

realm.write {
    // Instantiate a new unmanaged Forest object with to-many
    // relationship with multiple Realm objects
    val forest = Forest().apply {
        name = "Froggy Forest"
        frogsThatLiveHere = realmSetOf(
            Frog().apply { name = "Kermit" },
            Frog().apply { name = "Froggy Jay" }
        )
        nearbyPonds = realmListOf(
            Pond().apply { name = "Small Picnic Pond" },
            Pond().apply { name = "Big Pond" }
        )
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(forest)
}

realm.write {
    // Instantiate a new unmanaged User object with to-many
    // relationship with multiple Realm objects
    val post1 = Post().apply {
        title = "Forest Life"
    }
    val post2 = Post().apply {
        title = "Top Ponds of the Year!"
    }
    val user = User().apply {
        name = "Kermit"
        posts = realmListOf(post1, post2)
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(user)
}