openpit 0.5.0

Embeddable pre-trade risk SDK
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

// Copyright The Pit Project Owners. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Please see https://github.com/openpitkit and the OWNERS file for details.

//! Engine type aggregate.

use std::marker::PhantomData;

use super::sync_mode::SyncMode;

/// Aggregates the four type-level choices of an [`Engine`](crate::Engine)
/// instance into a single trait, so that engine code carries one generic
/// parameter instead of four.
///
/// The trait is open. The engine builder chain composes it automatically via
/// [`EngineTraitOf`] - end users rarely implement `EngineTrait` directly.
/// Implement it manually only when wiring a non-standard engine type into
/// another layer.
pub trait EngineTrait: 'static {
    /// Order contract type used by `start_pre_trade`.
    type Order: 'static;
    /// Execution-report contract type used by `apply_execution_report`.
    type ExecutionReport: 'static;
    /// Account-adjustment contract type used by `apply_account_adjustment`.
    type AccountAdjustment: 'static;
    /// Synchronization mode (see [`SyncMode`]).
    type Sync: SyncMode;
}

/// Concrete [`EngineTrait`] implementation composed from the four individual
/// type choices.
///
/// The engine builder chain produces this type at `build()` time so that the
/// resulting `Engine` value has a single, fully-determined [`EngineTrait`]
/// parameter.
pub struct EngineTraitOf<Order, ExecutionReport, AccountAdjustment, Sync>(
    PhantomData<(Order, ExecutionReport, AccountAdjustment, Sync)>,
);

impl<Order, ExecutionReport, AccountAdjustment, Sync> EngineTrait
    for EngineTraitOf<Order, ExecutionReport, AccountAdjustment, Sync>
where
    Order: 'static,
    ExecutionReport: 'static,
    AccountAdjustment: 'static,
    Sync: SyncMode,
{
    type Order = Order;
    type ExecutionReport = ExecutionReport;
    type AccountAdjustment = AccountAdjustment;
    type Sync = Sync;
}