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
136
137
138
139
140
141
142
143
144
145
146
147
|
use crate::proxy::Proxy;
/// Used by LightstreamerClient to provide an extra connection properties data object.
/// Data struct that contains the policy settings used to connect to a Lightstreamer Server.
/// An instance of this struct is attached to every LightstreamerClient as connection_options.
pub struct ConnectionOptions {
content_length: Option<usize>,
first_retry_max_delay: Option<u64>,
forced_transport: Option<String>,
http_extra_headers: Option<Vec<(String, String)>>,
http_extra_headers_on_session_creation_only: Option<bool>,
idle_timeout: Option<u64>,
keepalive_interval: Option<u64>,
polling_interval: Option<u64>,
proxy: Option<Proxy>,
real_max_bandwidth: Option<u64>,
reconnect_timeout: Option<u64>,
requested_max_bandwidth: Option<u64>,
retry_delay: Option<u64>,
reverse_heartbeat_interval: Option<u64>,
server_instance_address_ignored: Option<bool>,
session_recovery_timeout: Option<u64>,
slowing_enabled: Option<bool>,
stalled_timeout: Option<u64>,
}
impl ConnectionOptions {
/// Creates a new ConnectionOptions object with default values.
pub fn new() -> ConnectionOptions {
ConnectionOptions::default()
}
/// Sets the content length.
pub fn set_content_length(&mut self, content_length: usize) {
self.content_length = Some(content_length);
}
/// Sets the first retry max delay.
pub fn set_first_retry_max_delay(&mut self, first_retry_max_delay: u64) {
self.first_retry_max_delay = Some(first_retry_max_delay);
}
/// Sets the forced transport.
pub fn set_forced_transport(&mut self, forced_transport: String) {
self.forced_transport = Some(forced_transport);
}
/// Sets the HTTP extra headers.
pub fn set_http_extra_headers(&mut self, http_extra_headers: Vec<(String, String)>) {
self.http_extra_headers = Some(http_extra_headers);
}
/// Sets the HTTP extra headers on session creation only.
pub fn set_http_extra_headers_on_session_creation_only(&mut self, http_extra_headers_on_session_creation_only: bool) {
self.http_extra_headers_on_session_creation_only = Some(http_extra_headers_on_session_creation_only);
}
/// Sets the idle timeout.
pub fn set_idle_timeout(&mut self, idle_timeout: u64) {
self.idle_timeout = Some(idle_timeout);
}
/// Sets the keepalive interval.
pub fn set_keepalive_interval(&mut self, keepalive_interval: u64) {
self.keepalive_interval = Some(keepalive_interval);
}
/// Sets the polling interval.
pub fn set_polling_interval(&mut self, polling_interval: u64) {
self.polling_interval = Some(polling_interval);
}
/// Sets the proxy.
pub fn set_proxy(&mut self, proxy: Proxy) {
self.proxy = Some(proxy);
}
/// Sets the real max bandwidth.
pub fn set_real_max_bandwidth(&mut self, real_max_bandwidth: u64) {
self.real_max_bandwidth = Some(real_max_bandwidth);
}
/// Sets the reconnect timeout.
pub fn set_reconnect_timeout(&mut self, reconnect_timeout: u64) {
self.reconnect_timeout = Some(reconnect_timeout);
}
/// Sets the requested max bandwidth.
pub fn set_requested_max_bandwidth(&mut self, requested: u64) {
self.requested_max_bandwidth = Some(requested);
}
/// Sets the retry delay.
pub fn set_retry_delay(&mut self, retry_delay: u64) {
self.retry_delay = Some(retry_delay);
}
/// Sets the reverse heartbeat interval.
pub fn set_reverse_heartbeat_interval(&mut self, reverse_heartbeat_interval: u64) {
self.reverse_heartbeat_interval = Some(reverse_heartbeat_interval);
}
/// Sets the server instance address ignored.
pub fn set_server_instance_address_ignored(&mut self, server_instance_address_ignored: bool) {
self.server_instance_address_ignored = Some(server_instance_address_ignored);
}
/// Sets the session recovery timeout.
pub fn set_session_recovery_timeout(&mut self, session_recovery_timeout: u64) {
self.session_recovery_timeout = Some(session_recovery_timeout);
}
/// Sets the slowing enabled.
pub fn set_slowing_enabled(&mut self, slowing_enabled: bool) {
self.slowing_enabled = Some(slowing_enabled);
}
/// Sets the stalled timeout.
pub fn set_stalled_timeout(&mut self, stalled_timeout: u64) {
self.stalled_timeout = Some(stalled_timeout);
}
}
impl Default for ConnectionOptions {
fn default() -> Self {
ConnectionOptions {
content_length: None,
first_retry_max_delay: Some(100),
forced_transport: None,
http_extra_headers: None,
http_extra_headers_on_session_creation_only: Some(false),
idle_timeout: Some(19000),
keepalive_interval: Some(0),
polling_interval: Some(0),
proxy: None,
real_max_bandwidth: None,
reconnect_timeout: Some(3000),
requested_max_bandwidth: None,
retry_delay: Some(4000),
reverse_heartbeat_interval: Some(0),
server_instance_address_ignored: Some(false),
session_recovery_timeout: Some(15000),
slowing_enabled: Some(false),
stalled_timeout: Some(2000),
}
}
}
|
