Kotlinの拡張関数をオブジェクト単位で限定的に活用する方法

fun String.isPalindrome(): Boolean {
    return this == this.reversed()
}

fun List<Int>.sumOfSquares(): Int {
    return this.sumOf { it * it }
}

val numbers = listOf(1, 2, 3)
println(numbers.sumOfSquares()) // 出力: 14

class CustomObject(val name: String)

fun CustomObject.greet(): String {
    return "Hello, $name!"
}

val obj1 = CustomObject("Alice")
val obj2 = CustomObject("Bob")

println(obj1.greet()) // 出力: Hello, Alice!
println(obj2.greet()) // 出力: Hello, Bob!

class CustomObject(val id: Int, val name: String)

val allowedObject = CustomObject(1, "Allowed")

fun CustomObject.performAction() {
    if (this != allowedObject) {
        throw IllegalAccessException("This function is only allowed for the specified object.")
    }
    println("Action performed for $name")
}

val obj1 = CustomObject(1, "Allowed")
val obj2 = CustomObject(2, "NotAllowed")

obj1.performAction() // 出力: Action performed for Allowed
obj2.performAction() // 例外: IllegalAccessException

val customObject = CustomObject(1, "ScopedObject")

fun CustomObject.scopedExtension(block: CustomObject.() -> Unit) {
    if (this == customObject) {
        block()
    } else {
        throw IllegalAccessException("This function can only be used in the specific scope.")
    }
}

customObject.scopedExtension {
    println("This is a scoped extension for $name")
}
// 他のオブジェクトでは例外が発生する

   if (this != allowedObject) {
       throw IllegalAccessException("Only the allowed object can call this function.")
   }

class Config(val settings: MutableMap<String, Any>)

fun Config.applySettings(block: Config.() -> Unit) {
    this.apply(block)
    println("Settings applied: $settings")
}

// 使用例
val config = Config(mutableMapOf())

config.applySettings {
    settings["theme"] = "dark"
    settings["fontSize"] = 14
}

class User(val name: String, val isAdmin: Boolean)

fun User.performAdminAction(block: User.() -> Unit) {
    if (!isAdmin) {
        throw IllegalAccessException("This action is restricted to admins.")
    }
    block()
}

// 使用例
val adminUser = User("Alice", true)
val regularUser = User("Bob", false)

adminUser.performAdminAction {
    println("Admin action performed by $name")
}

regularUser.performAdminAction {
    println("This will not be printed")
}
// 例外がスローされる: IllegalAccessException

fun <T> T.runWithResult(condition: Boolean, block: T.() -> T): Result<T> {
    return if (condition) {
        runCatching { block() }
    } else {
        Result.failure(IllegalStateException("Condition not met"))
    }
}

// 使用例
val result = "Test".runWithResult(true) {
    this + " Success"
}

result.onSuccess { println(it) } // 出力: Test Success
result.onFailure { println("Failed: ${it.message}") }

class User(val name: String, val role: String)

val adminUser = User("Alice", "admin")
val regularUser = User("Bob", "user")

fun User.performAdminTask(action: User.() -> Unit) {
    if (role != "admin") {
        throw IllegalAccessException("Only admins can perform this action.")
    }
    action()
}

// 使用例
adminUser.performAdminTask {
    println("Admin task performed by $name")
}

// 例外がスローされる
regularUser.performAdminTask {
    println("This will not be executed")
}

class Config(val settings: MutableMap<String, Any>)

val allowedConfig = Config(mutableMapOf("theme" to "light", "fontSize" to 12))

fun Config.updateSettings(updater: Config.() -> Unit) {
    if (this != allowedConfig) {
        throw IllegalAccessException("Settings can only be updated for the allowed config.")
    }
    updater()
}

// 使用例
allowedConfig.updateSettings {
    settings["theme"] = "dark"
    settings["fontSize"] = 16
}
println(allowedConfig.settings) // 出力: {theme=dark, fontSize=16}

class LoggableAction(val actionName: String)

val criticalAction = LoggableAction("Critical Operation")

fun LoggableAction.logIfCritical(logger: LoggableAction.() -> Unit) {
    if (this == criticalAction) {
        println("Logging critical action: $actionName")
        logger()
    } else {
        println("Action $actionName does not require logging.")
    }
}

// 使用例
criticalAction.logIfCritical {
    println("Executing $actionName")
}

val regularAction = LoggableAction("Regular Operation")
regularAction.logIfCritical {
    println("Executing $actionName")
}

import kotlin.properties.Delegates

class User(val name: String) {
    var accessLevel: String by Delegates.observable("guest") { _, old, new ->
        println("Access level changed from $old to $new")
    }
}

fun User.updateAccessLevel(newLevel: String) {
    if (newLevel in listOf("guest", "user", "admin")) {
        this.accessLevel = newLevel
    } else {
        throw IllegalArgumentException("Invalid access level: $newLevel")
    }
}

// 使用例
val user = User("Alice")
user.updateAccessLevel("admin") // 出力: Access level changed from guest to admin

class Config(val settings: MutableMap<String, Any>)

fun Config.applySafeChanges(block: Config.() -> Unit) {
    this.run {
        println("Applying safe changes...")
        block()
        println("Changes applied successfully.")
    }
}

// 使用例
val config = Config(mutableMapOf("theme" to "light"))

config.applySafeChanges {
    settings["theme"] = "dark"
    settings["fontSize"] = 14
}

println(config.settings) // 出力: {theme=dark, fontSize=14}

sealed class Account {
    class Admin(val permissions: List<String>) : Account()
    class User(val username: String) : Account()
}

fun Account.performAction() {
    when (this) {
        is Account.Admin -> println("Performing admin actions with permissions: $permissions")
        is Account.User -> println("Performing user actions for: $username")
    }
}

// 使用例
val admin = Account.Admin(listOf("READ", "WRITE"))
val user = Account.User("Alice")

admin.performAction() // 出力: Performing admin actions with permissions: [READ, WRITE]
user.performAction() // 出力: Performing user actions for: Alice

class User(val name: String, val role: String)

val admin = User("Alice", "admin")
val user = User("Bob", "user")

admin.performAdminAction {
    println("Admin action performed by $name")
}

user.performAdminAction {
    println("This should not execute")
}
// 実行時に例外がスローされる: IllegalAccessException

class Config(val settings: MutableMap<String, Any>)

val allowedConfig = Config(mutableMapOf("theme" to "light"))
val otherConfig = Config(mutableMapOf("theme" to "dark"))

allowedConfig.updateSettings {
    settings["theme"] = "dark"
}

otherConfig.updateSettings {
    settings["theme"] = "light"
}
// 実行時に例外がスローされる: IllegalAccessException

class Action(val name: String, val isCritical: Boolean)

val criticalAction = Action("Delete Database", true)
val regularAction = Action("Update Profile", false)

criticalAction.logIfCritical {
    println("Executing critical action: $name")
}

regularAction.logIfCritical {
    println("This will not execute")
}