Struct Printer

pub struct Printer<O: Write, A: AddressFormatting + Clone, B: ByteFormatting + Clone, C: CharFormatting + Clone> { /* private fields */ }

The topmost struct for data output

Implementations

impl<O: Write, A: AddressFormatting + Clone, B: ByteFormatting + Clone, C: CharFormatting + Clone> Printer<O, A, B, C>

pub fn new( out: O, start_address: usize, config: Config<A, B, C>, ) -> Printer<O, A, B, C>

Customized constructor.

All constructors of the Printer moves given output. To give it back use finish(mut self) function

out - place to ouput string.

start_address - start address to print.

config - formatting configuration.

Printer does no assumptions on start_address where to start reading data, it just recieving data chunks in push(...) function, then increments the start_address

Examples found in repository

examples/endian.rs (line 38)

fn print_data_per_byte(data: &[u8], is_little_endian: bool) {
    use std::io::stdout;

    let config = Config::new(
        Some(AddressFormatter::new(AddressStyle::Hex(16), Default::default())),
        ByteFormatter::new(
            Default::default(),
            Groupping::RepeatingGroup(Group::new(GROUP_SIZE, " - "), NUM_OF_GROUPS),
            "/",
            is_little_endian,
            Default::default()
        ),
        Some(CharFormatter::default()),
        false,
    );

    let mut printer = Printer::new(stdout(), 0 as usize, config);

    
    for s in data {
        assert!(printer
            .write(&[*s])
            .is_ok());
    }

    _ = printer.finish();
    println!("");
}

examples/custom.rs (line 25)

fn main() {
    use std::io::stdout;

    let config = Config::new(
        Some(AddressFormatter::new(
            AddressStyle::Dec(8),
            Separators::new("", &'\u{1F929}'.to_string()),
        )),
        ByteFormatter::new(
            Default::default(),
            Groupping::RepeatingGroup(Group::new(4, "#"), 4),
            "",
            false,
            Default::default(),
        ),
        Some(CharFormatter::new(
            ".".to_string(),
            Separators::new(&'\u{1F4A5}'.to_string(), &'\u{1F4A8}'.to_string()),
        )),
        true
    );
    let mut printer = Printer::new(stdout(), 0, config);

    let bytes1 = &[222u8, 173, 190, 239];
    let bytes2 = &[0xfeu8, 0xed, 0xfa];
    let title = b"Custom printing";

    for _ in 0..10 {
        _ = printer.push(bytes1);
    }

    _ = printer.push(title);

    for _ in 0..11 {
        _ = printer.push(bytes2);
    }

    printer.finish();
}

pub fn finish(self) -> O

Finalize manually. Prints last unfinished line with paddings and turns back given output

Examples found in repository

examples/simple.rs (line 23)

fn main() {
    use std::io::stdout;

    let mut printer = Printer::default_fmt_with(stdout(), 0);

    let bytes1 = &[222u8, 173, 190, 239];
    let bytes2 = &[0xfeu8, 0xed, 0xfa];
    let title = b"Simple printing";

    for _ in 0..10 {
        _ = printer.push(bytes1);
    }

    _ = printer.push(title);

    for _ in 0..11 {
        _ = printer.push(bytes2);
    }

    printer.finish();
}

examples/stdin.rs (line 29)

fn main() {
    use std::io::stdout;

    let mut buf = [0u8; 64];
    let stdin = std::io::stdin();
    let mut handle = stdin.lock();
    
    let mut printer = Printer::default_fmt_with(stdout(), 0);

    while let Ok(size) = handle.read(&mut buf) {
        if size == 0 {
            break;
        }
        assert!(printer.write_all(&mut buf[..size]).is_ok());
    }

    printer.finish();
}

examples/endian.rs (line 47)

fn print_data_per_byte(data: &[u8], is_little_endian: bool) {
    use std::io::stdout;

    let config = Config::new(
        Some(AddressFormatter::new(AddressStyle::Hex(16), Default::default())),
        ByteFormatter::new(
            Default::default(),
            Groupping::RepeatingGroup(Group::new(GROUP_SIZE, " - "), NUM_OF_GROUPS),
            "/",
            is_little_endian,
            Default::default()
        ),
        Some(CharFormatter::default()),
        false,
    );

    let mut printer = Printer::new(stdout(), 0 as usize, config);

    
    for s in data {
        assert!(printer
            .write(&[*s])
            .is_ok());
    }

    _ = printer.finish();
    println!("");
}

examples/custom.rs (line 41)

