Flows Enumeration Reference


                    
                    
                    ExecuteStrategy

Undocumented

Declaration

Swift

public enum ExecuteStrategy


                    
                    
                    use(_:when:block:)

Undocumented

Declaration

Swift

public static func use<Root: UIViewController>(_ flows: [Flow],
                                               when strategy: ExecuteStrategy,
                                               block: @escaping ([Root]) -> Void)


                    
                    
                    use(_:_:_:_:_:when:block:)

Allow to be triggered etiher when Flows given as parameters are ready to be displayed or right after their instantiation Once it is the case, the block is executed

Declaration

Swift

public static func use<Root1, Root2, Root3, Root4, Root5>(_ flow1: Flow,
                                                          _ flow2: Flow,
                                                          _ flow3: Flow,
                                                          _ flow4: Flow,
                                                          _ flow5: Flow,
                                                          when strategy: ExecuteStrategy,
                                                          block: @escaping (
    _ flow1Root: Root1,
    _ flow2Root: Root2,
    _ flow3Root: Root3,
    _ flow4Root: Root4,
    _ flow5Root: Root5) -> Void)
    where
    Root1: UIViewController,
    Root2: UIViewController,
    Root3: UIViewController,
    Root4: UIViewController,
    Root5: UIViewController

Parameters

`flow1`	first Flow to be observed
`flow2`	second Flow to be observed
`flow3`	third Flow to be observed
`flow4`	fourth Flow to be observed
`flow5`	fifth Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    use(_:_:_:_:when:block:)

Allow to be triggered etiher when Flows given as parameters are ready to be displayed or right after their instantiation Once it is the case, the block is executed

Declaration

Swift

public static func use<Root1, Root2, Root3, Root4>(_ flow1: Flow,
                                                   _ flow2: Flow,
                                                   _ flow3: Flow,
                                                   _ flow4: Flow,
                                                   when strategy: ExecuteStrategy,
                                                   block: @escaping (
    _ flow1Root: Root1,
    _ flow2Root: Root2,
    _ flow3Root: Root3,
    _ flow4Root: Root4) -> Void) where
    Root1: UIViewController,
    Root2: UIViewController,
    Root3: UIViewController,
    Root4: UIViewController

Parameters

`flow1`	first Flow to be observed
`flow2`	second Flow to be observed
`flow3`	third Flow to be observed
`flow4`	fourth Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    use(_:_:_:when:block:)

Allow to be triggered etiher when Flows given as parameters are ready to be displayed or right after their instantiation Once it is the case, the block is executed

Declaration

Swift

public static func use<Root1, Root2, Root3>(_ flow1: Flow,
                                            _ flow2: Flow,
                                            _ flow3: Flow,
                                            when strategy: ExecuteStrategy,
                                            block: @escaping (
    _ flow1Root: Root1,
    _ flow2Root: Root2,
    _ flow3Root: Root3) -> Void) where
    Root1: UIViewController,
    Root2: UIViewController,
    Root3: UIViewController

Parameters

`flow1`	first Flow to be observed
`flow2`	second Flow to be observed
`flow3`	third Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    use(_:_:when:block:)

Allow to be triggered etiher when Flows given as parameters are ready to be displayed or right after their instantiation Once it is the case, the block is executed

Declaration

Swift

public static func use<Root1, Root2>(_ flow1: Flow,
                                     _ flow2: Flow,
                                     when strategy: ExecuteStrategy,
                                     block: @escaping (
    _ flow1Root: Root1,
    _ flow2Root: Root2) -> Void) where
    Root1: UIViewController,
    Root2: UIViewController

Parameters

`flow1`	first Flow to be observed
`flow2`	second Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    use(_:when:block:)

Allow to be triggered etiher when Flows given as parameters are ready to be displayed or right after their instantiation Once it is the case, the block is executed

Declaration

Swift

public static func use<Root>(_ flow: Flow,
                             when strategy: ExecuteStrategy,
                             block: @escaping (_ flowRoot: Root) -> Void)
    where
    Root: UIViewController

Parameters

`flow1`	first Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    whenReady(flows:block:)

Allow to be triggered only when Flows given as parameters are ready to be displayed. Once it is the case, the block is executed

