22518245728

Committed 28 Feb 2026 09:40AM UTC coverage: 57.751% (+3.1%) from 54.618%

Build # 22518245728

Build Type

push

github

Committed by

vigna

Commit Message

delta_gamma in filenames

Coverage Stats

2213 of 3832 relevant lines covered (57.75%)

2595204.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/utils/dbg_codes.rs

/*
 * SPDX-FileCopyrightText: 2023 Inria
 * SPDX-FileCopyrightText: 2023 Sebastiano Vigna
 *
 * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
 */

use crate::prelude::*;
use crate::traits::*;
#[cfg(feature = "mem_dbg")]
use mem_dbg::{MemDbg, MemSize};

/// A wrapper over a [`BitRead`] that reports on standard error all
/// operations performed, including all code reads.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
pub struct DbgBitReader<E: Endianness, R> {
    reader: R,
    _marker: core::marker::PhantomData<E>,
}

impl<E: Endianness, R> DbgBitReader<E, R> {
    #[must_use]
    pub fn new(cr: R) -> Self {
        Self {
            reader: cr,
            _marker: Default::default(),
        }
    }
}

impl<E: Endianness, R: BitRead<E>> BitRead<E> for DbgBitReader<E, R>
where
    R::PeekWord: core::fmt::Display,
{
    type Error = R::Error;
    type PeekWord = R::PeekWord;
    const PEEK_BITS: usize = R::PEEK_BITS;

    fn peek_bits(&mut self, n_bits: usize) -> Result<Self::PeekWord, Self::Error> {
        let value = self.reader.peek_bits(n_bits)?;
        #[cfg(feature = "std")]
        eprintln!("peek_bits({}): {}", n_bits, value);
        Ok(value)
    }

    fn skip_bits(&mut self, n_bits: usize) -> Result<(), Self::Error> {
        #[cfg(feature = "std")]
        eprintln!("skip_bits({})", n_bits);
        self.reader.skip_bits(n_bits)
    }

    fn read_bits(&mut self, num_bits: usize) -> Result<u64, Self::Error> {
        let value = self.reader.read_bits(num_bits)?;
        #[cfg(feature = "std")]
        eprintln!("read_bits({}): {}", num_bits, value);
        Ok(value)
    }

    fn read_unary(&mut self) -> Result<u64, Self::Error> {
        let value = self.reader.read_unary()?;
        #[cfg(feature = "std")]
        eprintln!("{{U:{}}}", value);
        Ok(value)
    }

    fn skip_bits_after_peek(&mut self, n: usize) {
        self.reader.skip_bits_after_peek(n)
    }
}

impl<E: Endianness, R: GammaRead<E>> GammaRead<E> for DbgBitReader<E, R>
where
    R::PeekWord: core::fmt::Display,
{
    fn read_gamma(&mut self) -> Result<u64, R::Error> {
        let value = self.reader.read_gamma()?;
        #[cfg(feature = "std")]
        eprintln!("{{g:{}}}", value);
        Ok(value)
    }
}

impl<E: Endianness, R: DeltaRead<E>> DeltaRead<E> for DbgBitReader<E, R>
where
    R::PeekWord: core::fmt::Display,
{
    fn read_delta(&mut self) -> Result<u64, R::Error> {
        let value = self.reader.read_delta()?;
        #[cfg(feature = "std")]
        eprintln!("{{d:{}}}", value);
        Ok(value)
    }
}

impl<E: Endianness, R: ZetaRead<E>> ZetaRead<E> for DbgBitReader<E, R>
where
    R::PeekWord: core::fmt::Display,
{
    fn read_zeta3(&mut self) -> Result<u64, R::Error> {
        let value = self.reader.read_zeta3()?;
        #[cfg(feature = "std")]
        eprintln!("{{z3:{}}}", value);
        Ok(value)
    }

    fn read_zeta(&mut self, k: usize) -> Result<u64, R::Error> {
        let value = self.reader.read_zeta(k)?;
        #[cfg(feature = "std")]
        eprintln!("{{z{}:{}}}", k, value);
        Ok(value)
    }
}

impl<E: Endianness, R: OmegaRead<E>> OmegaRead<E> for DbgBitReader<E, R>
where
    R::PeekWord: core::fmt::Display,
{
    fn read_omega(&mut self) -> Result<u64, R::Error> {
        let value = self.reader.read_omega()?;
        #[cfg(feature = "std")]
        eprintln!("{{o:{}}}", value);
        Ok(value)
    }
}

