Enum DocsError 

#[non_exhaustive]
pub enum DocsError {
    UnsupportedFormat(String),
    MacroEnabled(String),
    Encrypted,
    TooLarge {
        limit: u64,
        actual: u64,
    },
    ArchiveLimit(String),
    Malformed(String),
    ForbiddenXml {
        part: String,
        what: &'static str,
    },
    SourceChanged,
    TargetExists,
    TargetMissing,
    NotFound {
        kind: &'static str,
        name: String,
    },
    InvalidOp(String),
    UnsafeFormula(String),
    WrongFormat {
        op: &'static str,
        format: &'static str,
    },
    Pdf(PdfEditError),
    PdfExtract(String),
    Io(String),
    SavedWithWarning(String),
}

Everything read and write can refuse. Every variant has a stable DocsError::code.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

UnsupportedFormat(String)

The bytes are not a DOCX, XLSX or PDF (legacy OLE .doc/.xls, PPTX, XLSB, plain text…).

MacroEnabled(String)

A macro-enabled package (.docm, .xlsm, .dotm, .xltm, or any package holding a VBA project). Refused, never opened, never run.

Encrypted

Password-protected: an encrypted OOXML container, a zip-level encrypted entry, or an encrypted PDF. This crate does not decrypt.

TooLarge

The input exceeds the compressed-size cap.

Fields

limit: u64

actual: u64

ArchiveLimit(String)

A zip-bomb guard fired: entry count, decompressed size, or compression ratio.

Malformed(String)

The structure is not a valid package or part, or it contradicts itself (duplicate entries, unsafe entry names, truncated archive, broken XML).

ForbiddenXml

A DOCTYPE or entity declaration. XML external entities are not supported and the part is refused rather than parsed.

Fields

part: String

what: &'static str

SourceChanged

The target differs from the file the edit was based on.

TargetExists

create over an existing file without overwrite.

TargetMissing

An edit op on a target that does not exist.

NotFound

A named sheet, page, range or text was not found.

Fields

kind: &'static str

name: String

InvalidOp(String)

The op itself is invalid (bad cell address, empty find string, too-long string…).

UnsafeFormula(String)

A formula the policy refuses: external workbook link, DDE, network fetch function.

WrongFormat

The op does not apply to this format.

Fields

op: &'static str

format: &'static str

Pdf(PdfEditError)

A rightkit-pdf refusal; the PDF wire code is in the message.

PdfExtract(String)

PDF text extraction failed.

Io(String)

Reading the source or writing the target failed. Nothing was published.

SavedWithWarning(String)

The replacement was written but a step after it failed (directory sync); treat the file as saved, durability across power loss as not established.

Implementations

impl DocsError

pub fn code(&self) -> &'static str

Stable wire code.

Trait Implementations

impl Debug for DocsError

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

Formats the value using the given formatter.

impl Display for DocsError

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

Formats the value using the given formatter.

impl Error for DocsError

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<PdfEditError> for DocsError

fn from(source: PdfEditError) -> Self

Converts to this type from the input type.

impl Serialize for DocsError

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.