fn main() {
    use std::io::stdout;

    let config = Config::new(
        Some(AddressFormatter::new(
            AddressStyle::Dec(8),
            Separators::new("", &'\u{1F929}'.to_string()),
        )),
        ByteFormatter::new(
            Default::default(),
            Groupping::RepeatingGroup(Group::new(4, "#"), 4),
            "",
            false,
            Default::default(),
        ),
        Some(CharFormatter::new(
            ".".to_string(),
            Separators::new(&'\u{1F4A5}'.to_string(), &'\u{1F4A8}'.to_string()),
        )),
        true
    );
    let mut printer = Printer::new(stdout(), 0, config);

    let bytes1 = &[222u8, 173, 190, 239];
    let bytes2 = &[0xfeu8, 0xed, 0xfa];
    let title = b"Custom printing";

    for _ in 0..10 {
        _ = printer.push(bytes1);
    }

    _ = printer.push(title);

    for _ in 0..11 {
        _ = printer.push(bytes2);
    }

    printer.finish();
}

impl<O: Write, A: AddressFormatting + Clone, B: ByteFormatting + Clone, C: CharFormatting + Clone> Printer<O, A, B, C>

pub fn push(&mut self, bytes: &[u8]) -> Result<usize>

Accepts bytes chunk. Immediately prints first and second columns to out, third will printed after second column is completely filled, or after finalization.

Examples found in repository

examples/simple.rs (line 14)

fn main() {
    use std::io::stdout;

    let mut printer = Printer::default_fmt_with(stdout(), 0);

    let bytes1 = &[222u8, 173, 190, 239];
    let bytes2 = &[0xfeu8, 0xed, 0xfa];
    let title = b"Simple printing";

    for _ in 0..10 {
        _ = printer.push(bytes1);
    }

    _ = printer.push(title);

    for _ in 0..11 {
        _ = printer.push(bytes2);
    }

    printer.finish();
}

examples/custom.rs (line 32)

fn main() {
    use std::io::stdout;

    let config = Config::new(
        Some(AddressFormatter::new(
            AddressStyle::Dec(8),
            Separators::new("", &'\u{1F929}'.to_string()),
        )),
        ByteFormatter::new(
            Default::default(),
            Groupping::RepeatingGroup(Group::new(4, "#"), 4),
            "",
            false,
            Default::default(),
        ),
        Some(CharFormatter::new(
            ".".to_string(),
            Separators::new(&'\u{1F4A5}'.to_string(), &'\u{1F4A8}'.to_string()),
        )),
        true
    );
    let mut printer = Printer::new(stdout(), 0, config);

    let bytes1 = &[222u8, 173, 190, 239];
    let bytes2 = &[0xfeu8, 0xed, 0xfa];
    let title = b"Custom printing";

    for _ in 0..10 {
        _ = printer.push(bytes1);
    }

    _ = printer.push(title);

    for _ in 0..11 {
        _ = printer.push(bytes2);
    }

    printer.finish();
}

impl<O: Write, A: AddressFormatting + Clone + Default, B: ByteFormatting + Clone + Default, C: CharFormatting + Clone + Default> Printer<O, A, B, C>

pub fn default_with(out: O, start_address: usize) -> Printer<O, A, B, C>

impl<O: Write> Printer<O, AddressFormatter, ByteFormatter, CharFormatter>

pub fn default_fmt_with( out: O, start_address: usize, ) -> Printer<O, AddressFormatter, ByteFormatter, CharFormatter>

Examples found in repository

examples/simple.rs (line 7)

fn main() {
    use std::io::stdout;

    let mut printer = Printer::default_fmt_with(stdout(), 0);

    let bytes1 = &[222u8, 173, 190, 239];
    let bytes2 = &[0xfeu8, 0xed, 0xfa];
    let title = b"Simple printing";

    for _ in 0..10 {
        _ = printer.push(bytes1);
    }

    _ = printer.push(title);

    for _ in 0..11 {
        _ = printer.push(bytes2);
    }

    printer.finish();
}

examples/stdin.rs (line 20)

fn main() {
    use std::io::stdout;

    let mut buf = [0u8; 64];
    let stdin = std::io::stdin();
    let mut handle = stdin.lock();
    
    let mut printer = Printer::default_fmt_with(stdout(), 0);

    while let Ok(size) = handle.read(&mut buf) {
        if size == 0 {
            break;
        }
        assert!(printer.write_all(&mut buf[..size]).is_ok());
    }

    printer.finish();
}

Trait Implementations

impl<O: Write, A: AddressFormatting + Clone, B: ByteFormatting + Clone, C: CharFormatting + Clone> Drop for Printer<O, A, B, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<O: Write, A: AddressFormatting + Clone, B: ByteFormatting + Clone, C: CharFormatting + Clone> Write for Printer<O, A, B, C>

fn flush(&mut self) -> Result<()>

Does nothing. Always returns Ok(())

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.