Declaration

Swift

@available(*, deprecated, message: "You should use Flows.use(﹚")
static func whenReady<RootType: UIViewController>(flows: [Flow],
                                                  block: @escaping ([RootType]) -> Void)

Parameters

`flows`	Flow(s) to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    whenReady(flow1:flow2:flow3:flow4:flow5:block:)

Allow to be triggered only when Flows given as parameters are ready to be displayed. Once it is the case, the block is executed

Declaration

Swift

@available(*, deprecated, message: "You should use Flows.use(﹚")
static func whenReady<RootType1, RootType2, RootType3, RootType4, RootType5>(flow1: Flow,
                                                                             flow2: Flow,
                                                                             flow3: Flow,
                                                                             flow4: Flow,
                                                                             flow5: Flow,
                                                                             block: @escaping (_ flow1Root: RootType1,
    _ flow2Root: RootType2,
    _ flow3Root: RootType3,
    _ flow4Root: RootType4,
    _ flow5Root: RootType5) -> Void)
    where
    RootType1: UIViewController,
    RootType2: UIViewController,
    RootType3: UIViewController,
    RootType4: UIViewController,
    RootType5: UIViewController

Parameters

`flow1`	first Flow to be observed
`flow2`	second Flow to be observed
`flow3`	third Flow to be observed
`flow4`	fourth Flow to be observed
`flow5`	fifth Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    whenReady(flow1:flow2:flow3:flow4:block:)

Allow to be triggered only when Flows given as parameters are ready to be displayed. Once it is the case, the block is executed

Declaration

Swift

@available(*, deprecated, message: "You should use Flows.use(﹚")
static func whenReady<RootType1, RootType2, RootType3, RootType4>(flow1: Flow,
                                                                  flow2: Flow,
                                                                  flow3: Flow,
                                                                  flow4: Flow,
                                                                  block: @escaping (_ flow1Root: RootType1,
    _ flow2Root: RootType2,
    _ flow3Root: RootType3,
    _ flow4Root: RootType4) -> Void)
    where
    RootType1: UIViewController,
    RootType2: UIViewController,
    RootType3: UIViewController,
    RootType4: UIViewController

Parameters

`flow1`	first Flow to be observed
`flow2`	second Flow to be observed
`flow3`	third Flow to be observed
`flow4`	fourth Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    whenReady(flow1:flow2:flow3:block:)

Allow to be triggered only when Flows given as parameters are ready to be displayed. Once it is the case, the block is executed

Declaration

Swift

@available(*, deprecated, message: "You should use Flows.use(﹚")
static func whenReady<RootType1, RootType2, RootType3>(flow1: Flow,
                                                       flow2: Flow,
                                                       flow3: Flow,
                                                       block: @escaping (_ flow1Root: RootType1,
    _ flow2Root: RootType2,
    _ flow3Root: RootType3) -> Void)
    where
    RootType1: UIViewController,
    RootType2: UIViewController,
    RootType3: UIViewController

Parameters

`flow1`	first Flow to be observed
`flow2`	second Flow to be observed
`flow3`	third Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    whenReady(flow1:flow2:block:)

Allow to be triggered only when Flows given as parameters are ready to be displayed. Once it is the case, the block is executed

Declaration

Swift

@available(*, deprecated, message: "You should use Flows.use(﹚")
static func whenReady<RootType1: UIViewController, RootType2: UIViewController>(flow1: Flow,
                                                                                flow2: Flow,
                                                                                block: @escaping (_ flow1Root: RootType1,
    _ flow2Root: RootType2) -> Void)

Parameters

`flow1`	first Flow to be observed
`flow2`	second Flow to be observed
`block`	block to execute whenever the Flows are ready to use


                    
                    
                    whenReady(flow1:block:)

Allow to be triggered only when Flow given as parameters is ready to be displayed. Once it is the case, the block is executed

Declaration

Swift

@available(*, deprecated, message: "You should use Flows.use(﹚")
static func whenReady<RootType: UIViewController>(flow1: Flow,
                                                  block: @escaping (_ flowRoot1: RootType) -> Void)

Parameters

`flow1`	Flow to be observed
`block`	block to execute whenever the Flow is ready to use