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
148
149
150
151
152
153
154
155
156
|
/*
* Copyright 2019 The Chromium Authors. All rights reserved.
* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef NET_DCSCTP_PUBLIC_TYPES_H_
#define NET_DCSCTP_PUBLIC_TYPES_H_
#include <cstdint>
#include <limits>
#include "api/units/time_delta.h"
#include "rtc_base/strong_alias.h"
namespace dcsctp {
// Stream Identifier
using StreamID = webrtc::StrongAlias<class StreamIDTag, uint16_t>;
// Payload Protocol Identifier (PPID)
using PPID = webrtc::StrongAlias<class PPIDTag, uint32_t>;
// Timeout Identifier
using TimeoutID = webrtc::StrongAlias<class TimeoutTag, uint64_t>;
// Indicates if a message is allowed to be received out-of-order compared to
// other messages on the same stream.
using IsUnordered = webrtc::StrongAlias<class IsUnorderedTag, bool>;
// Stream priority, where higher values indicate higher priority. The meaning of
// this value and how it's used depends on the stream scheduler.
using StreamPriority = webrtc::StrongAlias<class StreamPriorityTag, uint16_t>;
// Duration, as milliseconds. Overflows after 24 days.
class DurationMs : public webrtc::StrongAlias<class DurationMsTag, int32_t> {
public:
constexpr explicit DurationMs(const UnderlyingType& v)
: webrtc::StrongAlias<class DurationMsTag, int32_t>(v) {}
constexpr explicit DurationMs(webrtc::TimeDelta v)
: webrtc::StrongAlias<class DurationMsTag, int32_t>(
v.IsInfinite() ? InfiniteDuration() : DurationMs(v.ms())) {}
static constexpr DurationMs InfiniteDuration() {
return DurationMs(std::numeric_limits<int32_t>::max());
}
// Convenience methods for working with time.
constexpr DurationMs& operator+=(DurationMs d) {
value_ += d.value_;
return *this;
}
constexpr DurationMs& operator-=(DurationMs d) {
value_ -= d.value_;
return *this;
}
template <typename T>
constexpr DurationMs& operator*=(T factor) {
value_ *= factor;
return *this;
}
constexpr webrtc::TimeDelta ToTimeDelta() const {
return *this == DurationMs::InfiniteDuration()
? webrtc::TimeDelta::PlusInfinity()
: webrtc::TimeDelta::Millis(value_);
}
};
constexpr inline DurationMs operator+(DurationMs lhs, DurationMs rhs) {
return lhs += rhs;
}
constexpr inline DurationMs operator-(DurationMs lhs, DurationMs rhs) {
return lhs -= rhs;
}
template <typename T>
constexpr inline DurationMs operator*(DurationMs lhs, T rhs) {
return lhs *= rhs;
}
template <typename T>
constexpr inline DurationMs operator*(T lhs, DurationMs rhs) {
return rhs *= lhs;
}
constexpr inline int32_t operator/(DurationMs lhs, DurationMs rhs) {
return lhs.value() / rhs.value();
}
// Represents time, in milliseconds since a client-defined epoch.
class TimeMs : public webrtc::StrongAlias<class TimeMsTag, int64_t> {
public:
constexpr explicit TimeMs(const UnderlyingType& v)
: webrtc::StrongAlias<class TimeMsTag, int64_t>(v) {}
// Convenience methods for working with time.
constexpr TimeMs& operator+=(DurationMs d) {
value_ += *d;
return *this;
}
constexpr TimeMs& operator-=(DurationMs d) {
value_ -= *d;
return *this;
}
static constexpr TimeMs InfiniteFuture() {
return TimeMs(std::numeric_limits<int64_t>::max());
}
};
constexpr inline TimeMs operator+(TimeMs lhs, DurationMs rhs) {
return lhs += rhs;
}
constexpr inline TimeMs operator+(DurationMs lhs, TimeMs rhs) {
return rhs += lhs;
}
constexpr inline TimeMs operator-(TimeMs lhs, DurationMs rhs) {
return lhs -= rhs;
}
constexpr inline DurationMs operator-(TimeMs lhs, TimeMs rhs) {
return DurationMs(*lhs - *rhs);
}
// The maximum number of times the socket should attempt to retransmit a
// message which fails the first time in unreliable mode.
class MaxRetransmits
: public webrtc::StrongAlias<class MaxRetransmitsTag, uint16_t> {
public:
constexpr explicit MaxRetransmits(const UnderlyingType& v)
: webrtc::StrongAlias<class MaxRetransmitsTag, uint16_t>(v) {}
// There should be no limit - the message should be sent reliably.
static constexpr MaxRetransmits NoLimit() {
return MaxRetransmits(std::numeric_limits<uint16_t>::max());
}
};
// An identifier that can be set on sent messages, and picked by the sending
// client. If different from `::NotSet()`, lifecycle events will be generated,
// and eventually `DcSctpSocketCallbacks::OnLifecycleEnd` will be called to
// indicate that the lifecycle isn't tracked any longer. The value zero (0) is
// not a valid lifecycle identifier, and will be interpreted as not having it
// set.
class LifecycleId : public webrtc::StrongAlias<class LifecycleIdTag, uint64_t> {
public:
constexpr explicit LifecycleId(const UnderlyingType& v)
: webrtc::StrongAlias<class LifecycleIdTag, uint64_t>(v) {}
constexpr bool IsSet() const { return value_ != 0; }
static constexpr LifecycleId NotSet() { return LifecycleId(0); }
};
} // namespace dcsctp
#endif // NET_DCSCTP_PUBLIC_TYPES_H_
|
