/rust/registry/src/index.crates.io-6f17d22bba15001f/weezl-0.1.10/src/error.rs

Source (jump to first uncovered line)
/// The result of a coding operation on a pair of buffer.
#[must_use = "Contains a status with potential error information"]
#[derive(Debug)]
pub struct BufferResult {
    /// The number of bytes consumed from the input buffer.
    pub consumed_in: usize,
    /// The number of bytes written into the output buffer.
    pub consumed_out: usize,
    /// The status after returning from the write call.
    pub status: Result<LzwStatus, LzwError>,
}

/// The result of a coding operation into a vector.
#[must_use = "Contains a status with potential error information"]
#[derive(Debug)]
pub struct VectorResult {
    /// The number of bytes consumed from the input buffer.
    pub consumed_in: usize,
    /// The number of bytes written into the output buffer.
    pub consumed_out: usize,
    /// The status after returning from the write call.
    pub status: Result<LzwStatus, LzwError>,
}

/// The result of coding into an output stream.
#[cfg(feature = "std")]
#[must_use = "Contains a status with potential error information"]
#[derive(Debug)]
pub struct StreamResult {
    /// The total number of bytes consumed from the reader.
    pub bytes_read: usize,
    /// The total number of bytes written into the writer.
    pub bytes_written: usize,
    /// The possible error that occurred.
    ///
    /// Note that when writing into streams it is not in general possible to recover from an error.
    pub status: std::io::Result<()>,
}

/// The status after successful coding of an LZW stream.
#[derive(Debug, Clone, Copy)]
pub enum LzwStatus {
    /// Everything went well.
    Ok,
    /// No bytes were read or written and no internal state advanced.
    ///
    /// If this is returned but your application can not provide more input data then decoding is
    /// definitely stuck for good and it should stop trying and report some error of its own. In
    /// other situations this may be used as a signal to refill an internal buffer.
    NoProgress,
    /// No more data will be produced because an end marker was reached.
    Done,
}

/// The error kind after unsuccessful coding of an LZW stream.
#[derive(Debug, Clone, Copy)]
pub enum LzwError {
    /// The input contained an invalid code.
    ///
    /// For decompression this refers to a code larger than those currently known through the prior
    /// decoding stages. For compression this refers to a byte that has no code representation due
    /// to being larger than permitted by the `size` parameter given to the Encoder.
    InvalidCode,
}

impl core::fmt::Display for LzwError {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        match self {
            LzwError::InvalidCode => f.write_str("invalid code in LZW stream"),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for LzwError {}

Coverage Report

Created: 2025-07-18 06:49

Line	Count	Source (jump to first uncovered line)
1		/// The result of a coding operation on a pair of buffer.
2		#[must_use = "Contains a status with potential error information"]
3		#[derive(Debug)]
4		pub struct BufferResult {
5		/// The number of bytes consumed from the input buffer.
6		pub consumed_in: usize,
7		/// The number of bytes written into the output buffer.
8		pub consumed_out: usize,
9		/// The status after returning from the write call.
10		pub status: Result<LzwStatus, LzwError>,
11		}
12
13		/// The result of a coding operation into a vector.
14		#[must_use = "Contains a status with potential error information"]
15		#[derive(Debug)]
16		pub struct VectorResult {
17		/// The number of bytes consumed from the input buffer.
18		pub consumed_in: usize,
19		/// The number of bytes written into the output buffer.
20		pub consumed_out: usize,
21		/// The status after returning from the write call.
22		pub status: Result<LzwStatus, LzwError>,
23		}
24
25		/// The result of coding into an output stream.
26		#[cfg(feature = "std")]
27		#[must_use = "Contains a status with potential error information"]
28		#[derive(Debug)]
29		pub struct StreamResult {
30		/// The total number of bytes consumed from the reader.
31		pub bytes_read: usize,
32		/// The total number of bytes written into the writer.
33		pub bytes_written: usize,
34		/// The possible error that occurred.
35		///
36		/// Note that when writing into streams it is not in general possible to recover from an error.
37		pub status: std::io::Result<()>,
38		}
39
40		/// The status after successful coding of an LZW stream.
41		#[derive(Debug, Clone, Copy)]
42		pub enum LzwStatus {
43		/// Everything went well.
44		Ok,
45		/// No bytes were read or written and no internal state advanced.
46		///
47		/// If this is returned but your application can not provide more input data then decoding is
48		/// definitely stuck for good and it should stop trying and report some error of its own. In
49		/// other situations this may be used as a signal to refill an internal buffer.
50		NoProgress,
51		/// No more data will be produced because an end marker was reached.
52		Done,
53		}
54
55		/// The error kind after unsuccessful coding of an LZW stream.
56		#[derive(Debug, Clone, Copy)]
57		pub enum LzwError {
58		/// The input contained an invalid code.
59		///
60		/// For decompression this refers to a code larger than those currently known through the prior
61		/// decoding stages. For compression this refers to a byte that has no code representation due
62		/// to being larger than permitted by the `size` parameter given to the Encoder.
63		InvalidCode,
64		}
65
66		impl core::fmt::Display for LzwError {
67	0	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
68	0	match self {
69	0	LzwError::InvalidCode => f.write_str("invalid code in LZW stream"),
70	0	}
71	0	}
72		}
73
74		#[cfg(feature = "std")]
75		impl std::error::Error for LzwError {}