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 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>

pub 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 tiff = TiffEncoder::new(&mut file)?;

// … some custom data writes, assume we know where a directory was written
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()?;

Trait Implementations

impl<K: Clone + TiffKind> Clone for DirectoryOffset<K>

where K::OffsetType: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + TiffKind> Debug for DirectoryOffset<K>

where K::OffsetType: Debug,

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

Formats the value using the given formatter.

impl<K: Hash + TiffKind> Hash for DirectoryOffset<K>

where K::OffsetType: Hash,

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<K: PartialEq + TiffKind> PartialEq for DirectoryOffset<K>

where K::OffsetType: PartialEq,

fn eq(&self, other: &DirectoryOffset<K>) -> 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<K: Copy + TiffKind> Copy for DirectoryOffset<K>

where K::OffsetType: Copy,

impl<K: Eq + TiffKind> Eq for DirectoryOffset<K>

where K::OffsetType: Eq,

impl<K: TiffKind> StructuralPartialEq for DirectoryOffset<K>