betex 0.35.0

Betfair / Prediction Market Exchange
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

macro_rules! impl_handler_tuple {
    ($barrier:ident => $($handler_ty:ident $handler_var:ident),+ $(,)?) => {
        impl<$($handler_ty),+> HandlerTuple for ($(RegisteredHandler<$handler_ty>,)+)
        where
            $($handler_ty: EventHandler<EngineEvent> + Send + 'static,)+
        {
            fn startup_recovery_plan(&self, snapshot_seq: u64) -> StartupRecoveryPlan {
                let ($($handler_var,)+) = self;
                let mut plan = StartupRecoveryPlan {
                    scan_floor: snapshot_seq,
                    required_through_seq: None,
                };
                $(
                    $handler_var.update_recovery_plan(snapshot_seq, &mut plan);
                )+
                plan
            }

            fn validate_cursors(
                &self,
                incomplete_tail: Option<IncompleteTailTx>,
                recoverable_head: u64,
            ) -> anyhow::Result<()> {
                let ($($handler_var,)+) = self;
                $(
                    $handler_var.validate_cursor(incomplete_tail, recoverable_head)?;
                )+
                Ok(())
            }

            fn replay_event(
                &mut self,
                event: &JournalEvent,
                sequence: disrupt_rs::Sequence,
                end_of_batch: bool,
                replay_event: &mut Option<EngineEvent>,
            ) {
                let ($($handler_var,)+) = self;
                $(
                    $handler_var.replay_event(event, sequence, end_of_batch, replay_event);
                )+
            }
        }

        impl<W, $($handler_ty),+> AttachHandlers<W> for ($(RegisteredHandler<$handler_ty>,)+)
        where
            W: WaitStrategy + Clone + Send + 'static,
            $($handler_ty: EventHandler<EngineEvent> + Send + 'static,)+
        {
            type Barrier = $barrier;

            fn attach(
                self,
                builder: NcBuilder<W>,
            ) -> disrupt_rs::SingleProducer<EngineEvent, Self::Barrier, W> {
                let ($($handler_var,)+) = self;
                $(
                    let builder = configure_handler_builder(builder, $handler_var.core_settings)
                        .handle_events_with($handler_var.handler);
                )+
                builder.build()
            }
        }

        impl<W, $($handler_ty),+> AttachHandlersWithPoller<W> for ($(RegisteredHandler<$handler_ty>,)+)
        where
            W: WaitStrategy + Clone + Send + 'static,
            $($handler_ty: EventHandler<EngineEvent> + Send + 'static,)+
        {
            fn attach_with_poller(self, builder: NcBuilder<W>) -> AttachWithPollerResult<W> {
                let ($($handler_var,)+) = self;
                $(
                    let builder = configure_handler_builder(builder, $handler_var.core_settings)
                        .handle_events_with($handler_var.handler);
                )+
                let (poller, builder) = builder.event_poller();
                (poller, builder.build())
            }
        }
    };
}

pub(crate) use impl_handler_tuple;

macro_rules! impl_many_handler_builder {
    ($(($($handler_ty:ident $handler_var:ident),+) => $next_ty:ident),+ $(,)?) => {
        $(
            impl<W, $($handler_ty),+> EngineBuilder<McBuilder<W>, W, ($(RegisteredHandler<$handler_ty>,)+)>
            where
                W: WaitStrategy + Clone + Send + 'static,
                $($handler_ty: EventHandler<EngineEvent> + Send + 'static,)+
            {
                pub fn build(self) -> anyhow::Result<Engine> {
                    build_engine_with_handlers(self)
                }

                pub fn build_with_poller(
                    self,
                ) -> anyhow::Result<EngineWithPoller<W>> {
                    build_engine_with_handlers_and_poller(self)
                }

                pub fn register_handler<$next_ty>(
                    self,
                    handler: $next_ty,
                    recovery: HandlerRecovery,
                    core_settings: CoreSettings,
                ) -> EngineBuilder<McBuilder<W>, W, ($(RegisteredHandler<$handler_ty>,)+ RegisteredHandler<$next_ty>,)>
                where
                    $next_ty: EventHandler<EngineEvent> + Send + 'static,
                {
                    self.map_handlers::<McBuilder<W>, _>(|($($handler_var,)+)| {
                        (
                            $($handler_var,)+
                            RegisteredHandler::new(handler, recovery, core_settings),
                        )
                    })
                }
            }
        )+
    };
}

pub(crate) use impl_many_handler_builder;