Conditional Compilation

// Conditional compilation based on target OS
#[cfg(target_os = "windows")]
fn get_config_dir() -> PathBuf {
    PathBuf::from(r"C:\ProgramData\MyApp")
}

#[cfg(target_os = "macos")]
fn get_config_dir() -> PathBuf {
    PathBuf::from("/Library/Application Support/MyApp")
}

#[cfg(target_os = "linux")]
fn get_config_dir() -> PathBuf {
    let home = env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
    PathBuf::from(format!("{}/.config/myapp", home))
}

// Usage remains the same across platforms
fn main() {
    let config_dir = get_config_dir();
    println!("Config directory: {:?}", config_dir);
}

fn main() {
    // Check configuration at runtime
    if cfg!(target_os = "windows") {
        println!("Running on Windows");
    } else if cfg!(target_os = "macos") {
        println!("Running on macOS");
    } else if cfg!(target_os = "linux") {
        println!("Running on Linux");
    }
    
    // Combine multiple conditions
    if cfg!(all(target_arch = "x86_64", target_os = "linux")) {
        println!("Running on 64-bit Linux");
    }
    
    // Check for debug vs release builds
    if cfg!(debug_assertions) {
        println!("Debug build with assertions enabled");
    } else {
        println!("Release build");
    }
}

# Cargo.toml
[package]
name = "my-crate"
version = "0.1.0"

[features]
default = ["json-support"]
json-support = ["serde", "serde_json"]
xml-support = ["quick-xml"]
async-support = ["tokio"]
full = ["json-support", "xml-support", "async-support"]

[dependencies]
serde = { version = "1.0", optional = true }
serde_json = { version = "1.0", optional = true }
quick-xml = { version = "0.22", optional = true }
tokio = { version = "1.0", optional = true }

// Use feature flags in code
#[cfg(feature = "json-support")]
use serde_json;

#[cfg(feature = "json-support")]
pub fn parse_json(input: &str) -> Result {
    serde_json::from_str(input)
}

#[cfg(feature = "xml-support")]
pub fn parse_xml(input: &str) -> Result {
    // XML parsing implementation
}

#[cfg(feature = "async-support")]
pub async fn async_process(data: Vec) -> Result {
    // Async processing implementation
    tokio::time::sleep(Duration::from_millis(100)).await;
    Ok(ProcessedData::new(data))
}

// Provide fallback for missing features
#[cfg(not(feature = "json-support"))]
pub fn parse_json(_input: &str) -> Result<(), &'static str> {
    Err("JSON support not enabled")
}

// AND logic - all conditions must be true
#[cfg(all(target_os = "linux", target_arch = "x86_64"))]
fn linux_x64_specific() {
    println!("This only runs on 64-bit Linux");
}

// OR logic - any condition can be true
#[cfg(any(target_os = "windows", target_os = "macos"))]
fn desktop_only() {
    println!("This runs on desktop platforms");
}

// NOT logic - condition must be false
#[cfg(not(target_os = "windows"))]
fn non_windows() {
    println!("This runs on everything except Windows");
}

// Complex combinations
#[cfg(all(
    any(target_os = "linux", target_os = "macos"),
    target_arch = "x86_64",
    feature = "advanced-features"
))]
fn complex_condition() {
    println!("Complex conditional compilation");
}

# Set custom cfg values via command line
cargo build --cfg custom_config
cargo build --cfg 'feature="experimental"'

# Multiple configurations
cargo build --cfg debug_mode --cfg 'version="1.0"'

// build.rs
use std::env;

fn main() {
    // Set configuration based on environment
    if env::var("ENABLE_EXPERIMENTAL").is_ok() {
        println!("cargo:rustc-cfg=experimental");
    }
    
    // Conditional configuration based on target
    let target = env::var("TARGET").unwrap();
    if target.contains("embedded") {
        println!("cargo:rustc-cfg=embedded_target");
    }
    
    // Version-based configuration
    let version = env::var("CARGO_PKG_VERSION").unwrap();
    if version.starts_with("2.") {
        println!("cargo:rustc-cfg=version_2");
    }
}

// Use custom configuration in code
#[cfg(experimental)]
pub fn experimental_feature() -> Result {
    // Cutting-edge functionality
    Ok("Experimental result".to_string())
}

#[cfg(embedded_target)]
const BUFFER_SIZE: usize = 512; // Small buffer for embedded

#[cfg(not(embedded_target))]
const BUFFER_SIZE: usize = 8192; // Large buffer for desktop

#[cfg(version_2)]
pub fn new_api() -> ApiV2 {
    ApiV2::new()
}

#[cfg(not(version_2))]
pub fn new_api() -> ApiV1 {
    ApiV1::new()
}

// Conditional imports
#[cfg(target_family = "unix")]
use std::os::unix::fs::PermissionsExt;

#[cfg(target_os = "windows")]
use std::os::windows::fs::MetadataExt;

// Conditional module declarations
#[cfg(feature = "networking")]
pub mod network;

#[cfg(feature = "database")]
pub mod db;

// Platform-specific implementations
#[cfg(target_os = "linux")]
mod platform {
    pub fn get_system_info() -> String {
        std::fs::read_to_string("/proc/version")
            .unwrap_or_else(|_| "Unknown".to_string())
    }
}

#[cfg(target_os = "windows")]
mod platform {
    pub fn get_system_info() -> String {
        "Windows System".to_string()
    }
}

pub use platform::get_system_info;

// Test-only code
#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_basic_functionality() {
        assert_eq!(add(2, 3), 5);
    }
    
    // Platform-specific tests
    #[cfg(target_os = "linux")]
    #[test]
    fn test_linux_specific() {
        // Linux-only test
    }
}

// Debug-only functionality
#[cfg(debug_assertions)]
pub fn debug_info() -> String {
    format!("Debug build at {}", file!())
}

// Mock implementations for testing
#[cfg(test)]
pub fn get_data() -> Vec {
    vec![1, 2, 3, 4, 5] // Test data
}

#[cfg(not(test))]
pub fn get_data() -> Vec {
    // Real implementation
    std::fs::read("data.bin").unwrap_or_default()
}