added useSequentialEventProcessing constructor paramter for Bloc constructor

Author: beyondeye

kbloc_app/src/main/java/com/beyondeye/kbloc_app/ABCCounterBloc.kt

@@ -13,6 +13,7 @@ class ABCCounterBloc(
     Bloc<MultiCounterEvent,
             ABCCounterState>(
         cscope, ABCCounterState(a= startCounters[0], b=startCounters[1],c=startCounters[2]),
+        true,
         true
     ) {
     init {

kbloc_app/src/main/java/com/beyondeye/kbloc_app/CounterBloc.kt

@@ -11,7 +11,7 @@ class SubtractionEvent(val value:Int):CounterEvent
 data class CounterState(val counter:Int=0)
 
 class CounterBloc(cscope: CoroutineScope, startCounter:Int=0): Bloc<CounterEvent, CounterState>(cscope,
-    CounterState(startCounter),false
+    CounterState(startCounter),false,true
 ) {
     init {
         on<IncrementEvent> { event, emit ->

kbloc_app/src/main/java/com/beyondeye/kbloc_app/MultiCounterBloc.kt

@@ -15,7 +15,7 @@ class MultiCounterBloc(
     Bloc<MultiCounterEvent,
             MultiCounterState>(
         cscope, MultiCounterState(counter = startCounters),
-        true
+        true,true
     ) {
     init {
         on<MultiAddEvent> { event, emit ->

kbloc_core/src/commonMain/kotlin/com/beyondeye/kbloc/core/bloc.kt

@@ -72,7 +72,20 @@ public abstract class Bloc<Event : Any, State : Any>
     /**
      * in the original dart code this is always false
      */
-    useReferenceEqualityForStateChanges: Boolean
+    useReferenceEqualityForStateChanges: Boolean,
+    /**
+     * flag that set change parallel/sequential behavior of event processing for a bloc
+     * in the original flutter_bloc events are processed in parallel by  default. This means
+     * it is possible to have race condition when multiple events are processed in parallel.
+     * So if multiple event handler will try to update the bloc state in parallel, not necessarily we will
+     * see the effect of all state changes from all event handler. This very problematic for complex bloc state
+     * (i.e. bloc state with more than one field that can change independently)
+     * With bloc with such complex bloc state. you should really use sequential event processing, unless
+     * you really know what you are doing.
+     * Note that if [BlocOverrides.current.eventTransformer] is defined that it will take precedence
+     * on what you specify with the flag [useSequentialEventProcessing]
+     */
+    useSequentialEventProcessing:Boolean,
 ) : BlocBase<State>(initialState, cscope, useReferenceEqualityForStateChanges), BlocEventSink<Event> {
 
     private var eventFlowJob:Job?=null
@@ -86,7 +99,7 @@ public abstract class Bloc<Event : Any, State : Any>
     private val _emitters:MutableList<_Emitter<State>> = mutableListOf()
     @PublishedApi
     internal val _eventTransformer:EventTransformer<Any> =
-    BlocOverrides.current?.eventTransformer ?: _defaultEventTransformer
+    BlocOverrides.current?.eventTransformer ?: if(useSequentialEventProcessing) EventTransformer_sequential() else EventTransformer_concurrent()
 
     init {
         _startEventHandlerJob()

kbloc_core/src/commonMain/kotlin/com/beyondeye/kbloc/core/bloc_overrides.kt

@@ -141,6 +141,7 @@ late final _defaultEventTransformer = (Stream events, EventMapper mapper) {
 *
 */
 // TODO change the default event transformer to flattenConcat from flattenMerge
+// NOTE that this exactly the same as EventTransformer_concurrent
 internal val _defaultEventTransformer: EventTransformer<Any> = { events: Flow<Any>, mapper: EventMapper<Any> ->
     events
         .map(mapper).flattenMerge()

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/async/async_bloc.kt

@@ -8,7 +8,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flatMapConcat
 import kotlinx.coroutines.flow.flatMapMerge
 
-class AsyncBloc(cscope: CoroutineScope) : Bloc<AsyncEvent,AsyncState>(cscope,AsyncState.initial(),false)
+class AsyncBloc(cscope: CoroutineScope) : Bloc<AsyncEvent,AsyncState>(cscope,AsyncState.initial(),false,false)
 {
     init {
         on<AsyncEvent>(transformer = { events,mapper-> events.asyncExpand(mapper) }) { event,emit ->

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/bloc_event_transformer_test.kt

@@ -52,7 +52,7 @@ suspend fun tick() {
 class CounterBloc(
     cscope: CoroutineScope,
     incrementTransformer: EventTransformer<Increment>?=null
-) : Bloc<CounterEvent, Int>(cscope, 0,false) {
+) : Bloc<CounterEvent, Int>(cscope, 0,false,false) {
     val onCalls= mutableListOf<CounterEvent>()
     val onEmitCalls= mutableListOf<CounterEvent>()
     init {

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/bloc_on_test.kt

@@ -39,7 +39,7 @@ class TestBloc(cscope:CoroutineScope,
                val onTestEventAA :onEvent<TestEventAA,TestState> = { _,_ -> },
                val onTestEventBA :onEvent<TestEventBA,TestState> = { _,_ -> },
 
-) : Bloc<TestEvent, TestState>(cscope, TestState(),false)
+) : Bloc<TestEvent, TestState>(cscope, TestState(),false,false)
 {
     init {
         on<TestEventA>(handler = onTestEventA)
@@ -49,14 +49,16 @@ class TestBloc(cscope:CoroutineScope,
         on<TestEvent>(handler = onTestEvent)
     }
 }
-class DuplicateHandlerBloc(cscope: CoroutineScope) : Bloc<TestEvent,TestState>(cscope, TestState(),false) {
+class DuplicateHandlerBloc(cscope: CoroutineScope) : Bloc<TestEvent,TestState>(cscope, TestState(),
+    false,false) {
     init {
         on<TestEvent> {_,_-> }
         on<TestEvent> {_,_-> }
     }
 }
 
-class MissingHandlerBloc(cscope: CoroutineScope) : Bloc<TestEvent,TestState>(cscope, TestState(),false) {
+class MissingHandlerBloc(cscope: CoroutineScope) : Bloc<TestEvent,TestState>(cscope, TestState(),
+    false,false) {
     init {
 
     }

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/complex/complex_bloc.kt

@@ -5,12 +5,14 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.stateIn
 import kotlin.time.Duration
 
 const private val _delay_ms:Long =100
 
-class ComplexBloc(cscope:CoroutineScope) : Bloc<ComplexEvent, ComplexState>(cscope,ComplexStateA(),false)
+class ComplexBloc(cscope:CoroutineScope) : Bloc<ComplexEvent, ComplexState>(cscope,ComplexStateA(),false,false)
 {
     init {
         on<ComplexEventA> { _,emit ->
@@ -29,6 +31,6 @@ class ComplexBloc(cscope:CoroutineScope) : Bloc<ComplexEvent, ComplexState>(csco
         }
     }
 
-    override val stream: Flow<ComplexState>
-        get() = super.stream.debounce(50)
+    override val stream: StateFlow<ComplexState>
+        get() = super.stream.debounce(50).stateIn(cscope)
  }

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/counter/counter_bloc.kt

@@ -18,7 +18,7 @@ class CounterBloc(cscope:CoroutineScope,
                   val onEventCallback: OnEventCallback?=null,
                   val onTransitionCallback: onTransitionCallback?=null,
                   val onErrorCallback: onErrorCallback?=null
-)            :Bloc<CounterEvent,Int>(cscope,0,false)
+)            :Bloc<CounterEvent,Int>(cscope,0,false,false)
 {
     init {
         on<CounterEvent> { event, emit ->

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/counter/counter_error_bloc.kt

@@ -8,7 +8,7 @@ import kotlinx.coroutines.CoroutineScope
  * NOTE: in kotlin there is no much difference between Error and Exception like in Dart
  * so [CounterErrorBloc] and [CounterExceptionBloc] are basically the same thing
  */
-class CounterErrorBloc(cscope:CoroutineScope) : Bloc<CounterEvent,Int>(cscope,0,false) {
+class CounterErrorBloc(cscope:CoroutineScope) : Bloc<CounterEvent,Int>(cscope,0,false,false) {
     init {
         on<CounterEvent> { event, emit ->
             _onCounterEvent(event,emit)

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/counter/counter_exception_bloc.kt

@@ -8,7 +8,7 @@ import kotlinx.coroutines.CoroutineScope
  * NOTE: in kotlin there is no much difference between Error and Exception like in Dart
  * so [CounterErrorBloc] and [CounterExceptionBloc] are basically the same thing
  */
-class CounterExceptionBloc(cscope: CoroutineScope) : Bloc<CounterEvent, Int>(cscope,0,false) {
+class CounterExceptionBloc(cscope: CoroutineScope) : Bloc<CounterEvent, Int>(cscope,0,false,false) {
     init {
         on<CounterEvent> { event, emit ->
             _onCounterEvent(event,emit)

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/counter/merge_bloc.kt

@@ -18,7 +18,8 @@ val customTransformer:EventTransformer<CounterEvent> = { events, mapper ->
 
 
 
-class MergeBloc(cscope:CoroutineScope,val  onTransitionCallback: onTransitionCallback?=null) : Bloc<CounterEvent, Int>(cscope,0,false) {
+class MergeBloc(cscope:CoroutineScope,val  onTransitionCallback: onTransitionCallback?=null) : Bloc<CounterEvent, Int>(cscope,0,
+    false,false) {
     init {
         on<CounterEvent>(transformer = customTransformer, handler = ::_onCounterEvent)
     }

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/counter/on_error_bloc.kt

@@ -11,7 +11,7 @@ import kotlinx.coroutines.CoroutineScope
 class OnErrorBloc(cscope: CoroutineScope,
                   val error: Throwable,
                   val onErrorCallback: (Throwable) -> Unit
-) : Bloc<CounterEvent, Int>(cscope, 0,false) {
+) : Bloc<CounterEvent, Int>(cscope, 0,false,false) {
     init {
         on<CounterEvent>(handler = ::_onCounterEvent)
     }

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/counter/on_event_error_bloc.kt

@@ -6,7 +6,7 @@ import kotlinx.coroutines.CoroutineScope
 
 class OnEventErrorBloc(cscope: CoroutineScope,
                   val exception: Exception,
-) : Bloc<CounterEvent, Int>(cscope, 0,false) {
+) : Bloc<CounterEvent, Int>(cscope, 0,false,false) {
     init {
         on<CounterEvent> { _,_-> }
     }

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/counter/on_exception_bloc.kt

@@ -11,7 +11,7 @@ import kotlinx.coroutines.CoroutineScope
 class OnExceptionBloc(cscope: CoroutineScope,
                       val exception: Exception,
                       val onErrorCallback: (Throwable) -> Unit
-) : Bloc<CounterEvent, Int>(cscope, 0,false) {
+) : Bloc<CounterEvent, Int>(cscope, 0,false,false) {
     init {
         on<CounterEvent>(handler = ::_onCounterEvent)
     }

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/counter/on_transition_error_bloc.kt

@@ -9,7 +9,7 @@ class OnTransitionErrorBloc(
     cscope: CoroutineScope,
     val error: Throwable,
     val onErrorCallback: onErrorCallback
-) : Bloc<CounterEvent, Int>(cscope, 0,false) {
+) : Bloc<CounterEvent, Int>(cscope, 0,false,false) {
     init {
         on<CounterEvent>(handler = ::_onCounterEvent)
     }

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/seeded/SeededBloc.kt

@@ -6,7 +6,7 @@ import kotlinx.coroutines.CoroutineScope
 class SeededBloc (
     val seed:Int, val states:List<Int>,
     cscope_stateUpdate: CoroutineScope, useReferenceEqualityForStateChanges: Boolean=false) :
-    Bloc<String, Int>(cscope_stateUpdate, seed, useReferenceEqualityForStateChanges) {
+    Bloc<String, Int>(cscope_stateUpdate, seed, useReferenceEqualityForStateChanges,false) {
     init {
         on<String>{ event, emit ->
             for (state in states) {

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/simple/SimpleBloc.kt

@@ -4,7 +4,7 @@ import com.beyondeye.kbloc.core.Bloc
 import kotlinx.coroutines.CoroutineScope
 
 class SimpleBloc (cscope_stateUpdate: CoroutineScope, useReferenceEqualityForStateChanges: Boolean=false) :
-    Bloc<Any, String>(cscope_stateUpdate, "", useReferenceEqualityForStateChanges) {
+    Bloc<Any, String>(cscope_stateUpdate, "", useReferenceEqualityForStateChanges,false) {
     init {
         on<String>{ _, emit ->
             emit("data")

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/stream/restartable_stream_bloc.kt

@@ -95,7 +95,8 @@ public fun Job.catchError(test:((Throwable)->Boolean)?=null,onError:(Throwable)-
     return this
 }
 
-class  RestartableStreamBloc(cscope:CoroutineScope,val inputEventsStream: Flow<Int>) :Bloc<RestartableStreamEvent,Int>(cscope,0,false) {
+class  RestartableStreamBloc(cscope:CoroutineScope,val inputEventsStream: Flow<Int>) :Bloc<RestartableStreamEvent,Int>(cscope,0,
+    false,false) {
     init {
         //    message = "Flow analogues of 'switchMap' are 'transformLatest', 'flatMapLatest' and 'mapLatest'",
         on<ForEach>(transformer = { events, mapper -> events.flatMapLatest(mapper) })

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/stream/stream_bloc.kt

@@ -13,7 +13,8 @@ class Subscribe : StreamEvent
 
 class OnData(val data:Int) :StreamEvent
 
-class StreamBloc(cscope:CoroutineScope, val inputEventsStream: Flow<Int>) :Bloc<StreamEvent,Int>(cscope,0,false) {
+class StreamBloc(cscope:CoroutineScope, val inputEventsStream: Flow<Int>) :Bloc<StreamEvent,Int>(cscope,0,
+    false,false) {
     private var _subscription: Job? = null
     init {
         //in the original code here there is on<StreamEvent> but it does not work that way, and it actually look like a bug

kbloc_core/src/commonTest/kotlin/com/beyondeye/kbloc/unawaited/unawaited_bloc.kt

@@ -9,7 +9,8 @@ class UnawaitedEvent
 class UnawaitedState
 
 class UnawaitedBloc(cscope:CoroutineScope) :
-    Bloc<UnawaitedEvent,UnawaitedState>(cscope, UnawaitedState(),false) {
+    Bloc<UnawaitedEvent,UnawaitedState>(cscope, UnawaitedState(),
+        false,false) {
     constructor(cscope: CoroutineScope,future:Deferred<Unit>):this(cscope) {
         on<UnawaitedEvent>{ event, emit ->
             //TODO the original code is