Struct MarkedData 

pub struct MarkedData<'a> {
    pub marker: u8,
    pub data: &'a [u8],
}

Parses a standard dynamically-sized chuck from a JPEG file.

Not all markers in JPEG are followed by data, or even a data size. This only represents those markers that have data. Markers that are not followed by data include “Start of Image”, “End of Image”, and “Reset”.

One marker, the “Start of Segment” marker, is followed by data, but then that data is also followed by entropy-encoded data that is unmarked.

Fields

marker: u8

data: &'a [u8]

Implementations

impl<'a> MarkedData<'a>

pub fn parser<I>( marker: impl Parser<Input = I, Output = u8> + 'a, ) -> impl Parser<Input = I, Output = MarkedData<'a>> + 'a

where I: RangeStream<Item = u8, Range = &'a [u8]> + 'a, I::Error: ParseError<I::Item, I::Range, I::Position>,

Parses out marked data from a JPEG file with marker parser marker.

use exifsd::*;
use combine::*;

// 0xFF - Start of marker
// 0x11 - Marker
// 0x00, 0x03 - Length of data including length (so data length 1)
// 0x01 - The data
let input = &[0xFF, 0x11, 0x00, 0x03, 0x01][..];
let result = MarkedData::parser(token(0x11)).parse(input);
let expected = MarkedData { marker: 0x11, data: &[0x01] };
assert_eq!(result, Ok((expected, &[][..])));

// Length cannot be less than 2 (here it is 1).
MarkedData::parser(any()).parse(&[0xFF, 0x11, 0x00, 0x01][..]).unwrap_err();

pub fn write<W: WriteBytesExt>(&self, writer: &mut W) -> Result<()>

Writes the binary representation of the MarkedData out to a file.

use exifsd::*;
use combine::*;

let input = &[0xFF, 0x11, 0x00, 0x03, 0x01][..];
let marked_data = MarkedData::parser(token(0x11)).parse(input).unwrap().0;
let mut written = vec![];
marked_data.write(&mut written).unwrap();
assert_eq!(input, &written[..]);

Trait Implementations

impl<'a> Clone for MarkedData<'a>

fn clone(&self) -> MarkedData<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for MarkedData<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for MarkedData<'a>

fn eq(&self, other: &MarkedData<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Copy for MarkedData<'a>

impl<'a> Eq for MarkedData<'a>

impl<'a> StructuralPartialEq for MarkedData<'a>