Struct Encoder 

pub struct Encoder<W: Write> { /* private fields */ }

Stream Bech32-encoded data to a writer without allocation.

Writing to an Encoder can be done iteratively.

The destination writer can be anything that implements Write. Examples: Vec<u8>, File, TcpStream, etc.

Note: You must flush() the encoder when you have finished writing data or the output will be incomplete.

Examples

Encode to a Vec<u8>:

use std::io::Write;
use pbech32::{Encoder, Hrp, Scheme};

let mut vec: Vec<u8> = Vec::new(); // output vector
let hrp: Hrp = "hello".parse()?; // human readable part

let mut encoder = Encoder::new(&mut vec, Scheme::Bech32m, hrp)?; // create encoder
encoder.write_all(b"folks")?; // write data
encoder.flush()?; // flush encoder (REQUIRED)

let got = str::from_utf8(vec.as_ref())?; // convert output vector to string
assert_eq!(got, "hello1vehkc6mn27xpct"); // check result

Iteratively encode to a Vec<u8>:

use std::io::Write;
use pbech32::{Encoder, Hrp, Scheme};

let mut vec: Vec<u8> = Vec::new(); // output vector
let hrp: Hrp = "hi".parse()?; // human readable part

let mut encoder = Encoder::new(&mut vec, Scheme::Bech32m, hrp)?; // create encoder
for chunk in vec![b"foo", b"bar", b"baz"] {
  encoder.write_all(chunk)?; // write chunk
}
encoder.flush()?; // flush encoder (REQUIRED)

let got = str::from_utf8(vec.as_ref())?; // convert output vector to string
assert_eq!(got, "hi1vehk7cnpwf3xz7skgej7x"); // check result

See examples/stream.rs for an example of streaming to standard output.

Implementations

impl<W: Write> Encoder<W>

pub fn new(inner: W, scheme: Scheme, hrp: Hrp) -> Result<Self>

Create streaming encoder.

Parameters

• inner: Wrapped writer
• scheme: Checksum scheme
• hrp: Human-readable part

Example

Encode to a Vec<u8>:

use std::io::Write;
use pbech32::{Encoder, Hrp, Scheme};

let mut vec: Vec<u8> = Vec::new(); // output vector
let hrp: Hrp = "hello".parse()?; // human readable part

let mut encoder = Encoder::new(&mut vec, Scheme::Bech32m, hrp)?; // create encoder
encoder.write_all(b"folks")?; // write data
encoder.flush()?; // flush encoder (REQUIRED)

let got = str::from_utf8(vec.as_ref())?; // convert output vector to string
assert_eq!(got, "hello1vehkc6mn27xpct"); // check result

See examples/stream.rs for an example of streaming to standard output.

Examples found in repository

examples/stream.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  // get/check args
  let args: Vec<String> = std::env::args().collect();
  if args.len() != 2 {
    panic!("Usage: {} [hrp]", args[0]);
  }

  let hrp: Hrp = args[1].parse()?; // parse first arg as hrp
  let (mut stdin, mut stdout) = (std::io::stdin(), std::io::stdout()); // get stdio

  let mut encoder = Encoder::new(&mut stdout, Scheme::Bech32m, hrp)?; // create encoder
  std::io::copy(&mut stdin, &mut encoder)?; // bech32-encode stdin to stdout
  encoder.flush()?; // flush encoder

  Ok(()) // return success
}

Trait Implementations

impl<W: Write> Write for Encoder<W>

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

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

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

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

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.