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
|
/*
Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2011, 2012 Her Majesty the Queen in Right of Canada (Communications
Research Center Canada)
Copyright (C) 2016
Matthias P. Braendli, matthias.braendli@mpb.li
*/
/*
This file is part of ODR-DabMux.
ODR-DabMux is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
ODR-DabMux is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with ODR-DabMux. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <cstdint>
#include <map>
#include <set>
#include <vector>
#include <memory>
#include <chrono>
namespace FIC {
// Some FIGs need to adapt their rate or their contents depending
// on if some data entries are stable or currently undergoing a
// change. The TransitionHandler keeps track of which entries
// are in what state.
template<class T>
class TransitionHandler {
public:
using duration = std::chrono::steady_clock::duration;
// update_state will move entries from new to repeated to disabled
// depending on their is_active() return value.
void update_state(duration timeout, std::vector<std::shared_ptr<T> > all_entries)
{
using namespace std::chrono;
auto now = steady_clock::now();
for (const auto& entry : all_entries) {
if (entry->is_active()) {
if (repeated_entries.count(entry) > 0) {
// We are currently announcing this entry
continue;
}
if (new_entries.count(entry) > 0) {
// We are currently announcing this entry at a
// fast rate. Handle timeout:
if (new_entries[entry] <= now) {
repeated_entries.insert(entry);
new_entries.erase(entry);
}
continue;
}
// unlikely
if (disabled_entries.count(entry) > 0) {
new_entries[entry] = now + timeout;
disabled_entries.erase(entry);
continue;
}
// It's a new entry!
new_entries[entry] = now + timeout;
}
else { // Not active
if (disabled_entries.count(entry) > 0) {
if (disabled_entries[entry] <= now) {
disabled_entries.erase(entry);
}
continue;
}
if (repeated_entries.count(entry) > 0) {
// We are currently announcing this entry
disabled_entries[entry] = now + timeout;
repeated_entries.erase(entry);
continue;
}
// unlikely
if (new_entries.count(entry) > 0) {
// We are currently announcing this entry at a
// fast rate. We must stop announcing it
disabled_entries[entry] = now + timeout;
new_entries.erase(entry);
continue;
}
}
}
}
// The FIG that needs the information about what state an entry is in
// can read from the following data structures. It shall not modify them.
using time_point = std::chrono::steady_clock::time_point;
std::map<
std::shared_ptr<T>, time_point> new_entries;
std::set<
std::shared_ptr<T> > repeated_entries;
std::map<
std::shared_ptr<T>, time_point> disabled_entries;
};
} // namespace FIC
|
