env:

RUST_BACKTRACE: 1

RUSTFLAGS: -Dwarnings

jobs:

build_and_test_nix:

) -> Result<()> {

// Header

writer.write_all(HEADER_LINE.as_bytes())?;

// Hashes

for hash in &self.hashes {

writer.write_all(b"Hash: ")?;

writer.write_all(hash.to_string().as_bytes())?;

}

// Cleartext body

writer.write_all(self.csf_encoded_text.as_bytes())?;

armor::write(

&self.signatures,

// break each line into "content" and "line ending"

let line_end_len = if line.ends_with("\r\n") {

2

1

} else {

0

Bzip2,

fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {

match self {

Decompressor::Uncompressed(ref mut c) => c.read(into),

// - plaintext length

let plain_len = plaintext.len();

// - number of chunks: plaintext length divided by chunk size, rounded up to the next integer

// - total output size: plaintext length + size of all authentication tags (one tag per chunk, plus one final tag)

let out_len = plain_len + (num_chunks + 1) * aead.tag_size().unwrap_or_default();

};

let chunk_and_tag_len = chunk_size_expanded + aead_tag_size;

let main_len = main_chunks.len();

// - total output size: main_chunks length - size of one authentication tag per chunk

let out_len = main_len - num_chunks * aead_tag_size;

}

fn to_writer<W: io::Write>(&self, writer: &mut W) -> Result<()> {

(*self).to_writer(writer)

}

fn to_writer<W: io::Write>(&self, writer: &mut W) -> Result<()> {

for x in self.iter() {

(*x).to_writer(writer)?;

}

type Target = [u8];

fn deref(&self) -> &Self::Target {

}

fn to_writer<W: io::Write>(&self, w: &mut W) -> errors::Result<()> {

let bytes = &self.0;

let size = bit_size(bytes);

X448(#[debug("..")] &'a [u8; 56]),

pub fn to_owned(&self) -> PlainSecretParams {

match self {

PlainSecretParamsRef::RSA { d, p, q, u } => PlainSecretParams::RSA {

}

fn verify_signature(

&self,

hash: HashAlgorithm,

}

type PublicKey = T::PublicKey;

type Unlocked = T::Unlocked;