impl<E: Endianness, R: PiRead<E>> PiRead<E> for DbgBitReader<E, R>
where
    R::PeekWord: core::fmt::Display,
{
    fn read_pi(&mut self, k: usize) -> Result<u64, R::Error> {
        let value = self.reader.read_pi(k)?;
        #[cfg(feature = "std")]
        eprintln!("{{p{}:{}}}", k, value);
        Ok(value)
    }

    fn read_pi2(&mut self) -> Result<u64, R::Error> {
        let value = self.reader.read_pi2()?;
        #[cfg(feature = "std")]
        eprintln!("{{p2:{}}}", value);
        Ok(value)
    }
}

/// A wrapper over a [`BitWrite`] that reports on standard error all operations performed,
/// including all code writes.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
pub struct DbgBitWriter<E: Endianness, W> {
    writer: W,
    _marker: core::marker::PhantomData<E>,
}

impl<E: Endianness, W> DbgBitWriter<E, W> {
    #[must_use]
    pub fn new(cw: W) -> Self {
        Self {
            writer: cw,
            _marker: Default::default(),
        }
    }
}

impl<E: Endianness, W: BitWrite<E>> BitWrite<E> for DbgBitWriter<E, W> {
    type Error = W::Error;

    fn write_bits(&mut self, value: u64, num_bits: usize) -> Result<usize, Self::Error> {
        #[cfg(feature = "std")]
        eprintln!("write_bits({}, {})", value, num_bits);
        self.writer.write_bits(value, num_bits)
    }

    fn write_unary(&mut self, n: u64) -> Result<usize, Self::Error> {
        #[cfg(feature = "std")]
        eprintln!("{{U:{}}}", n);
        self.writer.write_unary(n)
    }

    fn flush(&mut self) -> Result<usize, Self::Error> {
        self.writer.flush()
    }
}

impl<E: Endianness, W: GammaWrite<E>> GammaWrite<E> for DbgBitWriter<E, W> {
    fn write_gamma(&mut self, n: u64) -> Result<usize, W::Error> {
        #[cfg(feature = "std")]
        eprintln!("{{g:{}}}", n);
        self.writer.write_gamma(n)
    }
}

impl<E: Endianness, W: DeltaWrite<E>> DeltaWrite<E> for DbgBitWriter<E, W> {
    fn write_delta(&mut self, n: u64) -> Result<usize, W::Error> {
        #[cfg(feature = "std")]
        eprintln!("{{d:{}}}", n);
        self.writer.write_delta(n)
    }
}

impl<E: Endianness, W: ZetaWrite<E>> ZetaWrite<E> for DbgBitWriter<E, W> {
    fn write_zeta(&mut self, n: u64, k: usize) -> Result<usize, W::Error> {
        #[cfg(feature = "std")]
        eprintln!("{{z{}:{}}}", k, n);
        self.writer.write_zeta(n, k)
    }
    fn write_zeta3(&mut self, n: u64) -> Result<usize, W::Error> {
        #[cfg(feature = "std")]
        eprintln!("{{z3:{}}}", n);
        self.writer.write_zeta3(n)
    }
}

impl<E: Endianness, W: OmegaWrite<E>> OmegaWrite<E> for DbgBitWriter<E, W> {
    fn write_omega(&mut self, n: u64) -> Result<usize, W::Error> {
        #[cfg(feature = "std")]
        eprintln!("{{o:{}}}", n);
        self.writer.write_omega(n)
    }
}

impl<E: Endianness, W: PiWrite<E>> PiWrite<E> for DbgBitWriter<E, W> {
    fn write_pi(&mut self, n: u64, k: usize) -> Result<usize, W::Error> {
        #[cfg(feature = "std")]
        eprintln!("{{p{}:{}}}", k, n);
        self.writer.write_pi(n, k)
    }

    fn write_pi2(&mut self, n: u64) -> Result<usize, W::Error> {
        #[cfg(feature = "std")]
        eprintln!("{{p2:{}}}", n);
        self.writer.write_pi2(n)
    }
}

