discortp 0.6.0

Lightweight, flexible Real-time Transport Protocol (RTP) parsing 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
125
126

//! Utility types for wrapping arithmetic, compatible with pnet.

use core::{
	num::Wrapping,
	ops::{Add, AddAssign, Sub, SubAssign},
};
use pnet_macros_support::{
	packet::PrimitiveValues,
	types::{u16be, u32be},
};

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub struct Wrap16(pub Wrapping<u16>);

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub struct Wrap32(pub Wrapping<u32>);

impl Wrap16 {
	#[must_use]
	pub fn new(v: u16be) -> Self {
		Self(Wrapping(v))
	}
}

impl From<Wrap16> for u16 {
	fn from(val: Wrap16) -> Self {
		(val.0).0
	}
}

impl From<u16> for Wrap16 {
	fn from(val: u16) -> Self {
		Wrap16(Wrapping(val))
	}
}

impl PrimitiveValues for Wrap16 {
	type T = (u16be,);

	fn to_primitive_values(&self) -> Self::T {
		((*self).into(),)
	}
}

impl Add<u16> for Wrap16 {
	type Output = Self;

	fn add(self, other: u16) -> Self::Output {
		Wrap16(self.0 + Wrapping(other))
	}
}

impl AddAssign<u16> for Wrap16 {
	fn add_assign(&mut self, other: u16) {
		self.0 += Wrapping(other);
	}
}

impl Sub<u16> for Wrap16 {
	type Output = Self;

	fn sub(self, other: u16) -> Self::Output {
		Wrap16(self.0 - Wrapping(other))
	}
}

impl SubAssign<u16> for Wrap16 {
	fn sub_assign(&mut self, other: u16) {
		self.0 -= Wrapping(other);
	}
}

impl Wrap32 {
	#[must_use]
	pub fn new(v: u32be) -> Self {
		Self(Wrapping(v))
	}
}

impl From<Wrap32> for u32 {
	fn from(val: Wrap32) -> Self {
		(val.0).0
	}
}

impl From<u32> for Wrap32 {
	fn from(val: u32) -> Self {
		Wrap32(Wrapping(val))
	}
}

impl PrimitiveValues for Wrap32 {
	type T = (u32be,);

	fn to_primitive_values(&self) -> Self::T {
		((*self).into(),)
	}
}

impl Add<u32> for Wrap32 {
	type Output = Self;

	fn add(self, other: u32) -> Self::Output {
		Wrap32(self.0 + Wrapping(other))
	}
}

impl AddAssign<u32> for Wrap32 {
	fn add_assign(&mut self, other: u32) {
		self.0 += Wrapping(other);
	}
}

impl Sub<u32> for Wrap32 {
	type Output = Self;

	fn sub(self, other: u32) -> Self::Output {
		Wrap32(self.0 - Wrapping(other))
	}
}

impl SubAssign<u32> for Wrap32 {
	fn sub_assign(&mut self, other: u32) {
		self.0 -= Wrapping(other);
	}
}