Struct detached_jws::encode::SerializeJwsWriter

pub struct SerializeJwsWriter<W, S: Write> { /* fields omitted */ }

A Write implementation serialize to detached jws

Examples

extern crate detached_jws;
extern crate anyhow;
extern crate serde_json;

use std::io::{Write};
use anyhow::Result;
use serde_json::{json, Map};
use detached_jws::{SerializeJwsWriter, Sign};

#[derive(Default)]
pub struct DummySigner(Vec<u8>);

impl Sign for DummySigner {
    fn get_sign(&self) -> Result<Vec<u8>> {
        Ok(self.0.clone())
    }
}

impl Write for DummySigner {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        self.0.write(buf)
    }
    fn flush(&mut self) -> std::io::Result<()> {
       Ok(())
    }
}

let mut header = Map::new();
header.insert("custom".to_owned(), json!("custom_value"));

let mut writer = SerializeJwsWriter::new(Vec::new(),
       "test_algorithm".to_owned(),
       header,
       DummySigner::default()).unwrap();
writer.write_all(&[0, 1, 2, 3]);
writer.write_all(&[4, 5, 6]);

let jws = writer.finish().unwrap();

assert_eq!(
       String::from_utf8(jws).unwrap(),
       "eyJhbGciOiJ0ZXN0X2FsZ29yaXRobSIsImN1c3RvbSI6ImN1c3RvbV92YWx1ZSJ9..ZXlKaGJHY2lPaUowWlhOMFgyRnNaMjl5YVhSb2JTSXNJbU4xYzNSdmJTSTZJbU4xYzNSdmJWOTJZV3gxWlNKOS5BQUVDQXdRRkJn");

Implementations

impl<W, S> SerializeJwsWriter<W, S> where
    W: Write,
    S: Sign, 

pub fn new(
    mut writer: W,
    algorithm: String,
    mut header: JwsHeader,
    mut signer: S
) -> Result<Self>

pub fn finish(&mut self) -> Result<W>

Trait Implementations

impl<W, S> Write for SerializeJwsWriter<W, S> where
    S: Write, 

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

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

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

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

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

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

pub 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.

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

Attempts to write an entire buffer into this writer.

pub 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.

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

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

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

Creates a "by reference" adaptor for this instance of Write.