Enum TagValue

pub enum TagValue {
    U8(Vec<u8>),
    Ascii(String),
    U16(Vec<u16>),
    U32(Vec<u32>),
    URational(Vec<URational>),
    I8(Vec<i8>),
    Undefined(Vec<u8>, bool),
    I16(Vec<i16>),
    I32(Vec<i32>),
    IRational(Vec<IRational>),
    F32(Vec<f32>),
    F64(Vec<f64>),
    Unknown(Vec<u8>, bool),
    Invalid(Vec<u8>, bool, u16, u32),
}

Tag value enumeration. It works as a variant type. Each value is actually a vector because many EXIF tags are collections of values. Exif tags with single values are represented as single-item vectors.

Variants

U8(Vec<u8>)

Array of unsigned byte integers

Ascii(String)

ASCII string. (The standard specifies 7-bit ASCII, but this parser accepts UTF-8 strings.)

U16(Vec<u16>)

U32(Vec<u32>)

URational(Vec<URational>)

Array of URational structures (tuples with integer numerator and denominator)

I8(Vec<i8>)

Undefined(Vec<u8>, bool)

Array of bytes with opaque internal structure. Used by manufacturer-specific tags, SIG-specific tags, tags that contain Unicode (UCS-2) or Japanese (JIS) strings (i.e. strings that are not 7-bit-clean), tags that contain dissimilar or variant types, etc.

This item has a “little endian” boolean parameter that reports the whole TIFF’s endianness. Any sort of internal structure that is sensitive to endianess should be interpreted accordignly to this parameter (true=LE, false=BE).

I16(Vec<i16>)

I32(Vec<i32>)

IRational(Vec<IRational>)

Array of IRational structures (tuples with signed integer numerator and denominator)

F32(Vec<f32>)

Array of IEEE 754 floating-points

F64(Vec<f64>)

Array of IEEE 754 floating-points

Unknown(Vec<u8>, bool)

Array of bytes with unknown internal structure. This is different from Undefined because Undefined is actually a specified format, while Unknown is an unexpected format type. A tag of Unknown format is most likely a corrupted tag.

This variant has a “little endian” boolean parameter that reports the whole TIFF’s endianness. Any sort of internal structure that is sensitive to endianess should be interpreted accordignly to this parameter (true=LE, false=BE).

Invalid(Vec<u8>, bool, u16, u32)

Type that could not be parsed due to some sort of error (e.g. buffer too short for the count and type size). Variant contains raw data, LE/BE, format (as u16) and count.

Implementations

impl TagValue

pub fn to_i64(&self, index: usize) -> Option<i64>

Get value as an integer Out of bounds indexes and invalid types return None

pub fn to_f64(&self, index: usize) -> Option<f64>

Get value as a floating-point number Out of bounds indexes and invalid types return None

Trait Implementations

impl Clone for TagValue

fn clone(&self) -> TagValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TagValue

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

Formats the value using the given formatter.

impl Display for TagValue

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

Formats the value using the given formatter.

impl PartialEq for TagValue

fn eq(&self, other: &TagValue) -> 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 StructuralPartialEq for TagValue