nautilus-binance 0.55.0

Binance exchange integration adapter for the Nautilus trading engine
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
125
126
127
128
129
130
131
132
133
134
135

#[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct AllowedSelfTradePreventionModes(pub u8);
impl AllowedSelfTradePreventionModes {
    #[inline]
    pub fn new(value: u8) -> Self {
        AllowedSelfTradePreventionModes(value)
    }

    #[inline]
    pub fn clear(&mut self) -> &mut Self {
        self.0 = 0;
        self
    }

    #[inline]
    pub fn get_none(&self) -> bool {
        0 != self.0 & (1 << 0)
    }

    #[inline]
    pub fn set_none(&mut self, value: bool) -> &mut Self {
        self.0 = if value {
            self.0 | (1 << 0)
        } else {
            self.0 & !(1 << 0)
        };
        self
    }

    #[inline]
    pub fn get_expire_taker(&self) -> bool {
        0 != self.0 & (1 << 1)
    }

    #[inline]
    pub fn set_expire_taker(&mut self, value: bool) -> &mut Self {
        self.0 = if value {
            self.0 | (1 << 1)
        } else {
            self.0 & !(1 << 1)
        };
        self
    }

    #[inline]
    pub fn get_expire_maker(&self) -> bool {
        0 != self.0 & (1 << 2)
    }

    #[inline]
    pub fn set_expire_maker(&mut self, value: bool) -> &mut Self {
        self.0 = if value {
            self.0 | (1 << 2)
        } else {
            self.0 & !(1 << 2)
        };
        self
    }

    #[inline]
    pub fn get_expire_both(&self) -> bool {
        0 != self.0 & (1 << 3)
    }

    #[inline]
    pub fn set_expire_both(&mut self, value: bool) -> &mut Self {
        self.0 = if value {
            self.0 | (1 << 3)
        } else {
            self.0 & !(1 << 3)
        };
        self
    }

    #[inline]
    pub fn get_decrement(&self) -> bool {
        0 != self.0 & (1 << 4)
    }

    #[inline]
    pub fn set_decrement(&mut self, value: bool) -> &mut Self {
        self.0 = if value {
            self.0 | (1 << 4)
        } else {
            self.0 & !(1 << 4)
        };
        self
    }

    #[inline]
    pub fn get_transfer(&self) -> bool {
        0 != self.0 & (1 << 5)
    }

    #[inline]
    pub fn set_transfer(&mut self, value: bool) -> &mut Self {
        self.0 = if value {
            self.0 | (1 << 5)
        } else {
            self.0 & !(1 << 5)
        };
        self
    }

    #[inline]
    pub fn get_non_representable(&self) -> bool {
        0 != self.0 & (1 << 7)
    }

    #[inline]
    pub fn set_non_representable(&mut self, value: bool) -> &mut Self {
        self.0 = if value {
            self.0 | (1 << 7)
        } else {
            self.0 & !(1 << 7)
        };
        self
    }
}
impl core::fmt::Debug for AllowedSelfTradePreventionModes {
    #[inline]
    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(
            fmt,
            "AllowedSelfTradePreventionModes[none(0)={},expire_taker(1)={},expire_maker(2)={},expire_both(3)={},decrement(4)={},transfer(5)={},non_representable(7)={}]",
            self.get_none(),
            self.get_expire_taker(),
            self.get_expire_maker(),
            self.get_expire_both(),
            self.get_decrement(),
            self.get_transfer(),
            self.get_non_representable(),
        )
    }
}