Merge pull request #50 from KillingSpark/remove_thiserror

Remove thiserror in favor of derive_more

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruzstd"
-version = "0.4.0"
+version = "0.5.0"
 authors = ["Moritz Borcherding <[email protected]>"]
 edition = "2018"
 license = "MIT"
@@ -11,17 +11,17 @@ exclude = ["decodecorpus_files/*", "dict_tests/*", "fuzz_decodecorpus/*"]
 readme = "Readme.md"
 
 [dependencies]
-byteorder = { version = "1.4", default-features = false }
+byteorder = { version = "1.5", default-features = false }
 twox-hash = { version = "1.6", default-features = false }
-thiserror = { package = "thiserror-core", version = "1.0.38", default-features = false }
+derive_more = { version = "0.99", default-features = false, features = ["display", "from"] }
 
 [dev-dependencies]
 criterion = "0.3"
 rand = {version = "0.8.5", features = ["small_rng"]}
 
 [features]
 default = ["std"]
-std = ["thiserror/std"]
+std = ["derive_more/error"]
 
 [[bench]]
 name = "reversedbitreader_bench"

src/blocks/literals_section.rs

@@ -14,14 +14,18 @@ pub enum LiteralsSectionType {
  Treeless,
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display, derive_more::From)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum LiteralsSectionParseError {
- #[error("Illegal literalssectiontype. Is: {got}, must be in: 0, 1, 2, 3")]
+ #[display(fmt = "Illegal literalssectiontype. Is: {got}, must be in: 0, 1, 2, 3")]
  IllegalLiteralSectionType { got: u8 },
- #[error(transparent)]
- GetBitsError(#[from] GetBitsError),
- #[error("Not enough byte to parse the literals section header. Have: {have}, Need: {need}")]
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ GetBitsError(GetBitsError),
+ #[display(
+ fmt = "Not enough byte to parse the literals section header. Have: {have}, Need: {need}"
+ )]
  NotEnoughBytes { have: usize, need: u8 },
 }
 

src/blocks/sequence_section.rs

@@ -55,10 +55,13 @@ impl Default for SequencesHeader {
  }
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum SequencesHeaderParseError {
- #[error("source must have at least {need_at_least} bytes to parse header; got {got} bytes")]
+ #[display(
+ fmt = "source must have at least {need_at_least} bytes to parse header; got {got} bytes"
+ )]
  NotEnoughBytes { need_at_least: u8, got: usize },
 }
 

src/decoding/bit_reader.rs

@@ -3,15 +3,18 @@ pub struct BitReader<'s> {
  source: &'s [u8],
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum GetBitsError {
- #[error("Cant serve this request. The reader is limited to {limit} bits, requested {num_requested_bits} bits")]
+ #[display(
+ fmt = "Cant serve this request. The reader is limited to {limit} bits, requested {num_requested_bits} bits"
+ )]
  TooManyBits {
  num_requested_bits: usize,
  limit: u8,
  },
- #[error("Can't read {requested} bits, only have {remaining} bits left")]
+ #[display(fmt = "Can't read {requested} bits, only have {remaining} bits left")]
  NotEnoughRemainingBits { requested: usize, remaining: usize },
 }
 

src/decoding/block_decoder.rs

@@ -25,72 +25,89 @@ enum DecoderState {
  Failed, //TODO put "self.internal_state = DecoderState::Failed;" everywhere an unresolvable error occurs
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display, derive_more::From)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum BlockHeaderReadError {
- #[error("Error while reading the block header")]
- ReadError(#[from] io::Error),
- #[error("Reserved block occured. This is considered corruption by the documentation")]
+ #[display(fmt = "Error while reading the block header")]
+ #[from]
+ ReadError(io::Error),
+ #[display(fmt = "Reserved block occured. This is considered corruption by the documentation")]
  FoundReservedBlock,
- #[error("Error getting block type: {0}")]
- BlockTypeError(#[from] BlockTypeError),
- #[error("Error getting block content size: {0}")]
- BlockSizeError(#[from] BlockSizeError),
+ #[display(fmt = "Error getting block type: {_0}")]
+ #[from]
+ BlockTypeError(BlockTypeError),
+ #[display(fmt = "Error getting block content size: {_0}")]
+ #[from]
+ BlockSizeError(BlockSizeError),
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum BlockTypeError {
- #[error(
- "Invalid Blocktype number. Is: {num} Should be one of: 0, 1, 2, 3 (3 is reserved though"
+ #[display(
+ fmt = "Invalid Blocktype number. Is: {num} Should be one of: 0, 1, 2, 3 (3 is reserved though"
  )]
  InvalidBlocktypeNumber { num: u8 },
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum BlockSizeError {
- #[error("Blocksize was bigger than the absolute maximum {ABSOLUTE_MAXIMUM_BLOCK_SIZE} (128kb). Is: {size}")]
+ #[display(
+ fmt = "Blocksize was bigger than the absolute maximum {ABSOLUTE_MAXIMUM_BLOCK_SIZE} (128kb). Is: {size}"
+ )]
  BlockSizeTooLarge { size: u32 },
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display, derive_more::From)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum DecompressBlockError {
- #[error("Error while reading the block content: {0}")]
- BlockContentReadError(#[from] io::Error),
- #[error("Malformed section header. Says literals would be this long: {expected_len} but there are only {remaining_bytes} bytes left")]
+ #[display(fmt = "Error while reading the block content: {_0}")]
+ #[from]
+ BlockContentReadError(io::Error),
+ #[display(
+ fmt = "Malformed section header. Says literals would be this long: {expected_len} but there are only {remaining_bytes} bytes left"
+ )]
  MalformedSectionHeader {
  expected_len: usize,
  remaining_bytes: usize,
  },
- #[error(transparent)]
- DecompressLiteralsError(#[from] DecompressLiteralsError),
- #[error(transparent)]
- LiteralsSectionParseError(#[from] LiteralsSectionParseError),
- #[error(transparent)]
- SequencesHeaderParseError(#[from] SequencesHeaderParseError),
- #[error(transparent)]
- DecodeSequenceError(#[from] DecodeSequenceError),
- #[error(transparent)]
- ExecuteSequencesError(#[from] ExecuteSequencesError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ DecompressLiteralsError(DecompressLiteralsError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ LiteralsSectionParseError(LiteralsSectionParseError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ SequencesHeaderParseError(SequencesHeaderParseError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ DecodeSequenceError(DecodeSequenceError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ ExecuteSequencesError(ExecuteSequencesError),
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display, derive_more::From)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum DecodeBlockContentError {
- #[error("Can't decode next block if failed along the way. Results will be nonsense")]
+ #[display(fmt = "Can't decode next block if failed along the way. Results will be nonsense")]
  DecoderStateIsFailed,
- #[error("Cant decode next block body, while expecting to decode the header of the previous block. Results will be nonsense")]
+ #[display(
+ fmt = "Cant decode next block body, while expecting to decode the header of the previous block. Results will be nonsense"
+ )]
  ExpectedHeaderOfPreviousBlock,
- #[error("Error while reading bytes for {step}: {source}")]
- ReadError {
- step: BlockType,
- #[source]
- source: io::Error,
- },
- #[error(transparent)]
- DecompressBlockError(#[from] DecompressBlockError),
+ #[display(fmt = "Error while reading bytes for {step}: {source}")]
+ ReadError { step: BlockType, source: io::Error },
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ DecompressBlockError(DecompressBlockError),
 }
 
 pub fn new() -> BlockDecoder {

src/decoding/decodebuffer.rs

@@ -15,12 +15,13 @@ pub struct Decodebuffer {
  pub hash: XxHash64,
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum DecodebufferError {
- #[error("Need {need} bytes from the dictionary but it is only {got} bytes long")]
+ #[display(fmt = "Need {need} bytes from the dictionary but it is only {got} bytes long")]
  NotEnoughBytesInDictionary { got: usize, need: usize },
- #[error("offset: {offset} bigger than buffer: {buf_len}")]
+ #[display(fmt = "offset: {offset} bigger than buffer: {buf_len}")]
  OffsetTooBig { offset: usize, buf_len: usize },
 }
 

src/decoding/dictionary.rs

@@ -14,17 +14,20 @@ pub struct Dictionary {
  pub offset_hist: [u32; 3],
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display, derive_more::From)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum DictionaryDecodeError {
- #[error(
- "Bad magic_num at start of the dictionary; Got: {got:#04X?}, Expected: {MAGIC_NUM:#04x?}"
+ #[display(
+ fmt = "Bad magic_num at start of the dictionary; Got: {got:#04X?}, Expected: {MAGIC_NUM:#04x?}"
  )]
  BadMagicNum { got: [u8; 4] },
- #[error(transparent)]
- FSETableError(#[from] FSETableError),
- #[error(transparent)]
- HuffmanTableError(#[from] HuffmanTableError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ FSETableError(FSETableError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ HuffmanTableError(HuffmanTableError),
 }
 
 pub const MAGIC_NUM: [u8; 4] = [0x37, 0xA4, 0x30, 0xEC];

src/decoding/literals_section_decoder.rs

@@ -4,32 +4,40 @@ use super::scratch::HuffmanScratch;
 use crate::huff0::{HuffmanDecoder, HuffmanDecoderError, HuffmanTableError};
 use alloc::vec::Vec;
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display, derive_more::From)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum DecompressLiteralsError {
- #[error(
- "compressed size was none even though it must be set to something for compressed literals"
+ #[display(
+ fmt = "compressed size was none even though it must be set to something for compressed literals"
  )]
  MissingCompressedSize,
- #[error("num_streams was none even though it must be set to something (1 or 4) for compressed literals")]
+ #[display(
+ fmt = "num_streams was none even though it must be set to something (1 or 4) for compressed literals"
+ )]
  MissingNumStreams,
- #[error(transparent)]
- GetBitsError(#[from] GetBitsError),
- #[error(transparent)]
- HuffmanTableError(#[from] HuffmanTableError),
- #[error(transparent)]
- HuffmanDecoderError(#[from] HuffmanDecoderError),
- #[error("Tried to reuse huffman table but it was never initialized")]
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ GetBitsError(GetBitsError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ HuffmanTableError(HuffmanTableError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ HuffmanDecoderError(HuffmanDecoderError),
+ #[display(fmt = "Tried to reuse huffman table but it was never initialized")]
  UninitializedHuffmanTable,
- #[error("Need 6 bytes to decode jump header, got {got} bytes")]
+ #[display(fmt = "Need 6 bytes to decode jump header, got {got} bytes")]
  MissingBytesForJumpHeader { got: usize },
- #[error("Need at least {needed} bytes to decode literals. Have: {got} bytes")]
+ #[display(fmt = "Need at least {needed} bytes to decode literals. Have: {got} bytes")]
  MissingBytesForLiterals { got: usize, needed: usize },
- #[error("Padding at the end of the sequence_section was more than a byte long: {skipped_bits} bits. Probably caused by data corruption")]
+ #[display(
+ fmt = "Padding at the end of the sequence_section was more than a byte long: {skipped_bits} bits. Probably caused by data corruption"
+ )]
  ExtraPadding { skipped_bits: i32 },
- #[error("Bitstream was read till: {read_til}, should have been: {expected}")]
+ #[display(fmt = "Bitstream was read till: {read_til}, should have been: {expected}")]
  BitstreamReadMismatch { read_til: isize, expected: isize },
- #[error("Did not decode enough literals: {decoded}, Should have been: {expected}")]
+ #[display(fmt = "Did not decode enough literals: {decoded}, Should have been: {expected}")]
  DecodedLiteralCountMismatch { decoded: usize, expected: usize },
 }
 

src/decoding/sequence_execution.rs

@@ -1,13 +1,15 @@
 use super::{decodebuffer::DecodebufferError, scratch::DecoderScratch};
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display, derive_more::From)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum ExecuteSequencesError {
- #[error(transparent)]
- DecodebufferError(#[from] DecodebufferError),
- #[error("Sequence wants to copy up to byte {wanted}. Bytes in literalsbuffer: {have}")]
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ DecodebufferError(DecodebufferError),
+ #[display(fmt = "Sequence wants to copy up to byte {wanted}. Bytes in literalsbuffer: {have}")]
  NotEnoughBytesForSequence { wanted: usize, have: usize },
- #[error("Illegal offset: 0 found")]
+ #[display(fmt = "Illegal offset: 0 found")]
  ZeroOffset,
 }
 

src/decoding/sequence_section_decoder.rs

@@ -6,32 +6,38 @@ use super::scratch::FSEScratch;
 use crate::fse::{FSEDecoder, FSEDecoderError, FSETableError};
 use alloc::vec::Vec;
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, derive_more::Display, derive_more::From)]
+#[cfg_attr(feature = "std", derive(derive_more::Error))]
 #[non_exhaustive]
 pub enum DecodeSequenceError {
- #[error(transparent)]
- GetBitsError(#[from] GetBitsError),
- #[error(transparent)]
- FSEDecoderError(#[from] FSEDecoderError),
- #[error(transparent)]
- FSETableError(#[from] FSETableError),
- #[error("Padding at the end of the sequence_section was more than a byte long: {skipped_bits} bits. Probably caused by data corruption")]
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ GetBitsError(GetBitsError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ FSEDecoderError(FSEDecoderError),
+ #[display(fmt = "{_0:?}")]
+ #[from]
+ FSETableError(FSETableError),
+ #[display(
+ fmt = "Padding at the end of the sequence_section was more than a byte long: {skipped_bits} bits. Probably caused by data corruption"
+ )]
  ExtraPadding { skipped_bits: i32 },
- #[error("Do not support offsets bigger than 1<<32; got: {offset_code}")]
+ #[display(fmt = "Do not support offsets bigger than 1<<32; got: {offset_code}")]
  UnsupportedOffset { offset_code: u8 },
- #[error("Read an offset == 0. That is an illegal value for offsets")]
+ #[display(fmt = "Read an offset == 0. That is an illegal value for offsets")]
  ZeroOffset,
- #[error("Bytestream did not contain enough bytes to decode num_sequences")]
+ #[display(fmt = "Bytestream did not contain enough bytes to decode num_sequences")]
  NotEnoughBytesForNumSequences,
- #[error("Did not use full bitstream. Bits left: {bits_remaining} ({} bytes)", bits_remaining / 8)]
+ #[display(fmt = "Did not use full bitstream. Bits left: {bits_remaining} ({} bytes)", bits_remaining / 8)]
  ExtraBits { bits_remaining: isize },
- #[error("compression modes are none but they must be set to something")]
+ #[display(fmt = "compression modes are none but they must be set to something")]
  MissingCompressionMode,
- #[error("Need a byte to read for RLE ll table")]
+ #[display(fmt = "Need a byte to read for RLE ll table")]
  MissingByteForRleLlTable,
- #[error("Need a byte to read for RLE of table")]
+ #[display(fmt = "Need a byte to read for RLE of table")]
  MissingByteForRleOfTable,
- #[error("Need a byte to read for RLE ml table")]
+ #[display(fmt = "Need a byte to read for RLE ml table")]
  MissingByteForRleMlTable,
 }