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
116
117
118
119
120
121
122
123
124

// 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.


// Internal Dependencies ------------------------------------------------------
use ::Config;

/// A structure containing stats data average of the course of one second.
#[derive(Debug, PartialEq, Copy, Clone)]
pub struct Stats {

    /// Average number of bytes received over the last second.
    pub bytes_sent: u32,

    /// Average number of bytes received over the last second.
    pub bytes_received: u32

}

impl Stats {
    pub fn reset(&mut self) {
        self.bytes_sent = 0;
        self.bytes_received = 0;
    }
}

impl Default for Stats {
    fn default() -> Stats {
        Stats {
            bytes_sent: 0,
            bytes_received: 0
        }
    }
}

/// Structure to keep track of per second average stats of a Client or Server.
///
/// Uses a list of buckets and caluclates the average each time a new value is
/// pushed into the bucket list `O(1)`.
#[derive(Debug)]
pub struct StatsCollector {

    /// Internal tick value
    tick: u64,

    /// The collectors's configuration
    config: Config,

    /// Internal stat buckets for O(1) average calculation
    buckets: Vec<Stats>,

    /// Internal stat average for the current tick
    averages: Stats

}

impl StatsCollector {

    /// Creates a new stats object which averages incoming data over the given
    /// number of ticks per second.
    pub fn new(config: Config) -> StatsCollector {
        StatsCollector {
            tick: 0,
            config: config,
            buckets: (0..config.send_rate + 1).map(|_| {
                Stats::default()

            }).collect::<Vec<Stats>>(),
            averages: Stats::default()
        }
    }

    /// Overrides the collector's existing configuration.
    pub fn set_config(&mut self, config: Config) {
        self.config = config;
        self.buckets = (0..config.send_rate + 1).map(|_| {
            Stats::default()

        }).collect::<Vec<Stats>>()
    }

    /// Sets the number of bytes sent for the current tick.
    pub fn set_bytes_sent(&mut self, bytes: u32) {
        let old_index = (self.tick as i32 + 1) % (self.config.send_rate + 1) as i32;
        let old_bytes = self.buckets[old_index as usize].bytes_sent;
        self.averages.bytes_sent = (self.averages.bytes_sent - old_bytes) + bytes;
        self.buckets[self.tick as usize].bytes_sent = bytes;
    }

    /// Sets the number of bytes received for the current tick.
    pub fn set_bytes_received(&mut self, bytes: u32) {
        let old_index = (self.tick as i32 + 1) % (self.config.send_rate + 1) as i32;
        let old_bytes = self.buckets[old_index as usize].bytes_received;
        self.averages.bytes_received = (self.averages.bytes_received - old_bytes) + bytes;
        self.buckets[self.tick as usize].bytes_received = bytes;
    }

    /// Steps the internal tick value used for average calculation.
    pub fn tick(&mut self) {
        self.tick = (self.tick + 1) % (self.config.send_rate + 1);
    }

    /// Returns the calculated averages from the last tick.
    pub fn average(&self) -> Stats {
        self.averages
    }

    /// Resets the internal data used for average calculation, but does not
    /// reset the last calculated averages.
    pub fn reset(&mut self) {
        self.averages.bytes_sent = 0;
        self.averages.bytes_received = 0;
        for d in &mut self.buckets {
            d.reset();
        }
    }

}