Struct DirectoryOffset

pub struct DirectoryOffset<K: TiffKind> { pub offset: K::OffsetType, pub pointer: IfdPointer, /* private fields */ }

The offset of an encoded directory in the file.

Both the offset and pointer field are a complete description of the start offset of the dictionary which is used to point to it. The struct also describes the extent covered by the encoding of the directory. The constructors [new][DirectoryOffset::new] allow the checked conversion. Note that even though the offsets are public do not expect their information to propagate when modified.

Fields

offset: K::OffsetType

The start of the directory as a Tiff value.

This is a bit of a wart in the strongly typed design of the encoder. The value type must itself know how to be represented in the Tiff file but that may differ based on endianess as well as the offset size (u32 or BigTIFF's u64). Thankfully we're allowed to represent offsets with LONG or IFD in the usual case.

pointer: IfdPointer

The start of the directory as a pure offset.

Implementations

impl<K: TiffKind> DirectoryOffset<K>

fn new(pointer: IfdPointer, dir: &Directory) -> TiffResult<Self>

Construct the directory pointer information from its raw offset.

Fails in these cases:

  • if start offset is too large to be represented with the chosen TIFF format, i.e. a value larger than u32::MAX with a standard tiff which is only valid in a BigTiff. This returns TiffError::IntSizeError.
  • the extent of the directory would overflow the file length. This returns a TiffError::UsageError.

The library does not validate the contents or offset in any way, it just performs the necessary math assuming the data is an accurate representation of existing content.

Examples

If you have any custom way of writing a directory to a file that can not go through the usual TiffEncoder::extra_directory then you can reconstruct the offset information as long as you provide all the necessary data to the library. You can then use it as a parent directory, i.e. have the library overwrite its next field.

use tiff::{
    encoder::{TiffEncoder, DirectoryOffset},
    Directory,
    tags::IfdPointer,
};

# let mut file = std::io::Cursor::new(Vec::new());
let mut tiff = TiffEncoder::new(&mut file)?;

// … some custom data writes, assume we know where a directory was written
# fn reconstruction_of_your_directory() -> Directory { Directory::from_iter([]) }
let known_offset = IfdPointer(1024);
let known_contents: Directory = reconstruction_of_your_directory();

let reconstructed = DirectoryOffset::new(known_offset, &known_contents)?;

// Now we can use it as if the directory was written by the `TiffEncoder` itself.
let mut chain = tiff.extra_directory()?;
chain.set_parent(&reconstructed);
chain.finish_with_offsets()?;

# Ok::<_, tiff::TiffError>(())

Trait Implementations

impl<K: Clone + TiffKind> Clone for DirectoryOffset<K> where K::OffsetType: Clone,

fn clone(&self) -> DirectoryOffset<K>

impl<K: Copy + TiffKind> Copy for DirectoryOffset<K> where K::OffsetType: Copy,

impl<K: Debug + TiffKind> Debug for DirectoryOffset<K> where K::OffsetType: Debug,

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

impl<K: Eq + TiffKind> Eq for DirectoryOffset<K> where K::OffsetType: Eq,

impl<K: Hash + TiffKind> Hash for DirectoryOffset<K> where K::OffsetType: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

impl<K: PartialEq + TiffKind> PartialEq for DirectoryOffset<K> where K::OffsetType: PartialEq,

fn eq(&self, other: &DirectoryOffset<K>) -> bool

impl<K: PartialEq + TiffKind> StructuralPartialEq for DirectoryOffset<K> where K::OffsetType: PartialEq,

Auto Trait Implementations

impl<K> Freeze for DirectoryOffset<K> where <K as TiffKind>::OffsetType: Freeze, PhantomData<K>: Freeze,

impl<K> RefUnwindSafe for DirectoryOffset<K> where <K as TiffKind>::OffsetType: RefUnwindSafe, PhantomData<K>: RefUnwindSafe,

impl<K> Send for DirectoryOffset<K> where <K as TiffKind>::OffsetType: Send, PhantomData<K>: Send,

impl<K> Sync for DirectoryOffset<K> where <K as TiffKind>::OffsetType: Sync, PhantomData<K>: Sync,

impl<K> Unpin for DirectoryOffset<K> where <K as TiffKind>::OffsetType: Unpin, PhantomData<K>: Unpin,

impl<K> UnsafeUnpin for DirectoryOffset<K> where <K as TiffKind>::OffsetType: UnsafeUnpin, PhantomData<K>: UnsafeUnpin,

impl<K> UnwindSafe for DirectoryOffset<K> where <K as TiffKind>::OffsetType: UnwindSafe, PhantomData<K>: UnwindSafe,

Blanket Implementations

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

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

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

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for DirectoryOffset<K> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for DirectoryOffset<K> where T: ?Sized,

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

impl<T> CloneToUninit for DirectoryOffset<K> where T: Clone,

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

impl<T> From<T> for DirectoryOffset<K>

fn from(t: T) -> T

Returns the argument unchanged.

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

impl<T> ToOwned for DirectoryOffset<K> where T: Clone,

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

impl<T, U> Into<U> for DirectoryOffset<K> 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 DirectoryOffset<K> where U: Into<T>,

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

impl<T, U> TryInto<U> for DirectoryOffset<K> where U: TryFrom<T>,

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