Enum ParseError 

pub enum ParseError {
    Io(Error),
    InvalidHeader,
    UnsupportedVersion(String),
    SyntaxError {
        position: usize,
        message: String,
    },
    UnexpectedToken {
        expected: String,
        found: String,
    },
    InvalidReference(u32, u16),
    MissingKey(String),
    InvalidXRef,
    InvalidTrailer,
    CircularReference,
    StreamDecodeError(String),
    EncryptionNotSupported,
    EmptyFile,
    StreamLengthMismatch {
        declared: usize,
        actual: usize,
    },
    CharacterEncodingError {
        position: usize,
        message: String,
    },
    UnexpectedCharacter {
        character: String,
    },
}

PDF Parser errors covering all failure modes during parsing.

Error Categories

• I/O Errors: File access and reading issues
• Format Errors: Invalid PDF structure or syntax
• Unsupported Features: Encryption, newer PDF versions
• Reference Errors: Invalid or circular object references
• Stream Errors: Decompression or filter failures

Example

use oxidize_pdf::parser::{PdfReader, ParseError};

match PdfReader::open("missing.pdf") {
    Ok(_) => println!("File opened"),
    Err(ParseError::Io(e)) => println!("IO error: {}", e),
    Err(ParseError::InvalidHeader) => println!("Not a valid PDF"),
    Err(e) => println!("Other error: {}", e),
}

Error Recovery and Tolerant Parsing

The parser supports different levels of error tolerance for handling corrupted or non-standard PDF files:

use oxidize_pdf::parser::{PdfReader, ParseOptions};
use std::fs::File;

// Strict parsing (default) - fails on any deviation from PDF spec
let strict_reader = PdfReader::open("document.pdf")?;

// Tolerant parsing - attempts to recover from errors
let file = File::open("corrupted.pdf")?;
let tolerant_reader = PdfReader::new_with_options(file, ParseOptions::tolerant())?;

// Skip errors mode - ignores corrupt streams and returns partial content
let file = File::open("problematic.pdf")?;
let skip_errors_reader = PdfReader::new_with_options(file, ParseOptions::skip_errors())?;

Variants

Io(Error)

I/O error during file operations

InvalidHeader

PDF file doesn’t start with valid header (%PDF-)

UnsupportedVersion(String)

PDF version is not supported

SyntaxError

Syntax error in PDF structure

Fields

position: usize

message: String

UnexpectedToken

Fields

expected: String

found: String

InvalidReference(u32, u16)

Invalid or non-existent object reference

MissingKey(String)

Required dictionary key is missing

InvalidXRef

InvalidTrailer

CircularReference

StreamDecodeError(String)

Error decoding/decompressing stream data

EncryptionNotSupported

PDF encryption is not currently supported

EmptyFile

Empty file

StreamLengthMismatch

Stream length mismatch (only in strict mode)

Fields

declared: usize

actual: usize

CharacterEncodingError

Character encoding error

Fields

position: usize

message: String

UnexpectedCharacter

Unexpected character in PDF content

Fields

character: String

Trait Implementations

impl Debug for ParseError

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

Formats the value using the given formatter.

impl Display for ParseError

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

Formats the value using the given formatter.

impl Error for ParseError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for ParseError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ParseError> for OxidizePdfError

fn from(err: ParseError) -> Self

Converts to this type from the input type.

impl From<ParseError> for PdfError

fn from(err: ParseError) -> Self

Converts to this type from the input type.