Enum AppPathError

pub enum AppPathError {
    ExecutableNotFound(String),
    InvalidExecutablePath(String),
    IoError(String),
}

Error type for AppPath operations.

This enum represents the possible failures that can occur when working with AppPath instances. These include both system-level failures and I/O errors.

When These Errors Occur

• ExecutableNotFound: When std::env::current_exe() fails

  • Very rare, but can happen in some embedded or heavily sandboxed environments
  • May occur if the executable has been deleted while running
  • Can happen in some containerized environments with unusual configurations

• InvalidExecutablePath: When the executable path is empty

  • Extremely rare, indicates a corrupted or broken system
  • May occur with custom or non-standard program loaders

• IoError: When I/O operations fail

  • Directory creation fails due to insufficient permissions
  • Disk space issues or filesystem errors
  • Invalid path characters for the target filesystem
  • Network filesystem problems

System-level errors are typically unrecoverable for portable applications, while I/O errors may be recoverable depending on the specific cause.

Examples

use app_path::{AppPath, AppPathError};

// Handle errors explicitly
match AppPath::try_with("config.toml") {
    Ok(config) => {
        println!("Config path: {}", config.path().display());
    }
    Err(AppPathError::ExecutableNotFound(msg)) => {
        eprintln!("Cannot find executable: {msg}");
        // Fallback to alternative configuration
    }
    Err(AppPathError::InvalidExecutablePath(msg)) => {
        eprintln!("Invalid executable path: {msg}");
        // Fallback to alternative configuration
    }
    Err(AppPathError::IoError(io_err)) => {
        eprintln!("I/O operation failed: {io_err}");
        // Handle specific I/O error
    }
}

Variants

ExecutableNotFound(String)

Failed to determine the current executable path.

This error occurs when std::env::current_exe() fails, which is rare but can happen in some embedded or heavily sandboxed environments.

InvalidExecutablePath(String)

Executable path is empty or invalid.

This error occurs when the system returns an empty executable path, which is extremely rare and indicates a corrupted or broken system.

IoError(String)

An I/O operation failed.

This error occurs when filesystem operations fail, such as:

• Creating directories fails due to permissions
• Disk space is insufficient
• Path contains invalid characters for the filesystem
• Network filesystem issues

Trait Implementations

impl Clone for AppPathError

fn clone(&self) -> AppPathError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AppPathError

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

Formats the value using the given formatter.

impl Display for AppPathError

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

Formats the value using the given formatter.

impl Error for AppPathError

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, &PathBuf)> for AppPathError

Creates an IoError with path context for better debugging.

This implementation adds the file path to I/O error messages, making it easier to identify which path caused the failure in complex directory operations.

Examples

use app_path::AppPathError;
use std::path::PathBuf;

let io_error = std::io::Error::new(std::io::ErrorKind::PermissionDenied, "access denied");
let path = PathBuf::from("/some/restricted/path");
let app_error = AppPathError::from((io_error, &path));

// Error message includes both the original error and the path
assert!(app_error.to_string().contains("access denied"));
assert!(app_error.to_string().contains("/some/restricted/path"));

fn from((err, path): (Error, &PathBuf)) -> Self

Converts to this type from the input type.

impl From<Error> for AppPathError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl PartialEq for AppPathError

fn eq(&self, other: &AppPathError) -> 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 Eq for AppPathError

impl StructuralPartialEq for AppPathError