Enum Value

#[non_exhaustive]
pub enum Value

Variants

Byte(u8)
Short(u16)
SignedByte(i8)
SignedShort(i16)
Signed(i32)
SignedBig(i64)
Unsigned(u32)
UnsignedBig(u64)
Float(f32)
Double(f64)
List(Vec<Value>)
Rational(u32, u32)
RationalBig(u64, u64)
SRational(i32, i32)
SRationalBig(i64, i64)
Ascii(String)
Ifd(u32)
IfdBig(u64)

Implementations

impl Value

fn into_u8(self) -> TiffResult<u8>
fn into_i8(self) -> TiffResult<i8>
fn into_u16(self) -> TiffResult<u16>
fn into_i16(self) -> TiffResult<i16>
fn into_u32(self) -> TiffResult<u32>
fn into_i32(self) -> TiffResult<i32>
fn into_u64(self) -> TiffResult<u64>
fn into_i64(self) -> TiffResult<i64>
fn into_f32(self) -> TiffResult<f32>
fn into_f64(self) -> TiffResult<f64>
fn into_ifd_pointer(self) -> TiffResult<IfdPointer>

Turn this value into an IfdPointer.

Notice that this does not take an argument, a 64-bit IFD is always allowed. If the difference is crucial and you do not want to be permissive you're expected to filter this out before.

For compatibility the smaller sized tags should always be allowed i.e. you might use a non-bigtiff's directory and its tag types and move it straight to a bigtiff. For instance the SubIFD tag is defined as LONG or IFD:

https://web.archive.org/web/20181105221012/https://www.awaresystems.be/imaging/tiff/tifftags/subifds.html

fn into_string(self) -> TiffResult<String>
fn into_u32_vec(self) -> TiffResult<Vec<u32>>
fn into_u8_vec(self) -> TiffResult<Vec<u8>>
fn into_u16_vec(self) -> TiffResult<Vec<u16>>
fn into_i32_vec(self) -> TiffResult<Vec<i32>>
fn into_f32_vec(self) -> TiffResult<Vec<f32>>
fn into_f64_vec(self) -> TiffResult<Vec<f64>>
fn into_u64_vec(self) -> TiffResult<Vec<u64>>
fn into_i64_vec(self) -> TiffResult<Vec<i64>>
fn into_ifd_vec(self) -> TiffResult<Vec<IfdPointer>>

Trait Implementations

impl Clone for Value

fn clone(&self) -> Self

impl Debug for Value

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

impl PartialEq for Value

fn eq(&self, other: &Self) -> bool

impl StructuralPartialEq for Value

Auto Trait Implementations

impl Freeze for Value

impl RefUnwindSafe for Value

impl Send for Value

impl Sync for Value

impl Unpin for Value

impl UnsafeUnpin for Value

impl UnwindSafe for Value

Blanket Implementations

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for Value where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for Value where ST: ?Sized, DT: ?Sized,

impl<T> Any for Value where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Value where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Value where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Value where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for Value

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Read<Exclusive, BecauseExclusive> for Value where T: ?Sized,

impl<T> ToOwned for Value where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for Value where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for Value where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Value where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>