Provided Methods

fn encode<T: AsRef<[u8]>>(self: &Self, input: T) -> String

Encode arbitrary octets as base64 using the provided Engine. Returns a String.

Example

use base64::{Engine as _, engine::{self, general_purpose}, alphabet};

let b64 = general_purpose::STANDARD.encode(b"hello world~");
println!("{}", b64);

const CUSTOM_ENGINE: engine::GeneralPurpose =
    engine::GeneralPurpose::new(&alphabet::URL_SAFE, general_purpose::NO_PAD);

let b64_url = CUSTOM_ENGINE.encode(b"hello internet~");

fn encode_string<T: AsRef<[u8]>>(self: &Self, input: T, output_buf: &mut String)

Encode arbitrary octets as base64 into a supplied String. Writes into the supplied String, which may allocate if its internal buffer isn't big enough.

Example

use base64::{Engine as _, engine::{self, general_purpose}, alphabet};
const CUSTOM_ENGINE: engine::GeneralPurpose =
    engine::GeneralPurpose::new(&alphabet::URL_SAFE, general_purpose::NO_PAD);

fn main() {
    let mut buf = String::new();
    general_purpose::STANDARD.encode_string(b"hello world~", &mut buf);
    println!("{}", buf);

    buf.clear();
    CUSTOM_ENGINE.encode_string(b"hello internet~", &mut buf);
    println!("{}", buf);
}

fn encode_slice<T: AsRef<[u8]>>(self: &Self, input: T, output_buf: &mut [u8]) -> Result<usize, EncodeSliceError>

Encode arbitrary octets as base64 into a supplied slice. Writes into the supplied output buffer.

This is useful if you wish to avoid allocation entirely (e.g. encoding into a stack-resident or statically-allocated buffer).

Example

use base64::{Engine as _, engine::general_purpose};
let s = b"hello internet!";
let mut buf = Vec::new();
// make sure we'll have a slice big enough for base64 + padding
buf.resize(s.len() * 4 / 3 + 4, 0);

let bytes_written = general_purpose::STANDARD.encode_slice(s, &mut buf).unwrap();

// shorten our vec down to just what was written
buf.truncate(bytes_written);

assert_eq!(s, general_purpose::STANDARD.decode(&buf).unwrap().as_slice());

fn decode<T: AsRef<[u8]>>(self: &Self, input: T) -> Result<Vec<u8>, DecodeError>

Decode the input into a new Vec.

Example

use base64::{Engine as _, alphabet, engine::{self, general_purpose}};

let bytes = general_purpose::STANDARD
    .decode("aGVsbG8gd29ybGR+Cg==").unwrap();
println!("{:?}", bytes);

// custom engine setup
let bytes_url = engine::GeneralPurpose::new(
             &alphabet::URL_SAFE,
             general_purpose::NO_PAD)
    .decode("aGVsbG8gaW50ZXJuZXR-Cg").unwrap();
println!("{:?}", bytes_url);

fn decode_vec<T: AsRef<[u8]>>(self: &Self, input: T, buffer: &mut Vec<u8>) -> Result<(), DecodeError>

Decode the input into the supplied buffer.

Writes into the supplied Vec, which may allocate if its internal buffer isn't big enough. Returns a Result containing an empty tuple, aka ().

Example

use base64::{Engine as _, alphabet, engine::{self, general_purpose}};
const CUSTOM_ENGINE: engine::GeneralPurpose =
    engine::GeneralPurpose::new(&alphabet::URL_SAFE, general_purpose::PAD);

fn main() {
    use base64::Engine;
    let mut buffer = Vec::<u8>::new();
    // with the default engine
    general_purpose::STANDARD
        .decode_vec("aGVsbG8gd29ybGR+Cg==", &mut buffer,).unwrap();
    println!("{:?}", buffer);

    buffer.clear();

    // with a custom engine
    CUSTOM_ENGINE.decode_vec(
        "aGVsbG8gaW50ZXJuZXR-Cg==",
        &mut buffer,
    ).unwrap();
    println!("{:?}", buffer);
}

fn decode_slice<T: AsRef<[u8]>>(self: &Self, input: T, output: &mut [u8]) -> Result<usize, DecodeSliceError>

Decode the input into the provided output slice.

Returns the number of bytes written to the slice, or an error if output is smaller than the estimated decoded length.

This will not write any bytes past exactly what is decoded (no stray garbage bytes at the end).

See [crate::decoded_len_estimate] for calculating buffer sizes.

See [Engine::decode_slice_unchecked] for a version that panics instead of returning an error if the output buffer is too small.

fn decode_slice_unchecked<T: AsRef<[u8]>>(self: &Self, input: T, output: &mut [u8]) -> Result<usize, DecodeError>

Decode the input into the provided output slice.

Returns the number of bytes written to the slice.

This will not write any bytes past exactly what is decoded (no stray garbage bytes at the end).

See [crate::decoded_len_estimate] for calculating buffer sizes.

See [Engine::decode_slice] for a version that returns an error instead of panicking if the output buffer is too small.

Panics

Panics if the provided output buffer is too small for the decoded data.