deprecation of BehaviourContextWithFSMBuilder

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSM.kt

@@ -9,6 +9,8 @@ import dev.inmo.micro_utils.coroutines.accumulatorFlow
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
+import kotlin.jvm.JvmName
+import kotlin.reflect.KClass
 
 /**
  * Interface which combine [BehaviourContext] and [StatesMachine]. Subcontext of triggers and states contexts must have
@@ -30,6 +32,25 @@ interface BehaviourContextWithFSM<T : State> : BehaviourContext, StatesMachine<T
         }
     }
 
+    /**
+     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
+     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see onStateOrSubstate
+     */
+    fun <I : T> add(kClass: KClass<I>, strict: Boolean = false, handler: BehaviourWithFSMStateHandler<I, T>)
+
+    /**
+     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
+     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
+     * requirements
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see strictlyOn
+     */
+    fun <I : T> addStrict(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) = add(kClass, strict = true, handler)
+
     override fun copy(
         bot: TelegramBot,
         scope: CoroutineScope,
@@ -40,14 +61,42 @@ interface BehaviourContextWithFSM<T : State> : BehaviourContext, StatesMachine<T
     ): BehaviourContextWithFSM<T>
 
     companion object {
+        @JvmName("invokeWithMutableList")
+        operator fun <T : State> invoke(
+            behaviourContext: BehaviourContext,
+            handlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>>,
+            statesManager: StatesManager<T>
+        ) = DefaultBehaviourContextWithFSM<T>(behaviourContext, statesManager, handlers.toMutableList())
         operator fun <T : State> invoke(
             behaviourContext: BehaviourContext,
             handlers: List<BehaviourWithFSMStateHandlerHolder<*, T>>,
             statesManager: StatesManager<T>
-        ) = DefaultBehaviourContextWithFSM<T>(behaviourContext, statesManager, handlers)
+        ) = invoke<T>(behaviourContext, handlers.toMutableList(), statesManager)
     }
 }
 
