cobalt 0.22.0

Low level, UDP based networking library.
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

// Copyright (c) 2015-2017 Ivo Wetzel

// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.


// STD Dependencies -----------------------------------------------------------
use std::time::Duration;


/// Structure defining connection and message configuration options.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Config {

    /// Number of packets send per second. Default is `30`.
    pub send_rate: u64,

    /// Maximum bytes that can be received / send in one packet. Default
    /// `1400`.
    pub packet_max_size: usize,

    /// 32-Bit Protocol ID used to identify UDP related packets. Default is
    /// `[1, 2, 3, 4]`.
    pub protocol_header: [u8; 4],

    /// Maximum roundtrip-time in milliseconds before a packet is considered
    /// lost. Default is `1000`.
    pub packet_drop_threshold: Duration,

    /// Maximum time in milliseconds until the first packet must be received
    /// before a connection attempt fails. Default is `100`.
    pub connection_init_threshold: Duration,

    /// Maximum time in milliseconds between any two packets before the
    /// connection gets dropped. Default is `1000`.
    pub connection_drop_threshold: Duration,

    /// Maximum time in milliseconds to wait for remote confirmation after
    /// programmatically closing a connection. Default is `150`.
    pub connection_closing_threshold: Duration,

    /// The percent of available packet bytes to use when serializing
    /// `MessageKind::Instant` into a packet via a `MessageQueue`.
    pub message_quota_instant: f32,

    /// The percent of available packet bytes to use when serializing
    /// `MessageKind::Reliable` into a packet via a `MessageQueue`.
    pub message_quota_reliable: f32,

    /// The percent of available packet bytes to use when serializing
    /// `MessageKind::Ordered` into a packet via a `MessageQueue`.
    pub message_quota_ordered: f32,

    /// Whether to keep track of ticks which exceed their maximum running time
    /// and speed up successive ticks in order to keep the desired target
    /// `send_rate` stable.
    ///
    /// Each tick has a limit of the number of milliseconds in can take before
    /// the `send_rate` drops below the specified ticks per second
    /// target (`1000 / send_rate` milliseconds). Ticks which fall below this
    /// threshold will normally sleep for the remaining amount of time.
    ///
    /// Ticks which exceed this threshold will normally cause the `send_rate`
    /// to drop below the target; however, with `tick_overflow_recovery`
    /// enabled any tick which falls below the threshold will give up some of
    /// its remaining sleep time in order to allow the `send_rate` to catch up
    /// again.
    ///
    /// How much of each tick's sleep time is used for speedup purposes is
    /// determined by the value of `tick_overflow_recovery`.
    ///
    /// Default is `true`.
    pub tick_overflow_recovery: bool,

    /// Determines how much of each tick's sleep time may be used to reduce the
    /// current tick overflow time in order to smooth out the `send_rate`.
    ///
    /// Values must be in the range of `0.0` to `1.0` where `0.25` would be a
    /// quarter of the tick's sleep time.
    ///
    /// Example: For a `send_rate` of `30` with a maximum sleep time of `33.33`
    /// milliseconds, a `tick_overflow_recovery_rate` value of `0.5` would
    /// allow up to `16.66` milliseconds of sleep to be skipped.
    ///
    /// Values smaller than `0.0` or bigger than `1.0` will have no effect.
    ///
    /// Default is `1.0`.
    pub tick_overflow_recovery_rate: f32

}

impl Default for Config {

    fn default() -> Config {
        Config {
            send_rate: 30,
            protocol_header: [1, 2, 3, 4],
            packet_max_size: 1400,
            packet_drop_threshold: Duration::from_millis(1000),
            connection_init_threshold: Duration::from_millis(100),
            connection_drop_threshold: Duration::from_millis(1000),
            connection_closing_threshold: Duration::from_millis(150),
            message_quota_instant: 60.0,
            message_quota_reliable: 20.0,
            message_quota_ordered: 20.0,
            tick_overflow_recovery: true,
            tick_overflow_recovery_rate: 1.0
        }
    }

}