1
use crate::chunk::chunk_payload_data::ChunkPayloadData;
2
 
3
use alloc::collections::VecDeque;
4
 
5
/// pendingBaseQueue
6
pub(crate) type PendingBaseQueue = VecDeque<ChunkPayloadData>;
7
 
8
/// pendingQueue
9
#[derive(Debug, Default)]
10
pub(crate) struct PendingQueue {
11
    unordered_queue: PendingBaseQueue,
12
    ordered_queue: PendingBaseQueue,
13
    queue_len: usize,
14
    n_bytes: usize,
15
    selected: bool,
16
    unordered_is_selected: bool,
17
}
18
 
19
impl PendingQueue {
20
    pub(crate) fn new() -> Self {
21
        PendingQueue::default()
22
    }
23
 
24
    pub(crate) fn push(&mut self, c: ChunkPayloadData) {
25
        self.n_bytes += c.user_data.len();
26
        if c.unordered {
27
            self.unordered_queue.push_back(c);
28
        } else {
29
            self.ordered_queue.push_back(c);
30
        }
31
        self.queue_len += 1;
32
    }
33
 
34
    pub(crate) fn peek(&self) -> Option<&ChunkPayloadData> {
35
        if self.selected {
36
            if self.unordered_is_selected {
37
                return self.unordered_queue.front();
38
            } else {
39
                return self.ordered_queue.front();
40
            }
41
        }
42
 
43
        let c = self.unordered_queue.front();
44
 
45
        if c.is_some() {
46
            return c;
47
        }
48
 
49
        self.ordered_queue.front()
50
    }
51
 
52
    pub(crate) fn pop(
53
        &mut self,
54
        beginning_fragment: bool,
55
        unordered: bool,
56
    ) -> Option<ChunkPayloadData> {
57
        let popped = if self.selected {
58
            let popped = if self.unordered_is_selected {
59
                self.unordered_queue.pop_front()
60
            } else {
61
                self.ordered_queue.pop_front()
62
            };
63
            if let Some(p) = &popped {
64
                if p.ending_fragment {
65
                    self.selected = false;
66
                }
67
            }
68
            popped
69
        } else {
70
            if !beginning_fragment {
71
                return None;
72
            }
73
            if unordered {
74
                let popped = { self.unordered_queue.pop_front() };
75
                if let Some(p) = &popped {
76
                    if !p.ending_fragment {
77
                        self.selected = true;
78
                        self.unordered_is_selected = true;
79
                    }
80
                }
81
                popped
82
            } else {
83
                let popped = { self.ordered_queue.pop_front() };
84
                if let Some(p) = &popped {
85
                    if !p.ending_fragment {
86
                        self.selected = true;
87
                        self.unordered_is_selected = false;
88
                    }
89
                }
90
                popped
91
            }
92
        };
93
 
94
        if let Some(p) = &popped {
95
            self.n_bytes -= p.user_data.len();
96
            self.queue_len -= 1;
97
        }
98
 
99
        popped
100
    }
101
 
102
    pub(crate) fn get_num_bytes(&self) -> usize {
103
        self.n_bytes
104
    }
105
 
106
    pub(crate) fn len(&self) -> usize {
107
        self.queue_len
108
    }
109
 
110
    pub(crate) fn is_empty(&self) -> bool {
111
        self.len() == 0
112
    }
113
 
114
    pub(crate) fn contains_stream(&self, stream_identifier: u16) -> bool {
115
        self.unordered_queue
116
            .iter()
117
            .chain(self.ordered_queue.iter())
118
            .any(|chunk| chunk.stream_identifier == stream_identifier)
119
    }
120
}