### Get User Base Directories with choose_base_strategy

Source: https://context7.com/lunacookies/etcetera/llms.txt

Use this function to retrieve the current OS's default BaseStrategy for user-level directories. It defaults to Windows strategy on Windows and XDG strategy elsewhere. This is useful when you need base directories without application-specific subdirectories.

```rust
use etcetera::{choose_base_strategy, BaseStrategy};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = choose_base_strategy()?;

    // Get the user's home directory
    let home = strategy.home_dir();
    println!("Home: {:?}", home);

    // Get base directories (without app-specific subdirectories)
    // Linux/macOS: ~/.config/
    // Windows: ~/AppData/Roaming/
    let config_dir = strategy.config_dir();
    println!("Config directory: {:?}", config_dir);

    // Linux/macOS: ~/.local/share/
    // Windows: ~/AppData/Roaming/
    let data_dir = strategy.data_dir();
    println!("Data directory: {:?}", data_dir);

    // Linux/macOS: ~/.cache/
    // Windows: ~/AppData/Local/
    let cache_dir = strategy.cache_dir();
    println!("Cache directory: {:?}", cache_dir);

    // Linux/macOS: ~/.local/state/ (Some)
    // Windows: None
    if let Some(state_dir) = strategy.state_dir() {
        println!("State directory: {:?}", state_dir);
    }

    // Only available if XDG_RUNTIME_DIR is set
    if let Some(runtime_dir) = strategy.runtime_dir() {
        println!("Runtime directory: {:?}", runtime_dir);
    }

    Ok(())
}
```

--------------------------------

### choose_base_strategy - Get User Base Directories

Source: https://context7.com/lunacookies/etcetera/llms.txt

This function returns the current OS's default BaseStrategy for obtaining user-level configuration, data, and cache directories. It defaults to the Windows strategy on Windows and the XDG strategy on other operating systems. This is useful when you need base directories without application-specific subdirectories.

```APIDOC
## choose_base_strategy - Get User Base Directories

### Description
Returns the current OS's default BaseStrategy for obtaining user-level configuration, data, and cache directories. Uses Windows strategy on Windows, and XDG strategy everywhere else. This is ideal when you need the base directories without application-specific subdirectories.

### Method
Rust Function Call

### Endpoint
N/A (Library Function)

### Parameters
None

### Request Example
```rust
use etcetera::{choose_base_strategy, BaseStrategy};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = choose_base_strategy()?;

    // Get the user's home directory
    let home = strategy.home_dir();
    println!("Home: {:?}", home);

    // Get base directories (without app-specific subdirectories)
    // Linux/macOS: ~/.config/
    // Windows: ~/AppData/Roaming/
    let config_dir = strategy.config_dir();
    println!("Config directory: {:?}", config_dir);

    // Linux/macOS: ~/.local/share/
    // Windows: ~/AppData/Roaming/
    let data_dir = strategy.data_dir();
    println!("Data directory: {:?}", data_dir);

    // Linux/macOS: ~/.cache/
    // Windows: ~/AppData/Local/
    let cache_dir = strategy.cache_dir();
    println!("Cache directory: {:?}", cache_dir);

    // Linux/macOS: ~/.local/state/ (Some)
    // Windows: None
    if let Some(state_dir) = strategy.state_dir() {
        println!("State directory: {:?}", state_dir);
    }

    // Only available if XDG_RUNTIME_DIR is set
    if let Some(runtime_dir) = strategy.runtime_dir() {
        println!("Runtime directory: {:?}", runtime_dir);
    }

    Ok(())
}
```

### Response
#### Success Response (Result<BaseStrategy, Error>)
- **strategy** (BaseStrategy) - An object implementing the BaseStrategy trait, providing methods to access user-level directories.

#### Response Example
(Output depends on the operating system and environment variables. Example for Linux):
```
Home: Some("/home/user")
Config directory: Some("/home/user/.config")
Data directory: Some("/home/user/.local/share")
Cache directory: Some("/home/user/.cache")
State directory: Some("/home/user/.local/state")
Runtime directory: Some("/run/user/1000")
```
```

--------------------------------

### choose_app_strategy - Get Application-Specific Directories

Source: https://context7.com/lunacookies/etcetera/llms.txt

This function returns the current OS's default AppStrategy for obtaining application-specific directory locations. It requires `AppStrategyArgs` containing application metadata. Similar to `choose_base_strategy`, it defaults to Windows strategy on Windows and XDG strategy elsewhere. This is ideal for CLI applications needing dedicated configuration and data directories.

