Struct ExifData

pub struct ExifData {
    pub source_file: String,
    pub exif_tool_version: String,
    pub tags: Vec<TagEntry>,
    pub legacy_tags: HashMap<String, TagValue>,
    pub errors: Vec<String>,
    pub missing_implementations: Option<Vec<String>>,
}

Represents extracted EXIF data from an image

This matches ExifTool’s JSON output structure

Fields

source_file: String

Source file path

exif_tool_version: String

Version of exif-oxide

tags: Vec<TagEntry>

All extracted tags with both value and print representations

legacy_tags: HashMap<String, TagValue>

Legacy field for backward compatibility - will be populated during serialization TODO: Remove this once all consumers are updated to use TagEntry

errors: Vec<String>

Any errors encountered during processing

missing_implementations: Option<Vec<String>>

Missing implementations (only included with –show-missing)

Implementations

impl ExifData

pub fn new(source_file: String, exif_tool_version: String) -> Self

Create a new ExifData with empty tags

pub fn prepare_for_serialization( &mut self, numeric_tags: Option<&HashSet<String>>, )

Convert tags to legacy format for JSON serialization This populates legacy_tags from the TagEntry vector

pub fn get_exif_ifd_tags(&self) -> Vec<&TagEntry>

Get all ExifIFD tags specifically ExifTool compatibility: access tags by Group1 location

pub fn get_tags_by_group1(&self, group1_name: &str) -> Vec<&TagEntry>

Get all tags from a specific Group1 (subdirectory location) ExifTool: Group1-based filtering

Examples

use exif_oxide::formats::extract_metadata;

let exif_data = extract_metadata(std::path::Path::new("image.jpg"), false).unwrap();

// Get all GPS tags
let gps_tags = exif_data.get_tags_by_group1("GPS");

// Get all ExifIFD tags
let exif_ifd_tags = exif_data.get_tags_by_group1("ExifIFD");

pub fn get_tag_by_group( &self, group_name: &str, tag_name: &str, ) -> Option<&TagEntry>

ExifTool compatibility: get tag by group-qualified name Supports both Group0 and Group1 based access

Examples

use exif_oxide::formats::extract_metadata;

let exif_data = extract_metadata(std::path::Path::new("image.jpg"), false).unwrap();

// Access by Group1 (subdirectory location)
let exposure_time = exif_data.get_tag_by_group("ExifIFD", "ExposureTime");

// Access by Group0 (format family)
let make = exif_data.get_tag_by_group("EXIF", "Make");

pub fn get_tag_exiftool_style(&self, qualified_name: &str) -> Option<&TagEntry>

ExifTool-style group access: EXIF:ExposureTime vs ExifIFD:ExposureTime Parses qualified tag names in “Group:TagName” format

Examples

use exif_oxide::formats::extract_metadata;

let exif_data = extract_metadata(std::path::Path::new("image.jpg"), false).unwrap();

let exposure_time = exif_data.get_tag_exiftool_style("ExifIFD:ExposureTime");
let gps_lat = exif_data.get_tag_exiftool_style("GPS:GPSLatitude");

pub fn get_tag_by_name(&self, tag_name: &str) -> Option<&TagEntry>

Get tag by name (without group qualifier) Returns the first matching tag found

Trait Implementations

impl Clone for ExifData

fn clone(&self) -> ExifData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExifData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExifData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ExifData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.