Enum AppPathError

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

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.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 types
        match io_err.kind() {
            std::io::ErrorKind::PermissionDenied => {
                eprintln!("Permission denied - check file permissions");
            }
            std::io::ErrorKind::NotFound => {
                eprintln!("File or directory not found");
            }
            _ => eprintln!("Other I/O error: {io_err}"),
        }
    }
}

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(Error)

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

The original std::io::Error is preserved, allowing users to:

• Check specific error kinds (error.kind())
• Access OS error codes (error.raw_os_error())
• Handle different I/O errors appropriately

Trait Implementations

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.