```APIDOC
## choose_app_strategy - Get Application-Specific Directories

### Description
Returns the current OS's default AppStrategy for obtaining application-specific directory locations. Requires `AppStrategyArgs` with application metadata. Uses Windows strategy on Windows, and XDG strategy everywhere else. Perfect for CLI applications that need dedicated configuration and data directories.

### Method
Rust Function Call

### Endpoint
N/A (Library Function)

### Parameters
#### Request Body (AppStrategyArgs)
- **top_level_domain** (string) - Required - The top-level domain of your organization (e.g., "com", "org").
- **author** (string) - Required - The name of your organization or author.
- **app_name** (string) - Required - The name of your application.

### Request Example
```rust
use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = choose_app_strategy(AppStrategyArgs {
        top_level_domain: "org".to_string(),
        author: "Acme Corp".to_string(),
        app_name: "Frobnicator Plus".to_string(),
    })?;

    // Get application-specific directories
    // XDG (Linux/macOS): ~/.config/frobnicator-plus/
    // Windows: ~/AppData/Roaming/Acme Corp/Frobnicator Plus/config/
    let config_dir = strategy.config_dir();
    println!("Config directory: {:?}", config_dir);

    // XDG: ~/.local/share/frobnicator-plus/
    // Windows: ~/AppData/Roaming/Acme Corp/Frobnicator Plus/data/
    let data_dir = strategy.data_dir();
    println!("Data directory: {:?}", data_dir);

    // XDG: ~/.cache/frobnicator-plus/
    // Windows: ~/AppData/Local/Acme Corp/Frobnicator Plus/cache/
    let cache_dir = strategy.cache_dir();
    println!("Cache directory: {:?}", cache_dir);

    // Convenience method: construct paths inside directories
    let config_file = strategy.in_config_dir("config.toml");
    let database_file = strategy.in_data_dir("database.sqlite");
    let temp_file = strategy.in_cache_dir("temp.txt");

    println!("Config file: {:?}", config_file);
    println!("Database: {:?}", database_file);
    println!("Temp file: {:?}", temp_file);

    // State and runtime directories (XDG only)
    if let Some(state_file) = strategy.in_state_dir("app.state") {
        println!("State file: {:?}", state_file);
    }

    Ok(())
}
```

### Response
#### Success Response (Result<AppStrategy, Error>)
- **strategy** (AppStrategy) - An object implementing the AppStrategy trait, providing methods to access application-specific directories and construct paths within them.

#### Response Example
(Output depends on the operating system. Example for Linux with the provided args):
```
Config directory: Some("/home/user/.config/frobnicator-plus")
Data directory: Some("/home/user/.local/share/frobnicator-plus")
Cache directory: Some("/home/user/.cache/frobnicator-plus")
Config file: Some("/home/user/.config/frobnicator-plus/config.toml")
Database: Some("/home/user/.local/share/frobnicator-plus/database.sqlite")
Temp file: Some("/home/user/.cache/frobnicator-plus/temp.txt")
State file: Some("/home/user/.local/state/frobnicator-plus/app.state")
```
```

--------------------------------

### Get Application-Specific Directories with choose_app_strategy

Source: https://context7.com/lunacookies/etcetera/llms.txt

This function retrieves the current OS's default AppStrategy for application-specific directories, requiring AppStrategyArgs with application metadata. It defaults to Windows strategy on Windows and XDG strategy elsewhere, making it ideal for CLI applications needing dedicated directories.

```rust
use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = choose_app_strategy(AppStrategyArgs {
        top_level_domain: "org".to_string(),
        author: "Acme Corp".to_string(),
        app_name: "Frobnicator Plus".to_string(),
    })?;

    // Get application-specific directories
    // XDG (Linux/macOS): ~/.config/frobnicator-plus/
    // Windows: ~/AppData/Roaming/Acme Corp/Frobnicator Plus/config/
    let config_dir = strategy.config_dir();
    println!("Config directory: {:?}", config_dir);

    // XDG: ~/.local/share/frobnicator-plus/
    // Windows: ~/AppData/Roaming/Acme Corp/Frobnicator Plus/data/
    let data_dir = strategy.data_dir();
    println!("Data directory: {:?}", data_dir);

    // XDG: ~/.cache/frobnicator-plus/
    // Windows: ~/AppData/Local/Acme Corp/Frobnicator Plus/cache/
    let cache_dir = strategy.cache_dir();
    println!("Cache directory: {:?}", cache_dir);

    // Convenience method: construct paths inside directories
    let config_file = strategy.in_config_dir("config.toml");
    let database_file = strategy.in_data_dir("database.sqlite");
    let temp_file = strategy.in_cache_dir("temp.txt");

    println!("Config file: {:?}", config_file);
    println!("Database: {:?}", database_file);
    println!("Temp file: {:?}", temp_file);

    // State and runtime directories (XDG only)
    if let Some(state_file) = strategy.in_state_dir("app.state") {
        println!("State file: {:?}", state_file);
    }

    Ok(())
}
```

--------------------------------

### Choose Native Strategy for Platform-Native GUI Directories

Source: https://context7.com/lunacookies/etcetera/llms.txt

Use this strategy for GUI applications to follow native platform conventions. It defaults to Apple's Standard Directories on macOS/iOS.

```rust
use etcetera::app_strategy::{choose_native_strategy, AppStrategy, AppStrategyArgs);

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = choose_native_strategy(AppStrategyArgs {
        top_level_domain: "org".to_string(),
        author: "Acme Corp".to_string(),
        app_name: "Frobnicator Plus".to_string(),
    })?;

    // macOS: ~/Library/Preferences/org.acme-corp.Frobnicator-Plus/
    // Windows: ~/AppData/Roaming/Acme Corp/Frobnicator Plus/config/
    // Linux: ~/.config/frobnicator-plus/
    let config_dir = strategy.config_dir();
    println!("Native config: {:?}", config_dir);

    // macOS: ~/Library/Application Support/org.acme-corp.Frobnicator-Plus/
    // Windows: ~/AppData/Roaming/Acme Corp/Frobnicator Plus/data/
    // Linux: ~/.local/share/frobnicator-plus/
    let data_dir = strategy.data_dir();
    println!("Native data: {:?}", data_dir);

    // macOS: ~/Library/Caches/org.acme-corp.Frobnicator-Plus/
    // Windows: ~/AppData/Local/Acme Corp/Frobnicator Plus/cache/
    // Linux: ~/.cache/frobnicator-plus/
    let cache_dir = strategy.cache_dir();
    println!("Native cache: {:?}", cache_dir);

    Ok(())
}

```

--------------------------------

### Windows Known Folders Strategy

Source: https://context7.com/lunacookies/etcetera/llms.txt

Implements Windows Known Folder conventions for separating config/data (Roaming) from cache (Local). Requires `etcetera` crate.

```rust
use etcetera::app_strategy::{Windows, AppStrategy, AppStrategyArgs};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = Windows::new(AppStrategyArgs {
        top_level_domain: "org".to_string(),
        author: "Acme Corp".to_string(),
        app_name: "Frobnicator Plus".to_string(),
    })?;

    // ~/AppData/Roaming/Acme Corp/Frobnicator Plus/config/
    let config_dir = strategy.config_dir();

    // ~/AppData/Roaming/Acme Corp/Frobnicator Plus/data/
    let data_dir = strategy.data_dir();

    // ~/AppData/Local/Acme Corp/Frobnicator Plus/cache/
    let cache_dir = strategy.cache_dir();

    // Windows strategy does not support state_dir or runtime_dir
    assert!(strategy.state_dir().is_none());
    assert!(strategy.runtime_dir().is_none());

    println!("Windows Config: {:?}", config_dir);
    println!("Windows Data: {:?}", data_dir);
    println!("Windows Cache: {:?}", cache_dir);

    Ok(())
}
```

--------------------------------

### Unix Traditional Single-Folder Strategy

Source: https://context7.com/lunacookies/etcetera/llms.txt

Implements the traditional Unix convention where all application files reside in a single hidden directory in the user's home folder. Requires `etcetera` crate.

```rust
use etcetera::app_strategy::{Unix, AppStrategy, AppStrategyArgs};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = Unix::new(AppStrategyArgs {
        top_level_domain: "org".to_string(),
        author: "Acme Corp".to_string(),
        app_name: "Frobnicator Plus".to_string(),
    })?;

    // All in ~/.frobnicator-plus/
    let config_dir = strategy.config_dir();  // ~/.frobnicator-plus/
    let data_dir = strategy.data_dir();      // ~/.frobnicator-plus/data/
    let cache_dir = strategy.cache_dir();    // ~/.frobnicator-plus/cache/
    let state_dir = strategy.state_dir();    // ~/.frobnicator-plus/state/
    let runtime_dir = strategy.runtime_dir(); // ~/.frobnicator-plus/runtime/

    println!("Unix Config: {:?}", config_dir);
    println!("Unix Data: {:?}", data_dir);
    println!("Unix Cache: {:?}", cache_dir);
    println!("Unix State: {:?}", state_dir);
    println!("Unix Runtime: {:?}", runtime_dir);

    Ok(())
}
```

--------------------------------

### Home Directory Utility

Source: https://context7.com/lunacookies/etcetera/llms.txt

A convenience wrapper around `std::env::home_dir` that returns a `Result` with a descriptive error type instead of an `Option`. Requires `etcetera` crate.

```rust
use etcetera::{home_dir, HomeDirError};

fn main() {
    match home_dir() {
        Ok(path) => {
            println!("Home directory: {:?}", path);

            // Use for manual path construction
            let my_config = path.join(".myapp").join("config.toml");
            println!("Config path: {:?}", my_config);
        }
        Err(HomeDirError) => {
            eprintln!("Error: Could not locate home directory");
            std::process::exit(1);
        }
    }
}
```

--------------------------------

### AppStrategyArgs for Application Metadata

Source: https://context7.com/lunacookies/etcetera/llms.txt

Provides application metadata used to construct platform-specific directory paths. Includes helper methods for generating bundle identifiers and Unix-style names. Requires `etcetera` crate.

```rust
use etcetera::AppStrategyArgs;

fn main() {
    let args = AppStrategyArgs {
        top_level_domain: "io.github".to_string(),
        author: "Jane Developer".to_string(),
        app_name: "My Cool App".to_string(),
    };

    // Generate Apple-style bundle identifier
    // "io.github.jane-developer.My-Cool-App"
    let bundle_id = args.bundle_id();
    println!("Bundle ID: {}", bundle_id);

    // Generate Unix-style lowercase name
    // "my-cool-app"
    let unixy_name = args.unixy_name();
    println!("Unix name: {}", unixy_name);

    // Use with any strategy
    // XDG will use: ~/.config/my-cool-app/
    // Apple will use: ~/Library/Preferences/io.github.jane-developer.My-Cool-App/
    // Windows will use: ~/AppData/Roaming/Jane Developer/My Cool App/
}
```

--------------------------------

### Apple Strategy for macOS/iOS Standard Directories

Source: https://context7.com/lunacookies/etcetera/llms.txt

Implements Apple's Standard Directories specification for macOS and iOS, using bundle identifier format for application directories. Does not support state_dir or runtime_dir.

```rust
use etcetera::app_strategy::{Apple, AppStrategy, AppStrategyArgs);

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = Apple::new(AppStrategyArgs {
        top_level_domain: "org".to_string(),
        author: "Acme Corp".to_string(),
        app_name: "Frobnicator Plus".to_string(),
    })?;

    // ~/Library/Preferences/org.acme-corp.Frobnicator-Plus/
    let config_dir = strategy.config_dir();

    // ~/Library/Application Support/org.acme-corp.Frobnicator-Plus/
    let data_dir = strategy.data_dir();

    // ~/Library/Caches/org.acme-corp.Frobnicator-Plus/
    let cache_dir = strategy.cache_dir();

    // Apple strategy does not support state_dir or runtime_dir
    assert!(strategy.state_dir().is_none());
    assert!(strategy.runtime_dir().is_none());

    println!("Apple Config: {:?}", config_dir);
    println!("Apple Data: {:?}", data_dir);
    println!("Apple Cache: {:?}", cache_dir);

    Ok(())
}

```

--------------------------------

### XDG Strategy for XDG Base Directory Specification

Source: https://context7.com/lunacookies/etcetera/llms.txt

Implements the XDG Base Directory Specification, respecting XDG environment variables. Falls back to default locations if variables are not set.

```rust
use etcetera::app_strategy::{Xdg, AppStrategy, AppStrategyArgs);

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let strategy = Xdg::new(AppStrategyArgs {
        top_level_domain: "org".to_string(),
        author: "Acme Corp".to_string(),
        app_name: "Frobnicator Plus".to_string(),
    })?;

    // Default locations (when XDG env vars not set):
    // ~/.config/frobnicator-plus/
    let config_dir = strategy.config_dir();

    // ~/.local/share/frobnicator-plus/
    let data_dir = strategy.data_dir();

    // ~/.cache/frobnicator-plus/
    let cache_dir = strategy.cache_dir();

    // ~/.local/state/frobnicator-plus/
    let state_dir = strategy.state_dir();

    // Returns Some only if XDG_RUNTIME_DIR is set to an absolute path
    let runtime_dir = strategy.runtime_dir();

    println!("XDG Config: {:?}", config_dir);
    println!("XDG Data: {:?}", data_dir);
    println!("XDG Cache: {:?}", cache_dir);
    println!("XDG State: {:?}", state_dir);
    println!("XDG Runtime: {:?}", runtime_dir);

    // XDG respects environment variables when set to absolute paths
    // std::env::set_var("XDG_CONFIG_HOME", "/custom/config");
    // Would make config_dir return /custom/config/frobnicator-plus/

    Ok(())
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.