[移动开发]kotlin链式处理嵌套If else

kotlin链式处理嵌套If else

kotlin文件

@file:Suppress("UNCHECKED_CAST", "RedundantVisibilityModifier")

package com.quanyou.xxxx

import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract

public class Result<out T> @PublishedApi internal constructor(
        override val isTrue: Boolean,
        @PublishedApi
        internal val value: T?
) : Result0(isTrue) {

    public inline fun invoke(action: (value: T?) -> Unit) {
        isInvoked = true
        action(value)
    }

    public fun isFalseOrNull(): Boolean {
        return !isInvoked && (value?.run { !isTrue } ?: false)
    }

    public companion object {
        @Suppress("INAPPLICABLE_JVM_NAME")
        @JvmName("failure")
        public fun <T> get(isTrue: Boolean, value: T?): Result<T> =
                Result(isTrue, value)
    }
}

@ExperimentalContracts
public inline fun <T> T?.ifElse(predicate: T.() -> Boolean): Result<T> {
    return Result.get(this?.run { predicate(this) } ?: false, this)
}

@ExperimentalContracts
public fun <T> T?.ifElse(predicate: Boolean): Result<T> {
    return Result.get(this?.run { predicate } ?: false, this)
}

/**
 * [action]代码块，如果在每一级判定条件中和[isTrue]或[isTrue2Next]成对出现,则当前判定条件值为[false]且扩展类[T]对象不为[null]时调用(如果当前判定已被处理则跳过);
 * 如果之前判定没有任何[isFalse]或[isFalseOrNull]处理,则此前任意一个判定条件为[false]且扩展类[T]对象不为[null]时调用。
 */
@ExperimentalContracts
public inline fun <T> Result<T>.isFalse(action: (value: T?) -> Unit): Result<T> {
    contract {
        callsInPlace(action, InvocationKind.AT_MOST_ONCE)
    }
    if (isFalse()) invoke(action)
    return this
}

/**
 * 如果此方法直接放[ifElse]之后,[action]代码块在[ifElse]判定条件值为[false]或扩展类[T]对象为[null]时调用。否则等同[isFalse]
 */
@ExperimentalContracts
public inline fun <T> Result<T>.isFalseOrNull(action: (value: T?) -> Unit): Result<T> {
    contract {
        callsInPlace(action, InvocationKind.AT_MOST_ONCE)
    }
    if (isFalseOrNull()) invoke(action)
    return this
}

/**
 * [action]代码块，当上一级判定条件值为[true]且扩展类[T]对象不为[null]时调用。如果上一级判定已被处理则跳过 。
 */
@ExperimentalContracts
public inline fun <T> Result<T>.isTrue(action: (value: T) -> Unit): Result<T> {
    contract {
        callsInPlace(action, InvocationKind.AT_MOST_ONCE)
    }
    value?.run {
        if (!isInvoked && isTrue) {
            isInvoked = true
            action(value)
        }
    }
    return this
}

/**
 * [action]代码块，当上一级判定条件值为[true]且[T]对象不为[null]时调用，返回下一级判定条件。如果上一级判定已被处理则跳过 。
 */
@ExperimentalContracts
public inline fun <T> Result<T>.isTrue2Next(action: (value: T) -> (Boolean)): Result<T> {
    contract {
        callsInPlace(action, InvocationKind.AT_MOST_ONCE)
    }
    return value?.let {
        if (!isInvoked && isTrue) value.ifElse {
            isInvoked = true
            action(value)
        } else this@isTrue2Next
    } ?: this
}

public open class Result0 internal constructor(
        open val isTrue: Boolean,
) {
    var isInvoked = false

    public inline fun invoke(action: () -> Unit) {
        isInvoked = true
        action()
    }

    public fun isFalse(): Boolean {
        return !(isInvoked || isTrue)
    }

    public companion object {
        @Suppress("INAPPLICABLE_JVM_NAME")
        @JvmName("failure")
        public fun get(isTrue: Boolean): Result0 =
                Result0(isTrue)
    }
}

@JvmName("ifElse")
public inline fun _ifElse(predicate: () -> Boolean): Result0 {
    return Result0.get(predicate())
}

public fun ifElse(predicate: Boolean): Result0 {
    return Result0.get(predicate)
}

/**
 * [action]代码块，如果在每一级判定条件中和[isTrue]或[isTrue2Next]成对出现,则当前判定条件值为[false]时调用(如果当前判定已被处理则跳过);
 * 如果之前判定没有任何[isFalse]处理,则此前任意一个判定条件为[false]时调用。
 */