+
+/**
+ * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
+ * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
+ *
+ * @see BehaviourWithFSMStateHandlerHolder
+ * @see BehaviourContextWithFSM.add
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+inline fun <reified I : O, O: State> BehaviourContextWithFSM<O>.onStateOrSubstate(handler: BehaviourWithFSMStateHandler<I, O>) = add(I::class, strict = false, handler)
+
+/**
+ * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
+ * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
+ * requirements
+ *
+ * @see BehaviourWithFSMStateHandlerHolder
+ * @see BehaviourContextWithFSM.addStrict
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+inline fun <reified I : O, O: State> BehaviourContextWithFSM<O>.strictlyOn(handler: BehaviourWithFSMStateHandler<I, O>) = addStrict(I::class, handler)
+
 /**
  * Default realization of [BehaviourContextWithFSM]. It uses [behaviourContext] as a base for this object as
  * [BehaviourContext], but managing substates contexts updates for avoiding of updates lost between states
@@ -55,7 +104,7 @@ interface BehaviourContextWithFSM<T : State> : BehaviourContext, StatesMachine<T
 class DefaultBehaviourContextWithFSM<T : State>(
     private val behaviourContext: BehaviourContext,
     private val statesManager: StatesManager<T>,
-    private val handlers: List<BehaviourWithFSMStateHandlerHolder<*, T>>
+    private val handlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>>
 ) : BehaviourContext by behaviourContext, BehaviourContextWithFSM<T> {
     private val updatesFlows = mutableMapOf<Any, Flow<Update>>()
     private fun getContextUpdatesFlow(context: Any) = updatesFlows.getOrPut(context) {
@@ -68,6 +117,10 @@ class DefaultBehaviourContextWithFSM<T : State>(
         handlers
     )
 
+    override fun <I : T> add(kClass: KClass<I>, strict: Boolean, handler: BehaviourWithFSMStateHandler<I, T>) {
+        handlers.add(BehaviourWithFSMStateHandlerHolder(kClass, strict, handler))
+    }
+
     override fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
         val statePerformer: suspend (T) -> Unit = { state: T ->
             val newState = launchStateHandling(state, getContextUpdatesFlow(state.context), handlers)
@@ -106,9 +159,9 @@ class DefaultBehaviourContextWithFSM<T : State>(
         onBufferOverflow: BufferOverflow,
         upstreamUpdatesFlow: Flow<Update>?,
         updatesFilter: BehaviourContextAndTypeReceiver<Boolean, Update>?
-    ): BehaviourContextWithFSM<T> = BehaviourContextWithFSM(
+    ): DefaultBehaviourContextWithFSM<T> = BehaviourContextWithFSM(
         behaviourContext.copy(bot, scope, broadcastChannelsSize, onBufferOverflow, upstreamUpdatesFlow, updatesFilter),
-        handlers,
+        handlers.toMutableList(),
         statesManager
     )
 }

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSMBuilder.kt

@@ -14,70 +14,8 @@ import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.Flow
 import kotlin.reflect.KClass
 
-class BehaviourContextWithFSMBuilder<T : State> internal constructor(
+@Deprecated("Will be removed soon")
-    private val resultBehaviourContext: BehaviourContextWithFSM<T>,
+typealias BehaviourContextWithFSMBuilder<T> = BehaviourContextWithFSM<T>
-    private val handlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>>
-) : BehaviourContextWithFSM<T> by resultBehaviourContext {
-    internal constructor(
-        baseBehaviourContext: BehaviourContext,
-        statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-        handlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf()
-    ) : this(DefaultBehaviourContextWithFSM(baseBehaviourContext, statesManager, handlers), handlers)
-
-    /**
-     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
-     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see onStateOrSubstate
-     */
-    fun <I : T> add(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) {
-        handlers.add(BehaviourWithFSMStateHandlerHolder(kClass, false, handler))
-    }
-
-    /**
-     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
-     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
-     * requirements
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see strictlyOn
-     */
-    fun <I : T> addStrict(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) {
-        handlers.add(BehaviourWithFSMStateHandlerHolder(kClass, true, handler))
-    }
-
-
-    /**
-     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
-     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see BehaviourContextWithFSMBuilder.add
-     */
-    @Suppress("MemberVisibilityCanBePrivate")
-    inline fun <reified I : T> onStateOrSubstate(handler: BehaviourWithFSMStateHandler<I, T>) {
-        add(I::class, handler)
-    }
-
-    /**
-     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
-     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
-     * requirements
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see BehaviourContextWithFSMBuilder.addStrict
-     */
-    @Suppress("MemberVisibilityCanBePrivate")
-    inline fun <reified I : T> strictlyOn(handler: BehaviourWithFSMStateHandler<I, T>) {
-        addStrict(I::class, handler)
-    }
-
-    /**
-     * Returns completed [resultBehaviourContext], [handlers] and [statesManager]
-     */
-    internal fun build() = resultBehaviourContext
-}
 
 /**
  * Creates [BehaviourContextWithFSM] via creating of [DefaultBehaviourContext] with [this] as [TelegramBot],
@@ -95,16 +33,16 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<BehaviourContextWithFSM<T>, Unit>
-): BehaviourContextWithFSM<T> = BehaviourContextWithFSMBuilder(
+): BehaviourContextWithFSM<T> = BehaviourContextWithFSM(
     DefaultBehaviourContext(
         this,
         defaultExceptionsHandler ?.let { scope + ContextSafelyExceptionHandler(it) } ?: scope,
         upstreamUpdatesFlow = upstreamUpdatesFlow
     ),
-    statesManager,
+    presetHandlers,
-    presetHandlers
+    statesManager
-).apply { block() }.build()
+).apply { block() }
 
 /**
  * Use [buildBehaviourWithFSM] to create [BehaviourContextWithFSM] and launch getting of updates
@@ -117,7 +55,7 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<BehaviourContextWithFSM<T>, Unit>
 ): Pair<BehaviourContextWithFSM<T>, Job> = buildBehaviourWithFSM(
     upstreamUpdatesFlow,
     scope,
@@ -147,8 +85,8 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
  * @see BehaviourContext
  * @see BehaviourContextWithFSM
  * @see longPolling
- * @see BehaviourContextWithFSMBuilder.strictlyOn
+ * @see BehaviourContextWithFSM.strictlyOn
- * @see BehaviourContextWithFSMBuilder.onStateOrSubstate
+ * @see BehaviourContextWithFSM.onStateOrSubstate
  */
 @PreviewFeature
 suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
@@ -157,16 +95,16 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<BehaviourContextWithFSM<T>, Unit>
-): BehaviourContextWithFSM<T> = BehaviourContextWithFSMBuilder(
+): BehaviourContextWithFSM<T> = BehaviourContextWithFSM(
     DefaultBehaviourContext(
         this,
         defaultExceptionsHandler ?.let { scope + ContextSafelyExceptionHandler(it) } ?: scope,
         upstreamUpdatesFlow = flowUpdatesFilter.allUpdatesFlow
     ),
-    statesManager,
+    presetHandlers,
-    presetHandlers
+    statesManager
-).apply { block() }.build()
+).apply { block() }
 
 /**
  * Use [buildBehaviourWithFSM] to create [BehaviourContextWithFSM] and launch getting of updates
@@ -176,8 +114,8 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
  * @see buildBehaviourWithFSMAndStartLongPolling
  * @see BehaviourContext
  * @see longPolling
- * @see BehaviourContextWithFSMBuilder.strictlyOn
+ * @see BehaviourContextWithFSM.strictlyOn
- * @see BehaviourContextWithFSMBuilder.onStateOrSubstate
+ * @see BehaviourContextWithFSM.onStateOrSubstate
  */
 @PreviewFeature
 suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
@@ -185,7 +123,7 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<BehaviourContextWithFSM<T>, Unit>
 ) = FlowsUpdatesFilter().let {
     buildBehaviourWithFSM(
         it,

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/TelegramBotWithFSM.kt

@@ -39,7 +39,7 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
     testServer: Boolean = false,
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<BehaviourContextWithFSM<T>, Unit>
 ): TelegramBot = telegramBot(
     token,
     apiUrl,
@@ -76,7 +76,7 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSMAndStartLongPolling(
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
     testServer: Boolean = false,
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<BehaviourContextWithFSM<T>, Unit>
 ): Pair<TelegramBot, Job> {
     return telegramBot(
         token,