1	/*
2	* SPDX-FileCopyrightText: 2023 Inria
3	* SPDX-FileCopyrightText: 2023 Sebastiano Vigna
4	*
5	* SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
6	*/
7
8	use crate::prelude::*;
9	use crate::traits::*;
10	#[cfg(feature = "mem_dbg")]
11	use mem_dbg::{MemDbg, MemSize};
12
13	/// A wrapper over a [`BitRead`] that reports on standard error all
14	/// operations performed, including all code reads.
15	#[derive(Debug, Clone)]
16	#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
17	pub struct DbgBitReader<E: Endianness, R> {
18	reader: R,
19	_marker: core::marker::PhantomData<E>,
20	}
21
22	impl<E: Endianness, R> DbgBitReader<E, R> {
23	#[must_use]
24	pub fn new(cr: R) -> Self {	×
25	Self {
26	reader: cr,
27	_marker: Default::default(),	×
28	}
29	}
30	}
31
32	impl<E: Endianness, R: BitRead<E>> BitRead<E> for DbgBitReader<E, R>
33	where
34	R::PeekWord: core::fmt::Display,
35	{
36	type Error = R::Error;
37	type PeekWord = R::PeekWord;
38	const PEEK_BITS: usize = R::PEEK_BITS;
39
40	fn peek_bits(&mut self, n_bits: usize) -> Result<Self::PeekWord, Self::Error> {	×
41	let value = self.reader.peek_bits(n_bits)?;	×
42	#[cfg(feature = "std")]
43	eprintln!("peek_bits({}): {}", n_bits, value);	×
44	Ok(value)	×
45	}
46
47	fn skip_bits(&mut self, n_bits: usize) -> Result<(), Self::Error> {	×
48	#[cfg(feature = "std")]
49	eprintln!("skip_bits({})", n_bits);	×
50	self.reader.skip_bits(n_bits)	×
51	}
52
53	fn read_bits(&mut self, num_bits: usize) -> Result<u64, Self::Error> {	×
54	let value = self.reader.read_bits(num_bits)?;	×
55	#[cfg(feature = "std")]
56	eprintln!("read_bits({}): {}", num_bits, value);	×
57	Ok(value)	×
58	}
59
60	fn read_unary(&mut self) -> Result<u64, Self::Error> {	×
61	let value = self.reader.read_unary()?;	×
62	#[cfg(feature = "std")]
63	eprintln!("{{U:{}}}", value);	×
64	Ok(value)	×
65	}
66
67	fn skip_bits_after_peek(&mut self, n: usize) {	×
68	self.reader.skip_bits_after_peek(n)	×
69	}
70	}
71
72	impl<E: Endianness, R: GammaRead<E>> GammaRead<E> for DbgBitReader<E, R>
73	where
74	R::PeekWord: core::fmt::Display,
75	{
76	fn read_gamma(&mut self) -> Result<u64, R::Error> {	×
77	let value = self.reader.read_gamma()?;	×
78	#[cfg(feature = "std")]
79	eprintln!("{{g:{}}}", value);	×
80	Ok(value)	×
81	}
82	}
83
84	impl<E: Endianness, R: DeltaRead<E>> DeltaRead<E> for DbgBitReader<E, R>
85	where
86	R::PeekWord: core::fmt::Display,
87	{
88	fn read_delta(&mut self) -> Result<u64, R::Error> {	×
89	let value = self.reader.read_delta()?;	×
90	#[cfg(feature = "std")]
91	eprintln!("{{d:{}}}", value);	×
92	Ok(value)	×
93	}
94	}
95
96	impl<E: Endianness, R: ZetaRead<E>> ZetaRead<E> for DbgBitReader<E, R>
97	where
98	R::PeekWord: core::fmt::Display,
99	{
100	fn read_zeta3(&mut self) -> Result<u64, R::Error> {	×
101	let value = self.reader.read_zeta3()?;	×
102	#[cfg(feature = "std")]
103	eprintln!("{{z3:{}}}", value);	×
104	Ok(value)	×
105	}
106
107	fn read_zeta(&mut self, k: usize) -> Result<u64, R::Error> {	×
108	let value = self.reader.read_zeta(k)?;	×
109	#[cfg(feature = "std")]
110	eprintln!("{{z{}:{}}}", k, value);	×
111	Ok(value)	×
112	}
113	}
114
115	impl<E: Endianness, R: OmegaRead<E>> OmegaRead<E> for DbgBitReader<E, R>
116	where
117	R::PeekWord: core::fmt::Display,
118	{
119	fn read_omega(&mut self) -> Result<u64, R::Error> {	×
120	let value = self.reader.read_omega()?;	×
121	#[cfg(feature = "std")]
122	eprintln!("{{o:{}}}", value);	×
123	Ok(value)	×
124	}
125	}
126
127	impl<E: Endianness, R: PiRead<E>> PiRead<E> for DbgBitReader<E, R>
128	where
129	R::PeekWord: core::fmt::Display,
130	{
131	fn read_pi(&mut self, k: usize) -> Result<u64, R::Error> {	×
132	let value = self.reader.read_pi(k)?;	×
133	#[cfg(feature = "std")]
134	eprintln!("{{p{}:{}}}", k, value);	×
135	Ok(value)	×
136	}
137
138	fn read_pi2(&mut self) -> Result<u64, R::Error> {	×
139	let value = self.reader.read_pi2()?;	×
140	#[cfg(feature = "std")]
141	eprintln!("{{p2:{}}}", value);	×
142	Ok(value)	×
143	}
144	}
145
146	/// A wrapper over a [`BitWrite`] that reports on standard error all operations performed,
147	/// including all code writes.
148	#[derive(Debug, Clone)]
149	#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
150	pub struct DbgBitWriter<E: Endianness, W> {
151	writer: W,
152	_marker: core::marker::PhantomData<E>,
153	}
154
155	impl<E: Endianness, W> DbgBitWriter<E, W> {
156	#[must_use]
157	pub fn new(cw: W) -> Self {	×
158	Self {
159	writer: cw,
160	_marker: Default::default(),	×
161	}
162	}
163	}
164
165	impl<E: Endianness, W: BitWrite<E>> BitWrite<E> for DbgBitWriter<E, W> {
166	type Error = W::Error;
167
168	fn write_bits(&mut self, value: u64, num_bits: usize) -> Result<usize, Self::Error> {	×
169	#[cfg(feature = "std")]
170	eprintln!("write_bits({}, {})", value, num_bits);	×
171	self.writer.write_bits(value, num_bits)	×
172	}
173
174	fn write_unary(&mut self, n: u64) -> Result<usize, Self::Error> {	×
175	#[cfg(feature = "std")]
176	eprintln!("{{U:{}}}", n);	×
177	self.writer.write_unary(n)	×
178	}
179
180	fn flush(&mut self) -> Result<usize, Self::Error> {	×
181	self.writer.flush()	×
182	}
183	}
184
185	impl<E: Endianness, W: GammaWrite<E>> GammaWrite<E> for DbgBitWriter<E, W> {
186	fn write_gamma(&mut self, n: u64) -> Result<usize, W::Error> {	×
187	#[cfg(feature = "std")]
188	eprintln!("{{g:{}}}", n);	×
189	self.writer.write_gamma(n)	×
190	}
191	}
192
193	impl<E: Endianness, W: DeltaWrite<E>> DeltaWrite<E> for DbgBitWriter<E, W> {
194	fn write_delta(&mut self, n: u64) -> Result<usize, W::Error> {	×
195	#[cfg(feature = "std")]
196	eprintln!("{{d:{}}}", n);	×
197	self.writer.write_delta(n)	×
198	}
199	}
200
201	impl<E: Endianness, W: ZetaWrite<E>> ZetaWrite<E> for DbgBitWriter<E, W> {
202	fn write_zeta(&mut self, n: u64, k: usize) -> Result<usize, W::Error> {	×
203	#[cfg(feature = "std")]
204	eprintln!("{{z{}:{}}}", k, n);	×
205	self.writer.write_zeta(n, k)	×
206	}
207	fn write_zeta3(&mut self, n: u64) -> Result<usize, W::Error> {	×
208	#[cfg(feature = "std")]
209	eprintln!("{{z3:{}}}", n);	×
210	self.writer.write_zeta3(n)	×
211	}
212	}
213
214	impl<E: Endianness, W: OmegaWrite<E>> OmegaWrite<E> for DbgBitWriter<E, W> {
215	fn write_omega(&mut self, n: u64) -> Result<usize, W::Error> {	×
216	#[cfg(feature = "std")]
217	eprintln!("{{o:{}}}", n);	×
218	self.writer.write_omega(n)	×
219	}
220	}
221
222	impl<E: Endianness, W: PiWrite<E>> PiWrite<E> for DbgBitWriter<E, W> {
223	fn write_pi(&mut self, n: u64, k: usize) -> Result<usize, W::Error> {	×
224	#[cfg(feature = "std")]
225	eprintln!("{{p{}:{}}}", k, n);	×
226	self.writer.write_pi(n, k)	×
227	}
228
229	fn write_pi2(&mut self, n: u64) -> Result<usize, W::Error> {	×
230	#[cfg(feature = "std")]
231	eprintln!("{{p2:{}}}", n);	×
232	self.writer.write_pi2(n)	×
233	}
234	}

vigna / dsi-bitstream-rs / 22518245728

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous