SYMBOL INDEX (589 symbols across 49 files)

FILE: cli/src/main.rs
  type Cli (line 22) | struct Cli {
  type Commands (line 29) | enum Commands {
  function main (line 64) | fn main() -> color_eyre::Result<()> {
  function compress (line 104) | fn compress(input: PathBuf, output: PathBuf, level: u8) -> color_eyre::R...
  function decompress (line 133) | fn decompress(input: PathBuf, output: PathBuf) -> color_eyre::Result<()> {
  function add_extension (line 160) | fn add_extension<P: AsRef<Path>>(path: &Path, extension: P) -> PathBuf {
  function extension_added (line 174) | fn extension_added() {

FILE: cli/src/progress.rs
  type ProgressMonitor (line 14) | pub struct ProgressMonitor<R: Read> {
  function new (line 26) | pub fn new(reader: R, size: usize) -> Self {
  function update (line 44) | fn update(&mut self, delta: u64) {
  method read (line 59) | fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
  function fmt_size (line 70) | pub fn fmt_size(size_in_bytes: f64) -> String {
  function fmt_duration (line 87) | fn fmt_duration(duration: Duration) -> String {
  function human_readable_filesize (line 127) | fn human_readable_filesize() {
  function human_readable_duration (line 139) | fn human_readable_duration() {

FILE: ruzstd/benches/decode_all.rs
  function criterion_benchmark (line 4) | fn criterion_benchmark(c: &mut Criterion) {

FILE: ruzstd/fuzz/fuzz_targets/interop.rs
  function decode_ruzstd (line 8) | fn decode_ruzstd(data: &mut dyn std::io::Read) -> Vec<u8> {
  function decode_ruzstd_writer (line 15) | fn decode_ruzstd_writer(mut data: impl Read) -> Vec<u8> {
  function encode_zstd (line 31) | fn encode_zstd(data: &[u8]) -> Result<Vec<u8>, std::io::Error> {
  function encode_ruzstd_uncompressed (line 35) | fn encode_ruzstd_uncompressed(data: &mut dyn std::io::Read) -> Vec<u8> {
  function encode_ruzstd_compressed (line 41) | fn encode_ruzstd_compressed(data: &mut dyn std::io::Read) -> Vec<u8> {
  function decode_zstd (line 47) | fn decode_zstd(data: &[u8]) -> Result<Vec<u8>, std::io::Error> {

FILE: ruzstd/src/bit_io/bit_reader.rs
  type BitReader (line 3) | pub struct BitReader<'s> {
  function new (line 9) | pub fn new(source: &'s [u8]) -> BitReader<'s> {
  function bits_left (line 13) | pub fn bits_left(&self) -> usize {
  function bits_read (line 17) | pub fn bits_read(&self) -> usize {
  function return_bits (line 21) | pub fn return_bits(&mut self, n: usize) {
  function get_bits (line 28) | pub fn get_bits(&mut self, n: usize) -> Result<u64, GetBitsError> {
  type GetBitsError (line 96) | pub enum GetBitsError {
    method fmt (line 111) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

FILE: ruzstd/src/bit_io/bit_reader_reverse.rs
  type BitReaderReversed (line 6) | pub struct BitReaderReversed<'s> {
  function bits_remaining (line 27) | pub fn bits_remaining(&self) -> isize {
  function new (line 31) | pub fn new(source: &'s [u8]) -> BitReaderReversed<'s> {
  function refill (line 43) | fn refill(&mut self) {
  function get_bits (line 92) | pub fn get_bits(&mut self, n: u8) -> u64 {
  function peek_bits (line 105) | pub fn peek_bits(&mut self, n: u8) -> u64 {
  function peek_bits_triple (line 118) | pub fn peek_bits_triple(&mut self, sum: u8, n1: u8, n2: u8, n3: u8) -> (...
  function consume (line 144) | pub fn consume(&mut self, n: u8) {
  function get_bits_triple (line 151) | pub fn get_bits_triple(&mut self, n1: u8, n2: u8, n3: u8) -> (u64, u64, ...
  function it_works (line 169) | fn it_works() {

FILE: ruzstd/src/bit_io/bit_writer.rs
  type BitWriter (line 7) | pub(crate) struct BitWriter<V: AsMut<Vec<u8>>> {
  function new (line 20) | pub fn new() -> Self {
  function from (line 32) | pub fn from(mut output: V) -> BitWriter<V> {
  function index (line 42) | pub fn index(&self) -> usize {
  function reset_to (line 47) | pub fn reset_to(&mut self, index: usize) {
  function change_bits (line 57) | pub fn change_bits(&mut self, idx: usize, bits: impl Into<u64>, num_bits...
  function change_bits_64 (line 62) | pub fn change_bits_64(&mut self, mut idx: usize, mut bits: u64, mut num_...
  function append_bytes (line 105) | pub fn append_bytes(&mut self, data: &[u8]) {
  function flush (line 115) | pub fn flush(&mut self) {
  function write_bits (line 127) | pub fn write_bits(&mut self, bits: impl Into<u64>, num_bits: usize) {
  function write_bits_64_cold (line 134) | fn write_bits_64_cold(&mut self, bits: u64, num_bits: usize) {
  function write_bits_64 (line 170) | pub fn write_bits_64(&mut self, bits: u64, num_bits: usize) {
  function dump (line 195) | pub fn dump(mut self) -> V {
  function misaligned (line 205) | pub fn misaligned(&self) -> usize {
  function from_existing (line 221) | fn from_existing() {
  function change_bits (line 231) | fn change_bits() {
  function single_byte_written_4_4 (line 244) | fn single_byte_written_4_4() {
  function single_byte_written_3_5 (line 259) | fn single_byte_written_3_5() {
  function single_byte_written_1_7 (line 270) | fn single_byte_written_1_7() {
  function single_byte_written_8 (line 281) | fn single_byte_written_8() {
  function multi_byte_clean_boundary_4_4_4_4 (line 291) | fn multi_byte_clean_boundary_4_4_4_4() {
  function multi_byte_clean_boundary_16_8 (line 302) | fn multi_byte_clean_boundary_16_8() {
  function multi_byte_boundary_crossed_4_12 (line 311) | fn multi_byte_boundary_crossed_4_12() {
  function multi_byte_boundary_crossed_4_5_7 (line 320) | fn multi_byte_boundary_crossed_4_5_7() {
  function multi_byte_boundary_crossed_1_9_6 (line 330) | fn multi_byte_boundary_crossed_1_9_6() {
  function catches_unaligned_dump (line 341) | fn catches_unaligned_dump() {
  function catches_dirty_upper_bits (line 351) | fn catches_dirty_upper_bits() {
  function add_multiple_aligned (line 357) | fn add_multiple_aligned() {

FILE: ruzstd/src/blocks/block.rs
  type BlockType (line 5) | pub enum BlockType {
    method fmt (line 19) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fm...
  type BlockHeader (line 31) | pub struct BlockHeader {

FILE: ruzstd/src/blocks/literals_section.rs
  type LiteralsSection (line 9) | pub struct LiteralsSection {
    method new (line 56) | pub fn new() -> LiteralsSection {
    method header_bytes_needed (line 66) | pub fn header_bytes_needed(&self, first_byte: u8) -> Result<u8, Litera...
    method parse_from_header (line 117) | pub fn parse_from_header(&mut self, raw: &[u8]) -> Result<u8, Literals...
    method section_type (line 226) | fn section_type(raw: u8) -> Result<LiteralsSectionType, LiteralsSectio...
  type LiteralsSectionType (line 31) | pub enum LiteralsSectionType {
  method default (line 49) | fn default() -> Self {

FILE: ruzstd/src/blocks/sequence_section.rs
  constant MAX_LITERAL_LENGTH_CODE (line 6) | pub(crate) const MAX_LITERAL_LENGTH_CODE: u8 = 35;
  constant MAX_MATCH_LENGTH_CODE (line 7) | pub(crate) const MAX_MATCH_LENGTH_CODE: u8 = 52;
  constant MAX_OFFSET_CODE (line 8) | pub(crate) const MAX_OFFSET_CODE: u8 = 31;
  type SequencesHeader (line 10) | pub struct SequencesHeader {
    method new (line 100) | pub fn new() -> SequencesHeader {
    method parse_from_header (line 108) | pub fn parse_from_header(&mut self, source: &[u8]) -> Result<u8, Seque...
  type Sequence (line 21) | pub struct Sequence {
    method fmt (line 40) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fm...
  type CompressionModes (line 47) | pub struct CompressionModes(u8);
    method decode_mode (line 67) | pub fn decode_mode(m: u8) -> ModeType {
    method ll_mode (line 77) | pub fn ll_mode(self) -> ModeType {
    method of_mode (line 82) | pub fn of_mode(self) -> ModeType {
    method ml_mode (line 87) | pub fn ml_mode(self) -> ModeType {
  type ModeType (line 49) | pub enum ModeType {
  method default (line 93) | fn default() -> Self {

FILE: ruzstd/src/common/mod.rs
  constant MAGIC_NUM (line 6) | pub const MAGIC_NUM: u32 = 0xFD2F_B528;
  constant MIN_WINDOW_SIZE (line 10) | pub const MIN_WINDOW_SIZE: u64 = 1024;
  constant MAX_WINDOW_SIZE (line 14) | pub const MAX_WINDOW_SIZE: u64 = (1 << 41) + 7 * (1 << 38);
  constant MAX_BLOCK_SIZE (line 21) | pub const MAX_BLOCK_SIZE: u32 = 128 * 1024;

FILE: ruzstd/src/decoding/block_decoder.rs
  type BlockDecoder (line 18) | pub struct BlockDecoder {
    method decode_block_content (line 39) | pub fn decode_block_content(
    method decompress_block (line 123) | fn decompress_block(
    method read_block_header (line 227) | pub fn read_block_header(
    method reset_buffer (line 275) | fn reset_buffer(&mut self) {
    method is_last (line 281) | fn is_last(&self) -> bool {
    method block_type (line 285) | fn block_type(&self) -> Result<BlockType, BlockTypeError> {
    method block_content_size (line 296) | fn block_content_size(&self) -> Result<u32, BlockSizeError> {
    method block_content_size_unchecked (line 305) | fn block_content_size_unchecked(&self) -> u32 {
  type DecoderState (line 23) | enum DecoderState {
  function new (line 31) | pub fn new() -> BlockDecoder {

FILE: ruzstd/src/decoding/decode_buffer.rs
  type DecodeBuffer (line 9) | pub struct DecodeBuffer {
    method new (line 35) | pub fn new(window_size: usize) -> DecodeBuffer {
    method reset (line 46) | pub fn reset(&mut self, window_size: usize) {
    method len (line 58) | pub fn len(&self) -> usize {
    method push (line 62) | pub fn push(&mut self, data: &[u8]) {
    method repeat (line 67) | pub fn repeat(&mut self, offset: usize, match_length: usize) -> Result...
    method repeat_in_chunks (line 101) | fn repeat_in_chunks(&mut self, offset: usize, match_length: usize, sta...
    method repeat_from_dict (line 132) | fn repeat_from_dict(
    method can_drain_to_window_size (line 170) | pub fn can_drain_to_window_size(&self) -> Option<usize> {
    method can_drain (line 179) | pub fn can_drain(&self) -> usize {
    method drain_to_window_size (line 185) | pub fn drain_to_window_size(&mut self) -> Option<Vec<u8>> {
    method drain_to_window_size_writer (line 201) | pub fn drain_to_window_size_writer(&mut self, mut sink: impl Write) ->...
    method drain (line 209) | pub fn drain(&mut self) -> Vec<u8> {
    method drain_to_writer (line 224) | pub fn drain_to_writer(&mut self, mut sink: impl Write) -> Result<usiz...
    method read_all (line 229) | pub fn read_all(&mut self, target: &mut [u8]) -> Result<usize, Error> {
    method drain_to (line 244) | fn drain_to(
  method read (line 20) | fn read(&mut self, target: &mut [u8]) -> Result<usize, Error> {
  function write_all_bytes (line 306) | fn write_all_bytes(mut sink: impl Write, buf: &[u8]) -> (usize, Result<(...
  function short_writer (line 328) | fn short_writer() {
  function wouldblock_writer (line 375) | fn wouldblock_writer() {

FILE: ruzstd/src/decoding/dictionary.rs
  type Dictionary (line 12) | pub struct Dictionary {
    method decode_dict (line 45) | pub fn decode_dict(raw: &[u8]) -> Result<Dictionary, DictionaryDecodeE...
  constant MAGIC_NUM (line 40) | pub const MAGIC_NUM: [u8; 4] = [0x37, 0xA4, 0x30, 0xEC];

FILE: ruzstd/src/decoding/errors.rs
  type FrameDescriptorError (line 14) | pub enum FrameDescriptorError {
    method fmt (line 19) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FrameHeaderError (line 34) | pub enum FrameHeaderError {
    method fmt (line 45) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 88) | fn from(error: FrameDescriptorError) -> Self {
  method source (line 79) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type ReadFrameHeaderError (line 95) | pub enum ReadFrameHeaderError {
    method fmt (line 107) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 149) | fn from(error: FrameDescriptorError) -> Self {
  method source (line 135) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type BlockHeaderReadError (line 156) | pub enum BlockHeaderReadError {
    method source (line 165) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 176) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    method from (line 192) | fn from(val: Error) -> Self {
    method from (line 198) | fn from(val: BlockTypeError) -> Self {
    method from (line 204) | fn from(val: BlockSizeError) -> Self {
  type BlockTypeError (line 211) | pub enum BlockTypeError {
    method fmt (line 219) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type BlockSizeError (line 232) | pub enum BlockSizeError {
    method fmt (line 240) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type DecompressBlockError (line 256) | pub enum DecompressBlockError {
    method source (line 271) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 285) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 308) | fn from(val: Error) -> Self {
    method from (line 314) | fn from(val: DecompressLiteralsError) -> Self {
    method from (line 320) | fn from(val: LiteralsSectionParseError) -> Self {
    method from (line 326) | fn from(val: SequencesHeaderParseError) -> Self {
    method from (line 332) | fn from(val: DecodeSequenceError) -> Self {
    method from (line 338) | fn from(val: ExecuteSequencesError) -> Self {
  type DecodeBlockContentError (line 345) | pub enum DecodeBlockContentError {
    method source (line 354) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 364) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 386) | fn from(val: DecompressBlockError) -> Self {
  type DecodeBufferError (line 393) | pub enum DecodeBufferError {
    method fmt (line 402) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type DictionaryDecodeError (line 419) | pub enum DictionaryDecodeError {
    method source (line 427) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 437) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 454) | fn from(val: FSETableError) -> Self {
    method from (line 460) | fn from(val: HuffmanTableError) -> Self {
  type FrameDecoderError (line 467) | pub enum FrameDecoderError {
    method fmt (line 501) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    method from (line 558) | fn from(val: DictionaryDecodeError) -> Self {
    method from (line 564) | fn from(val: BlockHeaderReadError) -> Self {
    method from (line 570) | fn from(val: FrameHeaderError) -> Self {
    method from (line 576) | fn from(val: ReadFrameHeaderError) -> Self {
  method source (line 485) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type DecompressLiteralsError (line 583) | pub enum DecompressLiteralsError {
    method source (line 599) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 609) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 661) | fn from(val: HuffmanDecoderError) -> Self {
    method from (line 667) | fn from(val: GetBitsError) -> Self {
    method from (line 673) | fn from(val: HuffmanTableError) -> Self {
  type ExecuteSequencesError (line 680) | pub enum ExecuteSequencesError {
    method fmt (line 687) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method source (line 707) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method from (line 716) | fn from(val: DecodeBufferError) -> Self {
  type DecodeSequenceError (line 723) | pub enum DecodeSequenceError {
    method source (line 740) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 751) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 794) | fn from(val: GetBitsError) -> Self {
    method from (line 800) | fn from(val: FSETableError) -> Self {
    method from (line 806) | fn from(val: FSEDecoderError) -> Self {
  type LiteralsSectionParseError (line 813) | pub enum LiteralsSectionParseError {
    method source (line 821) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 829) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 849) | fn from(val: GetBitsError) -> Self {
  method fmt (line 855) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt:...
  type SequencesHeaderParseError (line 867) | pub enum SequencesHeaderParseError {
    method fmt (line 875) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type FSETableError (line 889) | pub enum FSETableError {
    method source (line 908) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 917) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 947) | fn from(val: GetBitsError) -> Self {
  type FSEDecoderError (line 954) | pub enum FSEDecoderError {
    method source (line 961) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 970) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 981) | fn from(val: GetBitsError) -> Self {
  type HuffmanTableError (line 988) | pub enum HuffmanTableError {
    method fmt (line 1040) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    method from (line 1107) | fn from(val: GetBitsError) -> Self {
    method from (line 1113) | fn from(val: FSEDecoderError) -> Self {
    method from (line 1119) | fn from(val: FSETableError) -> Self {
  method source (line 1029) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type HuffmanDecoderError (line 1126) | pub enum HuffmanDecoderError {
    method fmt (line 1131) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 1148) | fn from(val: GetBitsError) -> Self {
  method source (line 1140) | fn source(&self) -> Option<&(dyn StdError + 'static)> {

FILE: ruzstd/src/decoding/frame.rs
  function read_frame_header (line 6) | pub fn read_frame_header(mut r: impl Read) -> Result<(FrameHeader, u8), ...
  type FrameHeader (line 88) | pub struct FrameHeader {
    method window_size (line 116) | pub fn window_size(&self) -> Result<u64, FrameHeaderError> {
    method dictionary_id (line 142) | pub fn dictionary_id(&self) -> Option<u32> {
    method frame_content_size (line 147) | pub fn frame_content_size(&self) -> u64 {
  type FrameDescriptor (line 154) | pub struct FrameDescriptor(pub u8);
    method frame_content_size_flag (line 173) | pub fn frame_content_size_flag(&self) -> u8 {
    method reserved_flag (line 180) | pub fn reserved_flag(&self) -> bool {
    method single_segment_flag (line 188) | pub fn single_segment_flag(&self) -> bool {
    method content_checksum_flag (line 193) | pub fn content_checksum_flag(&self) -> bool {
    method dict_id_flag (line 206) | pub fn dict_id_flag(&self) -> u8 {
    method frame_content_size_bytes (line 213) | pub fn frame_content_size_bytes(&self) -> Result<u8, FrameDescriptorEr...
    method dictionary_id_bytes (line 232) | pub fn dictionary_id_bytes(&self) -> Result<u8, FrameDescriptorError> {

FILE: ruzstd/src/decoding/frame_decoder.rs
  constant MAXIMUM_ALLOWED_WINDOW_SIZE (line 19) | const MAXIMUM_ALLOWED_WINDOW_SIZE: u64 = 1024 * 1024 * 100;
  type FrameDecoder (line 74) | pub struct FrameDecoder {
    method new (line 141) | pub fn new() -> FrameDecoder {
    method init (line 154) | pub fn init(&mut self, source: impl Read) -> Result<(), FrameDecoderEr...
    method reset (line 164) | pub fn reset(&mut self, source: impl Read) -> Result<(), FrameDecoderE...
    method add_dict (line 188) | pub fn add_dict(&mut self, dict: Dictionary) -> Result<(), FrameDecode...
    method force_dict (line 193) | pub fn force_dict(&mut self, dict_id: u32) -> Result<(), FrameDecoderE...
    method content_size (line 210) | pub fn content_size(&self) -> u64 {
    method get_checksum_from_data (line 218) | pub fn get_checksum_from_data(&self) -> Option<u32> {
    method get_calculated_checksum (line 230) | pub fn get_calculated_checksum(&self) -> Option<u32> {
    method bytes_read_from_source (line 243) | pub fn bytes_read_from_source(&self) -> u64 {
    method is_finished (line 254) | pub fn is_finished(&self) -> bool {
    method blocks_decoded (line 267) | pub fn blocks_decoded(&self) -> usize {
    method decode_blocks (line 279) | pub fn decode_blocks(
    method collect (line 351) | pub fn collect(&mut self) -> Option<Vec<u8>> {
    method collect_to_writer (line 363) | pub fn collect_to_writer(&mut self, w: impl Write) -> Result<usize, Er...
    method can_collect (line 379) | pub fn can_collect(&self) -> usize {
    method decode_from_to (line 409) | pub fn decode_from_to(
    method decode_all (line 511) | pub fn decode_all(
    method decode_all_to_vec (line 561) | pub fn decode_all_to_vec(
  type FrameDecoderState (line 79) | struct FrameDecoderState {
    method new (line 96) | pub fn new(source: impl Read) -> Result<FrameDecoderState, FrameDecode...
    method reset (line 110) | pub fn reset(&mut self, source: impl Read) -> Result<(), FrameDecoderE...
  type BlockDecodingStrategy (line 89) | pub enum BlockDecodingStrategy {
  method default (line 132) | fn default() -> Self {
  method read (line 586) | fn read(&mut self, target: &mut [u8]) -> Result<usize, Error> {

FILE: ruzstd/src/decoding/literals_section_decoder.rs
  function decode_literals (line 12) | pub fn decode_literals(
  function decompress_literals (line 40) | fn decompress_literals(

FILE: ruzstd/src/decoding/ringbuffer.rs
  type RingBuffer (line 4) | pub struct RingBuffer {
    method new (line 29) | pub fn new() -> Self {
    method len (line 41) | pub fn len(&self) -> usize {
    method free (line 47) | pub fn free(&self) -> usize {
    method clear (line 53) | pub fn clear(&mut self) {
    method reserve (line 61) | pub fn reserve(&mut self, amount: usize) {
    method reserve_amortized (line 72) | fn reserve_amortized(&mut self, amount: usize) {
    method push_back (line 125) | pub fn push_back(&mut self, byte: u8) {
    method get (line 137) | pub fn get(&self, idx: usize) -> Option<u8> {
    method extend (line 148) | pub fn extend(&mut self, data: &[u8]) {
    method drop_first_n (line 185) | pub fn drop_first_n(&mut self, amount: usize) {
    method data_slice_lengths (line 196) | fn data_slice_lengths(&self) -> (usize, usize) {
    method data_slice_parts (line 213) | fn data_slice_parts(&self) -> ((*const u8, usize), (*const u8, usize)) {
    method as_slices (line 223) | pub fn as_slices(&self) -> (&[u8], &[u8]) {
    method free_slice_lengths (line 236) | fn free_slice_lengths(&self) -> (usize, usize) {
    method free_slice_parts (line 255) | fn free_slice_parts(&self) -> ((*mut u8, usize), (*mut u8, usize)) {
    method extend_from_within (line 266) | pub fn extend_from_within(&mut self, start: usize, len: usize) {
    method extend_from_within_unchecked (line 292) | pub unsafe fn extend_from_within_unchecked(&mut self, start: usize, le...
    method extend_from_within_unchecked_branchless (line 472) | pub unsafe fn extend_from_within_unchecked_branchless(&mut self, start...
  method drop (line 527) | fn drop(&mut self) {
  function copy_bytes_overshooting (line 556) | unsafe fn copy_bytes_overshooting(
  function copy_without_checks (line 607) | unsafe fn copy_without_checks(
  function copy_with_checks (line 631) | unsafe fn copy_with_checks(
  function copy_with_nobranch_check (line 663) | unsafe fn copy_with_nobranch_check(
  function smoke (line 749) | fn smoke() {
  function edge_cases (line 802) | fn edge_cases() {

FILE: ruzstd/src/decoding/scratch.rs
  type DecoderScratch (line 15) | pub struct DecoderScratch {
    method new (line 30) | pub fn new(window_size: usize) -> DecoderScratch {
    method reset (line 52) | pub fn reset(&mut self, window_size: usize) {
    method init_from_dict (line 70) | pub fn init_from_dict(&mut self, dict: &Dictionary) {
  type HuffmanScratch (line 81) | pub struct HuffmanScratch {
    method new (line 86) | pub fn new() -> HuffmanScratch {
  method default (line 94) | fn default() -> Self {
  type FSEScratch (line 99) | pub struct FSEScratch {
    method new (line 109) | pub fn new() -> FSEScratch {
    method reinit_from (line 120) | pub fn reinit_from(&mut self, other: &Self) {
  method default (line 131) | fn default() -> Self {

FILE: ruzstd/src/decoding/sequence_execution.rs
  function execute_sequences (line 5) | pub fn execute_sequences(scratch: &mut DecoderScratch) -> Result<(), Exe...
  function do_offset_history (line 59) | fn do_offset_history(offset_value: u32, lit_len: u32, scratch: &mut [u32...

FILE: ruzstd/src/decoding/sequence_section_decoder.rs
  function decode_sequences (line 14) | pub fn decode_sequences(
  function decode_sequences_with_rle (line 49) | fn decode_sequences_with_rle(
  function decode_sequences_without_rle (line 154) | fn decode_sequences_without_rle(
  function lookup_ll_code (line 227) | fn lookup_ll_code(code: u8) -> (u32, u8) {
  function lookup_ml_code (line 258) | fn lookup_ml_code(code: u8) -> (u32, u8) {
  constant LL_MAX_LOG (line 288) | pub const LL_MAX_LOG: u8 = 9;
  constant ML_MAX_LOG (line 290) | pub const ML_MAX_LOG: u8 = 9;
  constant OF_MAX_LOG (line 292) | pub const OF_MAX_LOG: u8 = 8;
  function maybe_update_fse_tables (line 294) | fn maybe_update_fse_tables(
  constant LL_DEFAULT_ACC_LOG (line 413) | const LL_DEFAULT_ACC_LOG: u8 = 6;
  constant LITERALS_LENGTH_DEFAULT_DISTRIBUTION (line 418) | const LITERALS_LENGTH_DEFAULT_DISTRIBUTION: [i32; 36] = [
  constant ML_DEFAULT_ACC_LOG (line 424) | const ML_DEFAULT_ACC_LOG: u8 = 6;
  constant MATCH_LENGTH_DEFAULT_DISTRIBUTION (line 429) | const MATCH_LENGTH_DEFAULT_DISTRIBUTION: [i32; 53] = [
  constant OF_DEFAULT_ACC_LOG (line 435) | const OF_DEFAULT_ACC_LOG: u8 = 5;
  constant OFFSET_DEFAULT_DISTRIBUTION (line 440) | const OFFSET_DEFAULT_DISTRIBUTION: [i32; 29] = [
  function test_ll_default (line 445) | fn test_ll_default() {

FILE: ruzstd/src/decoding/streaming_decoder.rs
  type StreamingDecoder (line 45) | pub struct StreamingDecoder<READ: Read, DEC: BorrowMut<FrameDecoder>> {
  function new_with_decoder (line 51) | pub fn new_with_decoder(
  function new (line 61) | pub fn new(
  function get_ref (line 72) | pub fn get_ref(&self) -> &READ {
  function get_mut (line 79) | pub fn get_mut(&mut self) -> &mut READ {
  function into_inner (line 84) | pub fn into_inner(self) -> READ
  function into_parts (line 92) | pub fn into_parts(self) -> (READ, DEC)
  function into_frame_decoder (line 100) | pub fn into_frame_decoder(self) -> DEC {
  method read (line 106) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {

FILE: ruzstd/src/dictionary/cover.rs
  constant K (line 17) | pub(super) const K: usize = 16;
  type KMer (line 23) | pub(super) type KMer = [u8; K];
  type Segment (line 25) | pub struct Segment {
  method eq (line 38) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 45) | fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
  method cmp (line 51) | fn cmp(&self, other: &Self) -> core::cmp::Ordering {
  type Context (line 58) | pub struct Context {
  function pick_best_segment (line 67) | pub fn pick_best_segment(
  function score_segment (line 95) | fn score_segment(ctx: &mut Context, collection_sample: &[u8], segment: &...
  function compute_epoch_info (line 119) | pub fn compute_epoch_info(

FILE: ruzstd/src/dictionary/frequency.rs
  function estimate_frequency (line 8) | pub fn estimate_frequency(pattern: &[u8], body: &[u8]) -> usize {
  function dead_beef (line 52) | fn dead_beef() {
  function smallest_body (line 60) | fn smallest_body() {
  function no_match (line 65) | fn no_match() {

FILE: ruzstd/src/dictionary/mod.rs
  type DictParams (line 47) | pub(super) struct DictParams {
  function create_raw_dict_from_dir (line 77) | pub fn create_raw_dict_from_dir<P: AsRef<Path>, W: io::Write>(
  function create_raw_dict_from_source (line 128) | pub fn create_raw_dict_from_source<R: io::Read, W: io::Write>(

FILE: ruzstd/src/dictionary/reservoir.rs
  function create_sample (line 8) | pub fn create_sample<R: io::Read>(input: &mut R, size: usize) -> Vec<u8> {
  type Reservoir (line 17) | struct Reservoir {
    method new (line 32) | pub fn new(size: usize) -> Self {
    method fill (line 42) | pub fn fill<R: io::Read>(mut self, source: &mut R) -> Vec<u8> {
  function initial_fill (line 116) | fn initial_fill() {
  function shrinks_for_small_sample (line 126) | fn shrinks_for_small_sample() {
  function lake_doesnt_grow (line 136) | fn lake_doesnt_grow() {

FILE: ruzstd/src/encoding/block_header.rs
  type BlockHeader (line 5) | pub struct BlockHeader {
    method serialize (line 24) | pub fn serialize(self, output: &mut Vec<u8>) {
  function block_header_serialize (line 46) | fn block_header_serialize() {

FILE: ruzstd/src/encoding/blocks/compressed.rs
  function compress_block (line 12) | pub fn compress_block<M: Matcher>(state: &mut CompressState<M>, output: ...
  type FseTableMode (line 103) | enum FseTableMode<'a> {
  function as_ref (line 110) | pub fn as_ref(&self) -> &FSETable {
  function choose_table (line 119) | fn choose_table<'a>(
  function encode_table (line 137) | fn encode_table(mode: &FseTableMode<'_>, writer: &mut BitWriter<&mut Vec...
  function encode_fse_table_modes (line 145) | fn encode_fse_table_modes(
  function encode_sequences (line 160) | fn encode_sequences(
  function encode_seqnum (line 223) | fn encode_seqnum(seqnum: usize, writer: &mut BitWriter<impl AsMut<Vec<u8...
  function encode_literal_length (line 245) | fn encode_literal_length(len: u32) -> (u8, u32, usize) {
  function encode_match_len (line 272) | fn encode_match_len(len: u32) -> (u8, u32, usize) {
  function encode_offset (line 301) | fn encode_offset(len: u32) -> (u8, u32, usize) {
  function raw_literals (line 307) | fn raw_literals(literals: &[u8], writer: &mut BitWriter<&mut Vec<u8>>) {
  function compress_literals (line 314) | fn compress_literals(

FILE: ruzstd/src/encoding/frame_compressor.rs
  type FrameCompressor (line 38) | pub struct FrameCompressor<R: Read, W: Write, M: Matcher> {
  type FseTables (line 47) | pub(crate) struct FseTables {
    method new (line 57) | pub fn new() -> Self {
  type CompressState (line 69) | pub(crate) struct CompressState<M: Matcher> {
  function new (line 77) | pub fn new(compression_level: CompressionLevel) -> Self {
  function new_with_matcher (line 95) | pub fn new_with_matcher(matcher: M, compression_level: CompressionLevel)...
  function set_source (line 113) | pub fn set_source(&mut self, uncompressed_data: R) -> Option<R> {
  function set_drain (line 120) | pub fn set_drain(&mut self, compressed_data: W) -> Option<W> {
  function compress (line 131) | pub fn compress(&mut self) {
  function source_mut (line 227) | pub fn source_mut(&mut self) -> Option<&mut R> {
  function drain_mut (line 232) | pub fn drain_mut(&mut self) -> Option<&mut W> {
  function source (line 237) | pub fn source(&self) -> Option<&R> {
  function drain (line 242) | pub fn drain(&self) -> Option<&W> {
  function take_source (line 247) | pub fn take_source(&mut self) -> Option<R> {
  function take_drain (line 252) | pub fn take_drain(&mut self) -> Option<W> {
  function replace_matcher (line 257) | pub fn replace_matcher(&mut self, mut match_generator: M) -> M {
  function set_compression_level (line 263) | pub fn set_compression_level(
  function compression_level (line 273) | pub fn compression_level(&self) -> CompressionLevel {
  function frame_starts_with_magic_num (line 288) | fn frame_starts_with_magic_num() {
  function very_simple_raw_compress (line 300) | fn very_simple_raw_compress() {
  function very_simple_compress (line 311) | fn very_simple_compress() {
  function rle_compress (line 335) | fn rle_compress() {
  function aaa_compress (line 351) | fn aaa_compress() {
  function checksum_two_frames_reused_compressor (line 372) | fn checksum_two_frames_reused_compressor() {
  function fuzz_targets (line 436) | fn fuzz_targets() {

FILE: ruzstd/src/encoding/frame_header.rs
  type FrameHeader (line 11) | pub struct FrameHeader {
    method serialize (line 34) | pub fn serialize(self, output: &mut Vec<u8>) {
    method descriptor (line 65) | fn descriptor(&self) -> u8 {
  function minify_val_fcs (line 154) | fn minify_val_fcs(val: u64) -> Vec<u8> {
  function frame_header_descriptor_decode (line 170) | fn frame_header_descriptor_decode() {
  function frame_header_decode (line 186) | fn frame_header_decode() {
  function catches_single_segment_no_fcs (line 204) | fn catches_single_segment_no_fcs() {
  function catches_single_segment_no_winsize (line 219) | fn catches_single_segment_no_winsize() {

FILE: ruzstd/src/encoding/levels/fastest.rs
  function compress_fastest (line 20) | pub fn compress_fastest<M: Matcher>(

FILE: ruzstd/src/encoding/match_generator.rs
  constant MIN_MATCH_LEN (line 15) | const MIN_MATCH_LEN: usize = 5;
  type MatchGeneratorDriver (line 18) | pub struct MatchGeneratorDriver {
    method new (line 28) | pub(crate) fn new(slice_size: usize, max_slices_in_window: usize) -> S...
  method reset (line 39) | fn reset(&mut self, _level: CompressionLevel) {
  method window_size (line 52) | fn window_size(&self) -> u64 {
  method get_next_space (line 56) | fn get_next_space(&mut self) -> Vec<u8> {
  method get_last_space (line 64) | fn get_last_space(&mut self) -> &[u8] {
  method commit_space (line 68) | fn commit_space(&mut self, space: Vec<u8>) {
  method start_matching (line 85) | fn start_matching(&mut self, mut handle_sequence: impl for<'a> FnMut(Seq...
  method skip_matching (line 88) | fn skip_matching(&mut self) {
  type SuffixStore (line 95) | struct SuffixStore {
    method with_capacity (line 104) | fn with_capacity(capacity: usize) -> Self {
    method insert (line 112) | fn insert(&mut self, suffix: &[u8], idx: usize) {
    method contains_key (line 118) | fn contains_key(&self, suffix: &[u8]) -> bool {
    method get (line 124) | fn get(&self, suffix: &[u8]) -> Option<usize> {
    method key (line 130) | fn key(&self, suffix: &[u8]) -> usize {
  type WindowEntry (line 153) | struct WindowEntry {
  type MatchGenerator (line 161) | pub(crate) struct MatchGenerator {
    method new (line 177) | fn new(max_size: usize) -> Self {
    method reset (line 189) | fn reset(&mut self, mut reuse_space: impl FnMut(Vec<u8>, SuffixStore)) {
    method next_sequence (line 204) | fn next_sequence(&mut self, mut handle_sequence: impl for<'a> FnMut(Se...
    method common_prefix_len (line 309) | fn common_prefix_len(a: &[u8], b: &[u8]) -> usize {
    method mismatch_chunks (line 315) | fn mismatch_chunks<const N: usize>(xs: &[u8], ys: &[u8]) -> usize {
    method add_suffixes_till (line 327) | fn add_suffixes_till(&mut self, idx: usize) {
    method skip_matching (line 341) | fn skip_matching(&mut self) {
    method add_data (line 350) | fn add_data(
    method reserve (line 382) | fn reserve(&mut self, amount: usize, mut reuse_space: impl FnMut(Vec<u...
  function matches (line 401) | fn matches() {

FILE: ruzstd/src/encoding/mod.rs
  function compress (line 24) | pub fn compress<R: Read, W: Write>(source: R, target: W, level: Compress...
  function compress_to_vec (line 37) | pub fn compress_to_vec<R: Read>(source: R, level: CompressionLevel) -> V...
  type CompressionLevel (line 47) | pub enum CompressionLevel {
  type Matcher (line 84) | pub trait Matcher {
    method get_next_space (line 86) | fn get_next_space(&mut self) -> alloc::vec::Vec<u8>;
    method get_last_space (line 88) | fn get_last_space(&mut self) -> &[u8];
    method commit_space (line 90) | fn commit_space(&mut self, space: alloc::vec::Vec<u8>);
    method skip_matching (line 92) | fn skip_matching(&mut self);
    method start_matching (line 94) | fn start_matching(&mut self, handle_sequence: impl for<'a> FnMut(Seque...
    method reset (line 96) | fn reset(&mut self, level: CompressionLevel);
    method window_size (line 100) | fn window_size(&self) -> u64;
  type Sequence (line 105) | pub enum Sequence<'data> {

FILE: ruzstd/src/encoding/util.rs
  function find_min_size (line 7) | pub fn find_min_size(val: u64) -> usize {
  function minify_val (line 27) | pub fn minify_val(val: u64) -> Vec<u8> {
  function min_size_detection (line 39) | fn min_size_detection() {
  function bytes_minified (line 50) | fn bytes_minified() {

FILE: ruzstd/src/fse/fse_decoder.rs
  type FSEDecoder (line 5) | pub struct FSEDecoder<'table> {
  function new (line 14) | pub fn new(table: &'t FSETable) -> FSEDecoder<'t> {
  function decode_symbol (line 26) | pub fn decode_symbol(&self) -> u8 {
  function init_state (line 32) | pub fn init_state(&mut self, bits: &mut BitReaderReversed<'_>) -> Result...
  function update_state (line 43) | pub fn update_state(&mut self, bits: &mut BitReaderReversed<'_>) {
  type FSETable (line 59) | pub struct FSETable {
    method new (line 87) | pub fn new(max_symbol: u8) -> FSETable {
    method reinit_from (line 98) | pub fn reinit_from(&mut self, other: &Self) {
    method reset (line 108) | pub fn reset(&mut self) {
    method build_decoder (line 116) | pub fn build_decoder(&mut self, source: &[u8], max_log: u8) -> Result<...
    method build_from_probabilities (line 126) | pub fn build_from_probabilities(
    method build_decoding_table (line 141) | fn build_decoding_table(&mut self) -> Result<(), FSETableError> {
    method read_probabilities (line 224) | fn read_probabilities(&mut self, source: &[u8], max_log: u8) -> Result...
  type Entry (line 312) | pub struct Entry {
  constant ACC_LOG_OFFSET (line 324) | const ACC_LOG_OFFSET: u8 = 5;
  function highest_bit_set (line 326) | fn highest_bit_set(x: u32) -> u32 {
  function next_position (line 334) | fn next_position(mut p: usize, table_size: usize) -> usize {
  function calc_baseline_and_numbits (line 340) | fn calc_baseline_and_numbits(

FILE: ruzstd/src/fse/fse_encoder.rs
  type FSEEncoder (line 4) | pub(crate) struct FSEEncoder<'output, V: AsMut<Vec<u8>>> {
  function new (line 10) | pub fn new(table: FSETable, writer: &mut BitWriter<V>) -> FSEEncoder<'_,...
  function into_table (line 15) | pub fn into_table(self) -> FSETable {
  function encode (line 26) | pub fn encode(&mut self, data: &[u8]) {
  function encode_interleaved (line 53) | pub fn encode_interleaved(&mut self, data: &[u8]) {
  function write_table (line 115) | fn write_table(&mut self) {
  function acc_log (line 119) | pub(super) fn acc_log(&self) -> u8 {
  type FSETable (line 125) | pub struct FSETable {
    method next_state (line 133) | pub(crate) fn next_state(&self, symbol: u8, idx: usize) -> &State {
    method start_state (line 138) | pub(crate) fn start_state(&self, symbol: u8) -> &State {
    method acc_log (line 143) | pub fn acc_log(&self) -> u8 {
    method write_table (line 147) | pub(crate) fn write_table<V: AsMut<Vec<u8>>>(&self, writer: &mut BitWr...
  type SymbolStates (line 192) | pub(super) struct SymbolStates {
    method get (line 199) | fn get(&self, idx: usize, max_idx: usize) -> &State {
  type State (line 209) | pub(crate) struct State {
    method contains (line 221) | fn contains(&self, idx: usize) -> bool {
  function build_table_from_data (line 226) | pub fn build_table_from_data(
  function build_table_from_counts (line 244) | fn build_table_from_counts(counts: &[usize], max_log: u8, avoid_0_numbit...
  function build_table_from_probabilities (line 313) | pub(super) fn build_table_from_probabilities(probs: &[i32], acc_log: u8)...
  function next_position (line 415) | fn next_position(mut p: usize, table_size: usize) -> usize {
  constant ML_DIST (line 421) | const ML_DIST: &[i32] = &[
  constant LL_DIST (line 426) | const LL_DIST: &[i32] = &[
  constant OF_DIST (line 431) | const OF_DIST: &[i32] = &[
  function default_ml_table (line 435) | pub(crate) fn default_ml_table() -> FSETable {
  function default_ll_table (line 439) | pub(crate) fn default_ll_table() -> FSETable {
  function default_of_table (line 443) | pub(crate) fn default_of_table() -> FSETable {

FILE: ruzstd/src/fse/mod.rs
  function tables_equal (line 22) | fn tables_equal() {
  function check_tables (line 32) | fn check_tables(dec_table: &fse_decoder::FSETable, enc_table: &fse_encod...
  function roundtrip (line 46) | fn roundtrip() {
  function round_trip (line 80) | pub fn round_trip(data: &[u8]) {

FILE: ruzstd/src/huff0/huff0_decoder.rs
  constant MAX_MAX_NUM_BITS (line 9) | pub(crate) const MAX_MAX_NUM_BITS: u8 = 11;
  type HuffmanDecoder (line 11) | pub struct HuffmanDecoder<'table> {
  function new (line 19) | pub fn new(table: &'t HuffmanTable) -> HuffmanDecoder<'t> {
  function decode_symbol (line 25) | pub fn decode_symbol(&mut self) -> u8 {
  function init_state (line 32) | pub fn init_state(&mut self, br: &mut BitReaderReversed<'_>) -> u8 {
  function next_state (line 41) | pub fn next_state(&mut self, br: &mut BitReaderReversed<'_>) -> u8 {
  type HuffmanTable (line 57) | pub struct HuffmanTable {
    method new (line 78) | pub fn new() -> HuffmanTable {
    method reinit_from (line 93) | pub fn reinit_from(&mut self, other: &Self) {
    method reset (line 104) | pub fn reset(&mut self) {
    method build_decoder (line 117) | pub fn build_decoder(&mut self, source: &[u8]) -> Result<u32, HuffmanT...
    method read_weights (line 132) | fn read_weights(&mut self, source: &[u8]) -> Result<u32, HuffmanTableE...
    method build_table_from_weights (line 284) | fn build_table_from_weights(&mut self) -> Result<(), HuffmanTableError> {
  method default (line 381) | fn default() -> Self {
  type Entry (line 389) | pub struct Entry {
  function highest_bit_set (line 398) | fn highest_bit_set(x: u32) -> u32 {

FILE: ruzstd/src/huff0/huff0_encoder.rs
  type HuffmanEncoder (line 9) | pub(crate) struct HuffmanEncoder<'output, 'table, V: AsMut<Vec<u8>>> {
  function new (line 15) | pub fn new<'o, 't>(
  function encode (line 27) | pub fn encode(&mut self, data: &[u8], with_table: bool) {
  function encode4x (line 39) | pub fn encode4x(&mut self, data: &[u8], with_table: bool) {
  function encode_stream (line 87) | fn encode_stream<VV: AsMut<Vec<u8>>>(
  function weights (line 106) | pub(super) fn weights(&self) -> Vec<u8> {
  function write_table (line 119) | fn write_table(&mut self) {
  type HuffmanTable (line 156) | pub struct HuffmanTable {
    method build_from_data (line 162) | pub fn build_from_data(data: &[u8]) -> Self {
    method build_from_counts (line 173) | pub fn build_from_counts(counts: &[usize]) -> Self {
    method build_from_weights (line 196) | pub fn build_from_weights(weights: &[usize]) -> Self {
    method can_encode (line 255) | pub fn can_encode(&self, other: &Self) -> Option<usize> {
  function highest_bit_set (line 271) | fn highest_bit_set(x: usize) -> usize {
  function huffman (line 277) | fn huffman() {
  function distribute_weights (line 295) | fn distribute_weights(amount: usize) -> Vec<usize> {
  function redistribute_weights (line 345) | fn redistribute_weights(weights: &mut [usize], max_num_bits: usize) {
  function weights (line 402) | fn weights() {
  function counts (line 448) | fn counts() {
  function from_data (line 475) | fn from_data() {

FILE: ruzstd/src/huff0/mod.rs
  function round_trip (line 15) | pub fn round_trip(data: &[u8]) {
  function roundtrip (line 59) | fn roundtrip() {

FILE: ruzstd/src/io_nostd.rs
  type ErrorKind (line 7) | pub enum ErrorKind {
    method as_str (line 16) | fn as_str(&self) -> &'static str {
    method fmt (line 29) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type Error (line 34) | pub struct Error {
    method fmt (line 40) | fn fmt(&self, f: &mut alloc::fmt::Formatter<'_>) -> Result<(), alloc::...
    method new (line 51) | pub fn new(kind: ErrorKind, err: Box<dyn core::fmt::Display + Send + S...
    method from (line 58) | pub fn from(kind: ErrorKind) -> Self {
    method kind (line 62) | pub fn kind(&self) -> ErrorKind {
    method is_interrupted (line 66) | pub fn is_interrupted(&self) -> bool {
    method get_ref (line 70) | pub fn get_ref(&self) -> Option<&(dyn core::fmt::Display + Send + Sync...
    method into_inner (line 74) | pub fn into_inner(self) -> Option<Box<dyn core::fmt::Display + Send + ...
    method fmt (line 80) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    method from (line 92) | fn from(value: ErrorKind) -> Self {
  type Read (line 97) | pub trait Read {
    method read (line 98) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>;
    method read_exact (line 100) | fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<(), Error> {
    method read_to_end (line 119) | fn read_to_end(&mut self, output: &mut alloc::vec::Vec<u8>) -> Result<...
    method take (line 131) | fn take(self, limit: u64) -> Take<Self>
    method read (line 140) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
    method read (line 159) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
    method read (line 192) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
  type Take (line 164) | pub struct Take<R: Read> {
  function limit (line 170) | pub fn limit(&self) -> u64 {
  function set_limit (line 174) | pub fn set_limit(&mut self, limit: u64) {
  function get_ref (line 178) | pub fn get_ref(&self) -> &R {
  function get_mut (line 182) | pub fn get_mut(&mut self) -> &mut R {
  function into_inner (line 186) | pub fn into_inner(self) -> R {
  type Write (line 204) | pub trait Write {
    method write (line 205) | fn write(&mut self, buf: &[u8]) -> Result<usize, Error>;
    method flush (line 206) | fn flush(&mut self) -> Result<(), Error>;
    method write_all (line 207) | fn write_all(&mut self, mut buf: &[u8]) -> Result<(), Error> {
    method write (line 226) | fn write(&mut self, buf: &[u8]) -> Result<usize, Error> {
    method flush (line 230) | fn flush(&mut self) -> Result<(), Error> {
    method write (line 237) | fn write(&mut self, data: &[u8]) -> Result<usize, Error> {
    method flush (line 245) | fn flush(&mut self) -> Result<(), Error> {
    method write (line 252) | fn write(&mut self, data: &[u8]) -> Result<usize, Error> {
    method flush (line 257) | fn flush(&mut self) -> Result<(), Error> {

FILE: ruzstd/src/lib.rs
  constant VERBOSE (line 24) | pub(crate) const VERBOSE: bool = false;

FILE: ruzstd/src/tests/bit_reader.rs
  function test_bitreader_reversed (line 2) | fn test_bitreader_reversed() {
  function test_bitreader_normal (line 42) | fn test_bitreader_normal() {

FILE: ruzstd/src/tests/decode_corpus.rs
  function test_decode_corpus_files (line 2) | fn test_decode_corpus_files() {

FILE: ruzstd/src/tests/dict_test.rs
  function test_dict_parsing (line 2) | fn test_dict_parsing() {
  function test_dict_decoding (line 78) | fn test_dict_decoding() {

FILE: ruzstd/src/tests/encode_corpus.rs
  function test_encode_corpus_files_uncompressed_our_decompressor (line 2) | fn test_encode_corpus_files_uncompressed_our_decompressor() {
  function test_encode_corpus_files_uncompressed_original_decompressor (line 57) | fn test_encode_corpus_files_uncompressed_original_decompressor() {
  function test_encode_corpus_files_compressed_our_decompressor (line 119) | fn test_encode_corpus_files_compressed_our_decompressor() {
  function test_encode_corpus_files_compressed_original_decompressor (line 174) | fn test_encode_corpus_files_compressed_original_decompressor() {

FILE: ruzstd/src/tests/fuzz_regressions.rs
  function test_all_artifacts (line 2) | fn test_all_artifacts() {

FILE: ruzstd/src/tests/mod.rs
  function read (line 12) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, crate::io_nostd::Err...
  function assure_error_impl (line 28) | fn assure_error_impl() {
  function assure_decoder_send_sync (line 37) | fn assure_decoder_send_sync() {
  function skippable_frame (line 48) | fn skippable_frame() {
  function test_frame_header_reading (line 81) | fn test_frame_header_reading() {
  function test_block_header_reading (line 90) | fn test_block_header_reading() {
  function test_frame_decoder (line 104) | fn test_frame_decoder() {
  function test_decode_from_to (line 130) | fn test_decode_from_to() {
  function test_specific_file (line 233) | fn test_specific_file() {
  function test_streaming (line 296) | fn test_streaming() {
  function test_incremental_read (line 383) | fn test_incremental_read() {
  function test_streaming_no_std (line 408) | fn test_streaming_no_std() {
  function test_decode_all (line 491) | fn test_decode_all() {
  function verbose_disabled (line 585) | fn verbose_disabled() {