@ExperimentalContracts
public inline fun Result0.isFalse(action: () -> Unit): Result0 {
    contract {
        callsInPlace(action, InvocationKind.AT_MOST_ONCE)
    }
    if (isFalse()) invoke(action)
    return this
}

/**
 * [action]代码块，当上一级判定条件值为[true]时调用。如果上一级判定已被处理则跳过 。
 */
@ExperimentalContracts
public inline fun Result0.isTrue(action: () -> Unit): Result0 {
    contract {
        callsInPlace(action, InvocationKind.AT_MOST_ONCE)
    }

    if (!isInvoked && isTrue) {
        isInvoked = true
        action()
    }
    return this
}

/**
 * [action]代码块，当上一级判定条件值为[true]时调用，返回下一级判定条件。如果上一级判定已被处理则跳过 。
 */
@ExperimentalContracts
public inline fun Result0.isTrue2Next(action: () -> (Boolean)): Result0 {
    contract {
        callsInPlace(action, InvocationKind.AT_MOST_ONCE)
    }
    return if (!isInvoked && isTrue) _ifElse {
        isInvoked = true
        action()
    } else this
}

示例

1、示例一

 this.ifElse {
            i >= 1//一级判定条件
        }.isFalseOrNull {e->
            log("1")
            //此代码块 当上一级判定条件(i >= 1) 值为false 或者 this(即e对象) == null时调用
        }.isTrue2Next { e ->
            //此代码块 当上一级判定条件(i >= 1) 值为true 且 this(即e对象) != null时调用
            log("2")
            i >= 2
        }.isFalse { e ->
            log("3")
            //此代码块 当上一级判定条件(i >= 2) 值为false时调用
        }.isTrue2Next { e ->
            //此代码块 当上一级判定条件(i >= 2) 值为true 且 this(即e对象) != null时调用 
            log("4")
            i >= 3
        }.isFalse { e->
            log("5")
            //此代码块 当上一级判定条件(i >= 3) 值为false时调用 
        }.isTrue { e ->
            log("6")
            //此代码块 当上一级判定条件(i >= 3) 值为true 且 this(即e对象) != null时调用 
        }.isFalse { e ->
            log("7")
           //此代码块 不会调用 因为上一级判定(i >= 3) 已被处理
        }.isTrue { e ->
            log("8")
            //此代码块 不会调用 因为上一级判定(i >= 3) 已被处理
        }

 _ifElse {
            i >= 1//一级判定条件
        }.isFalse {
            log("1")
            //此代码块 当上一级判定条件(i >= 1) 值为false 时调用
        }.isTrue2Next {
            //此代码块 当上一级判定条件(i >= 1) 值为true 时调用
            log("2")
            i >= 2
        }.isFalse {
            log("3")
            //此代码块 当上一级判定条件(i >= 2) 值为false时调用 
        }.isTrue2Next {
            //此代码块 当上一级判定条件(i >= 2) 值为true 时调用
            log("4")
            i >= 3
        }.isFalse {
            log("5")
            //此代码块 当上一级判定条件(i >= 3) 值为false时调用 
        }.isTrue {
            log("6")
            //此代码块 当上一级判定条件(i >= 3) 值为true 时调用 
        }.isFalse {
            log("7")
            //此代码块 不会调用 因为上一级判定(i >= 3) 已被处理
        }.isTrue {
            log("8")
            //此代码块 不会调用 因为上一级判定(i >= 3) 已被处理
        }

2、示例二

  this.ifElse {
            i >= 1//一级判定条件
        }.isTrue2Next { e ->
            //此代码块 当上一级判定条件(i >= 1) 值为true且this(即e对象) != null 时调用
            log("1")
            i >= 2
        }.isTrue2Next { e ->
            //此代码块 当上一级判定条件(i >= 2) 值为true 且this(即e对象) != null 时时调用
            log("2")
            i >= 3
        }.isTrue { e ->
            log("3")
            //此代码块 当上一级判定条件(i >= 3) 值为true且this(即e对象) != null 时 时调用
        }.isFalse { e ->
            log("4")//此代码块 此前判定条件(i >= 1/i >= 2/i >= 3)为false 时调用
        }

        _ifElse {
            i >= 1//一级判定条件
        }.isTrue2Next {
            //此代码块 当上一级判定条件(i >= 1) 值为true 时调用
            log("1")
            i >= 2
        }.isTrue2Next {
            //此代码块 当上一级判定条件(i >= 2) 值为true 时调用
            log("2")
            i >= 3
        }.isTrue {
            log("3")
            //此代码块 当上一级判定条件(i >= 3) 值为true 时调用
        }.isFalse {
            log("4") //此代码块 此前判定条件(i >= 1/i >= 2/i >= 3)为false 时调用
        }