Sysproxy

https://docs.rs/sysproxy/0.3.0
Admin
Sysproxy is a Rust library for getting and setting system proxy settings across Windows, macOS, and...
Tokens:28,445
Snippets:240
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Get System Proxy

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the current system proxy configuration.

```APIDOC
## get_system_proxy()

### Description
Retrieves the current system proxy configuration.

### Returns
- `Result<Sysproxy>`: A `Result` containing the `Sysproxy` configuration if successful, or an error otherwise.
```

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

### Get HTTP Proxy

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the HTTP proxy configuration.

```APIDOC
## get_http()

### Description
Retrieves the HTTP proxy configuration.

### Returns
- `Result<Sysproxy>`: A `Result` containing the `Sysproxy` configuration for HTTP if successful, or an error.
```

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

### Get HTTP Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Retrieves the configured host and port for the HTTP proxy.

```APIDOC
## get_http()

### Description
Retrieves the current HTTP proxy configuration.

### Returns
- `Result<Sysproxy>`: A `Sysproxy` struct containing the HTTP proxy host and port.

### Example
```rust
let http_proxy = Sysproxy::get_http()?;
println!("HTTP Proxy: {}:{}", http_proxy.host, http_proxy.port);
```
```

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

### Get HTTP Proxy Settings

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the system's HTTP proxy configuration. Returns a Result containing a Sysproxy struct.

```rust
pub fn get_http() -> Result<Sysproxy>
```

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

### Get SOCKS Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Retrieves the configured host and port for the SOCKS proxy.

```APIDOC
## get_socks()

### Description
Retrieves the current SOCKS proxy configuration.

### Returns
- `Result<Sysproxy>`: A `Sysproxy` struct containing the SOCKS proxy host and port.

### Example
```rust
let socks_proxy = Sysproxy::get_socks()?;
println!("SOCKS Proxy: {}:{}", socks_proxy.host, socks_proxy.port);
```
```

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

### Get Enable Status

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the current enable status of the system proxy.

```APIDOC
## get_enable()

### Description
Retrieves the current enable status of the system proxy.

### Returns
- `Result<bool>`: A `Result` containing `true` if the proxy is enabled, `false` otherwise, or an error.
```

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

### Get System Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Retrieves the current system-wide proxy settings, including enable status, proxy hosts and ports for HTTP, HTTPS, and SOCKS, and the bypass list.

```APIDOC
## get_system_proxy()

### Description
Retrieves the current system-wide proxy configuration.

### Returns
- `Result<Sysproxy>`: A `Sysproxy` struct containing the proxy settings.

### Example
```rust
let proxy_settings = Sysproxy::get_system_proxy()?;
println!("SOCKS Host: {}", proxy_settings.host);
```
```

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

### Get System Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Retrieves the current system-wide proxy configuration, including HTTP, HTTPS, and SOCKS settings, as well as the proxy enable status and bypass list. It intelligently merges settings if SOCKS is not explicitly configured.

```rust
use crate::{Error, Result, Sysproxy};
use std::{process::Command, str::from_utf8};

const CMD_KEY: &str = "org.gnome.system.proxy";

impl Sysproxy {
    pub fn get_system_proxy() -> Result<Sysproxy> {
        let enable = Sysproxy::get_enable()?;

        let mut socks = get_proxy("socks")?;
        let https = get_proxy("https")?;
        let http = get_proxy("http")?;

        if socks.host.len() == 0 {
            if http.host.len() > 0 {
                socks.host = http.host;
                socks.port = http.port;
            }
            if https.host.len() > 0 {
                socks.host = https.host;
                socks.port = https.port;
            }
        }

        socks.enable = enable;
        socks.bypass = Sysproxy::get_bypass().unwrap_or("".into());

        Ok(socks)
    }
// ... other methods
```

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

### Get HTTPS Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Retrieves the configured host and port for the HTTPS proxy.

```APIDOC
## get_https()

### Description
Retrieves the current HTTPS proxy configuration.

### Returns
- `Result<Sysproxy>`: A `Sysproxy` struct containing the HTTPS proxy host and port.

### Example
```rust
let https_proxy = Sysproxy::get_https()?;
println!("HTTPS Proxy: {}:{}", https_proxy.host, https_proxy.port);
```
```

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

### Get SOCKS Proxy

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the SOCKS proxy configuration.

```APIDOC
## get_socks()

### Description
Retrieves the SOCKS proxy configuration.

### Returns
- `Result<Sysproxy>`: A `Result` containing the `Sysproxy` configuration for SOCKS if successful, or an error.
```

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

### Get HTTPS Proxy

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the HTTPS proxy configuration.

```APIDOC
## get_https()

### Description
Retrieves the HTTPS proxy configuration.

### Returns
- `Result<Sysproxy>`: A `Result` containing the `Sysproxy` configuration for HTTPS if successful, or an error.
```

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

### Get Proxy Details from GSettings

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Internal function to retrieve proxy host and port for a given service from `gsettings`. It handles parsing the output and converting the port to a `u16`.

```rust
fn get_proxy(service: &str) -> Result<Sysproxy> {
    let schema = format!("{CMD_KEY}.{service}");
    let schema = schema.as_str();

    let host = gsettings().args(["get", schema, "host"]).output()?;
    let host = from_utf8(&host.stdout).or(Err(Error::ParseStr))?.trim();
    let host = strip_str(host);

    let port = gsettings().args(["get", schema, "port"]).output()?;
    let port = from_utf8(&port.stdout).or(Err(Error::ParseStr))?.trim();
    let port = port.parse().unwrap_or(80u16);

    Ok(Sysproxy {
        enable: false,
        host: String::from(host),
        port,
        bypass: "".into(),
    })
}
```

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

### Get HTTPS Proxy Settings

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the system's HTTPS proxy configuration. Returns a Result containing a Sysproxy struct.

```rust
pub fn get_https() -> Result<Sysproxy>
```

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

### Get SOCKS Proxy Settings

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the system's SOCKS proxy configuration. Returns a Result containing a Sysproxy struct.

```rust
pub fn get_socks() -> Result<Sysproxy>
```

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

### Get Proxy Bypass List

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Fetches the list of hosts to ignore from system proxy settings. It parses the string representation of the list and returns a comma-separated string of hosts.

```rust
impl Sysproxy {
    // ... other methods
    pub fn get_bypass() -> Result<String> {
        let bypass = gsettings()
            .args(["get", CMD_KEY, "ignore-hosts"])
            .output()?;
        let bypass = from_utf8(&bypass.stdout).or(Err(Error::ParseStr))?.trim();

        let bypass = bypass.strip_prefix('[').unwrap_or(bypass);
        let bypass = bypass.strip_suffix(']').unwrap_or(bypass);

        let bypass = bypass
            .split(',')
            .map(|h| strip_str(h.trim()))
            .collect::<Vec<&str>>()
            .join(",");

        Ok(bypass)
    }
// ... other methods
```

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

### Get Bypass List

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the current bypass list for the system proxy.

```APIDOC
## get_bypass()

### Description
Retrieves the current bypass list for the system proxy.

### Returns
- `Result<String>`: A `Result` containing the bypass list as a string, or an error.
```

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

### Get System Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the current system proxy settings. This function returns a Result containing a Sysproxy struct if successful.

```rust
pub fn get_system_proxy() -> Result<Sysproxy>
```

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

### Get Proxy Bypass List

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the current bypass list for the system proxy. Returns a Result containing a String.

```rust
pub fn get_bypass() -> Result<String>
```

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

### Get References to Result Values

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Use `as_ref` to get a `Result` containing references to the contained values without consuming the original `Result`. This is useful for inspecting values without taking ownership.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### Handling File Metadata with Result

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Demonstrates using `Result` to handle potential errors when accessing file metadata. `and_then` is used to chain operations that might fail, such as getting metadata and then its modification time.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### Unwrapping with expect and handling panics

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Use `expect` to get the contained Ok value, but it will panic if the Result is Err. It's recommended to use this only when you are certain the Result should be Ok, and provide a descriptive panic message.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

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

### Get Proxy Enable Status

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the current enable status of the system proxy. Returns a Result containing a boolean value.

```rust
pub fn get_enable() -> Result<bool>
```

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

### Get Proxy Enable Status

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Retrieves the current manual proxy enablement status from system settings. Returns an error if the status cannot be parsed.

```rust
impl Sysproxy {
    // ... other methods
    pub fn get_enable() -> Result<bool> {
        let mode = gsettings().args(["get", CMD_KEY, "mode"]).output()?;
        let mode = from_utf8(&mode.stdout).or(Err(Error::ParseStr))?.trim();
        Ok(mode == "'manual'")
    }
// ... other methods
```

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

### Get Proxy Enable Status

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Checks whether the system proxy is currently enabled or disabled.

```APIDOC
## get_enable()

### Description
Retrieves the current enable status of the system proxy.

### Returns
- `Result<bool>`: `true` if the proxy is enabled, `false` otherwise.

### Example
```rust
let is_enabled = Sysproxy::get_enable()?;
println!("Proxy enabled: {}", is_enabled);
```
```

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

### Get Proxy Bypass List

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Retrieves the list of hosts or domains that should be bypassed by the proxy settings.

```APIDOC
## get_bypass()

### Description
Retrieves the list of hosts that are ignored by the system proxy.

### Returns
- `Result<String>`: A comma-separated string of hosts to bypass.

### Example
```rust
let bypass_list = Sysproxy::get_bypass()?;
println!("Bypass list: {}", bypass_list);
```
```

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

### Implement ToString for generic types

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/enum.Error.html

Converts any type that implements the Display trait into a String. This is a convenient way to get a string representation.

```rust
impl<T> ToString for T
where T: Display + ?Sized,
{
    fn to_string(&self) -> String
}
```

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

### into_ok

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Returns the contained Ok value, but never panics. This is a nightly-only experimental API.

```APIDOC
## into_ok

### Description
Returns the contained `Ok` value, but never panics. Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur. This is a nightly-only experimental API.

### Method
`into_ok()`

### Request Example
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```
```

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

### Get Mutable References to Result Values

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Use `as_mut` to get a `Result` containing mutable references to the contained values, allowing in-place modification. This is useful for modifying the success or error value directly.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### Basic Result Usage

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Demonstrates the basic usage of the Result type, showing how to extract a value from an Ok variant.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

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

### Is Support

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Checks if the system proxy functionality is supported on the current platform.

```APIDOC
## is_support()

### Description
Checks if the system proxy functionality is supported on the current platform.

### Returns
- `bool`: `true` if supported, `false` otherwise.
```

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

### Set HTTP Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Configures the host and port for the HTTP proxy.

```APIDOC
## set_http(&self)

### Description
Sets the HTTP proxy host and port.

### Returns
- `Result<()>`: Ok if the settings were applied successfully, or an error.

### Example
```rust
let mut proxy = Sysproxy::get_system_proxy()?;
proxy.host = "proxy.example.com".to_string();
proxy.port = 8080;
proxy.set_http()?;
```
```

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

### is_support Function

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/lib.rs.html

Checks if the current operating system is supported by the sysproxy library.

```APIDOC
## is_support()

### Description
Determines if the sysproxy library's functionality is available on the current platform.

### Returns
- **bool**: `true` if the OS is Windows, macOS, or Linux; `false` otherwise.
```

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

### Set HTTP Proxy Settings

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the system's HTTP proxy configuration using the current Sysproxy instance. Returns a Result indicating success or failure.

```rust
pub fn set_http(&self) -> Result<()>
```

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

### Set SOCKS Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Configures the host and port for the SOCKS proxy.

```APIDOC
## set_socks(&self)

### Description
Sets the SOCKS proxy host and port.

### Returns
- `Result<()>`: Ok if the settings were applied successfully, or an error.

### Example
```rust
let mut proxy = Sysproxy::get_system_proxy()?;
proxy.host = "socks.example.com".to_string();
proxy.port = 1080;
proxy.set_socks()?;
```
```

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

### Get Type ID

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Retrieves the TypeId of the current object. This is part of the Any trait implementation.

```rust
fn type_id(&self) -> TypeId
```

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

### Set System Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Applies the specified system-wide proxy settings. This includes enabling or disabling the proxy, setting the HTTP, HTTPS, and SOCKS proxy hosts and ports, and configuring the bypass list.

```APIDOC
## set_system_proxy(&self)

### Description
Sets the system-wide proxy configuration based on the `Sysproxy` struct.

### Parameters
- `self` (`&Sysproxy`): A reference to a `Sysproxy` struct containing the desired proxy settings.

### Returns
- `Result<()>`: Ok if the settings were applied successfully, or an error.

### Example
```rust
let mut proxy = Sysproxy::get_system_proxy()?;
proxy.enable = true;
proxy.host = "127.0.0.1".to_string();
proxy.port = 8080;
proxy.set_system_proxy()?;
```
```

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

### Check Proxy Support

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Determines if the system proxy functionality is supported on the current platform. Returns a boolean value.

```rust
pub fn is_support() -> bool
```

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

### Set SOCKS Proxy Settings

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the system's SOCKS proxy configuration using the current Sysproxy instance. Returns a Result indicating success or failure.

```rust
pub fn set_socks(&self) -> Result<()>
```

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

### Set System Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Applies the specified system-wide proxy configuration, including enabling/disabling proxies, setting HTTP, HTTPS, SOCKS proxy details, and updating the bypass list.

```rust
impl Sysproxy {
    // ... other methods
    pub fn set_system_proxy(&self) -> Result<()> {
        self.set_enable()?;

        if self.enable {
            self.set_socks()?;
            self.set_https()?;
            self.set_http()?;
            self.set_bypass()?;
        }

        Ok(())
    }
// ... other methods
```

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

### Set HTTPS Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Configures the host and port for the HTTPS proxy.

```APIDOC
## set_https(&self)

### Description
Sets the HTTPS proxy host and port.

### Returns
- `Result<()>`: Ok if the settings were applied successfully, or an error.

### Example
```rust
let mut proxy = Sysproxy::get_system_proxy()?;
proxy.host = "proxy.example.com".to_string();
proxy.port = 8080;
proxy.set_https()?;
```
```

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

### Iterating and Calculating Product with Result

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Demonstrates how to use the `product()` method on an iterator of `Result` values. If any element fails to parse, `product()` returns the first `Err` encountered. Otherwise, it returns the Ok value of the computed product.

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
```

```rust
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```

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

### Get Specific Proxy Type

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Helper function to retrieve proxy details (host and port) for a specific service type (e.g., http, https, socks).

```rust
impl Sysproxy {
    // ... other methods
    pub fn get_http() -> Result<Sysproxy> {
        get_proxy("http")
    }

    pub fn get_https() -> Result<Sysproxy> {
        get_proxy("https")
    }

    pub fn get_socks() -> Result<Sysproxy> {
        get_proxy("socks")
    }
// ... other methods
```

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

### Set HTTPS Proxy Settings

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the system's HTTPS proxy configuration using the current Sysproxy instance. Returns a Result indicating success or failure.

```rust
pub fn set_https(&self) -> Result<()>
```

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

### Set System Proxy Configuration

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Applies the system proxy settings defined by the current Sysproxy instance. This method returns a Result indicating success or failure.

```rust
pub fn set_system_proxy(&self) -> Result<()>
```

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

### fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Compares two Results for partial ordering. Requires `T` and `E` to implement `PartialOrd`.

```APIDOC
## fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

### Description
This method returns an ordering between `self` and `other` values if one exists. This comparison requires that both the `Ok` and `Err` types implement the `PartialOrd` trait.

### Parameters
#### Path Parameters
- **other** (&Result<T, E>) - Required - The other Result to compare against.
```

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

### Set System Proxy

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Applies the current Sysproxy configuration to the system.

```APIDOC
## set_system_proxy()

### Description
Applies the current Sysproxy configuration to the system.

### Returns
- `Result<()>`: A `Result` indicating success or failure.
```

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

### ok()

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Converts a Result<T, E> into an Option<T>, consuming the Result and discarding the error if present.

```APIDOC
## pub fn ok(self) -> Option<T>

Converts from `Result<T, E>` to `Option<T>`.
Consumes `self`, and discards the error, if any.

### Description
Converts `self` into an `Option<T>`, consuming `self`, and discarding the error, if any.

### Method
`ok()`

### Parameters
None

### Response
- `Option<T>`: `Some(T)` if the result was `Ok`, `None` if it was `Err`.

### Request Example
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```
```

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

### Set SOCKS Proxy

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the SOCKS proxy configuration.

```APIDOC
## set_socks()

### Description
Sets the SOCKS proxy configuration based on the fields of the `Sysproxy` instance.

### Returns
- `Result<()>`: A `Result` indicating success or failure.
```

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

### Set HTTP Proxy

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the HTTP proxy configuration.

```APIDOC
## set_http()

### Description
Sets the HTTP proxy configuration based on the fields of the `Sysproxy` instance.

### Returns
- `Result<()>`: A `Result` indicating success or failure.
```

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

### Implement From<T> for T

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/enum.Error.html

A trivial implementation that returns the argument unchanged. This is often used in generic contexts.

```rust
impl<T> From<T> for T {
    fn from(t: T) -> T
}
```

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

### Set Proxy Bypass List

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Updates the list of hosts to ignore in system proxy settings. It formats the provided bypass list into the expected string format for `gsettings`.

```rust
impl Sysproxy {
    // ... other methods
    pub fn set_bypass(&self) -> Result<()> {
        let bypass = self
            .bypass
            .split(',')
            .map(|h| {
                let mut host = String::from(h.trim());
                if !host.starts_with('\'') && !host.starts_with('"') {
                    host = String::from("'"') + &host;
                }
                if !host.ends_with('\'') && !host.ends_with('"') {
                    host = host + "'" ;
                }
                host
            })
            .collect::<Vec<String>>()
            .join(", ");

        let bypass = format!("[{bypass}]");

        gsettings()
            .args(["set", CMD_KEY, "ignore-hosts", bypass.as_str()])
            .status()?;
        Ok(())
    }
// ... other methods
```

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

### fn from_residual<E, F>(_: Yeet<E>) -> Result<T, F>

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Constructs a Result from a compatible `Residual` type (`Yeet<E>`). This is an experimental API.

```APIDOC
## fn from_residual<E, F>(_: Yeet<E>) -> Result<T, F>

### Description
Constructs the type from a compatible `Residual` type. This is a nightly-only experimental API (`try_trait_v2`).

### Parameters
#### Path Parameters
- **_** (Yeet<E>) - Required - The residual to construct from.

### Response
#### Success Response (Result<T, F>)
- **T** - The success type.
- **F** - The error type.
```

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

### Set Enable Status

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the enable status of the system proxy.

```APIDOC
## set_enable()

### Description
Sets the enable status of the system proxy based on the `enable` field of the `Sysproxy` instance.

### Returns
- `Result<()>`: A `Result` indicating success or failure.
```

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

### Set Proxy Enable Status

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Sets whether the system proxy should be enabled or disabled.

```APIDOC
## set_enable(&self)

### Description
Sets the enable status for the system proxy.

### Returns
- `Result<()>`: Ok if the status was updated successfully, or an error.

### Example
```rust
let mut proxy = Sysproxy::get_system_proxy()?;
proxy.enable = true;
proxy.set_enable()?;
```
```

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

### fn hash<__H>(&self, state: &mut __H)

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Feeds the Result into a given `Hasher`. Requires `T` and `E` to implement `Hash`.

```APIDOC
## fn hash<__H>(&self, state: &mut __H)

### Description
Feeds this value into the given `Hasher`. This method requires that both the `Ok` and `Err` types implement the `Hash` trait.

### Parameters
#### Path Parameters
- **state** (&mut __H) - Required - The hasher state to feed into.
```

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

### Create From Value

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Creates a new instance from a given value. This is a standard implementation for the From trait.

```rust
fn from(t: T) -> T
```

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

### Sysproxy Library Core Definitions

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/lib.rs.html

Defines the main Sysproxy struct for proxy settings (enable, host, port, bypass) and the Error enum for handling potential issues. This code is conditional based on the target operating system.

```rust
1//! Get/Set system proxy. Supports Windows, macOS and linux (via gsettings).
2
3#[cfg(target_os = "linux")]
4mod linux;
5#[cfg(target_os = "macos")]
6mod macos;
7#[cfg(target_os = "windows")]
8mod windows;
9
10#[derive(Debug, Default, Clone, PartialEq, Eq)]
11pub struct Sysproxy {
12    pub enable: bool,
13    pub host: String,
14    pub port: u16,
15    pub bypass: String,
16}
17
18#[derive(thiserror::Error, Debug)]
19pub enum Error {
20    #[error("failed to parse string")]
21    ParseStr,
22
23    #[error(transparent)]
24    Io(#[from] std::io::Error),
25
26    #[error("failed to get default network interface")]
27    NetworkInterface,
28}
29
30pub type Result<T> = std::result::Result<T, Error>;
31
32impl Sysproxy {
33    pub fn is_support() -> bool {
34        cfg!(any(
35            target_os = "linux",
36            target_os = "macos",
37            target_os = "windows",
38        ))
39    }
40}
```

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

### fn from_iter<I>(iter: I) -> Result<V, E>

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Creates a Result by collecting items from an iterator. If any item is an Err, it's returned immediately. Otherwise, a container with all Ok values is returned.

```APIDOC
## fn from_iter<I>(iter: I) -> Result<V, E>

### Description
Takes each element in the `Iterator`: if it is an `Err`, no further elements are taken, and the `Err` is returned. Should no `Err` occur, a container with the values of each `Result` is returned.

### Parameters
#### Path Parameters
- **iter** (I) - Required - An iterator yielding `Result<A, E>` items.

### Response
#### Success Response (Result<V, E>)
- **V** - A container type holding the successful values.
- **E** - The error type.

#### Error Response (E)
- **E** - The first error encountered in the iterator.

### Example
```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```
```

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

### Set HTTPS Proxy

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the HTTPS proxy configuration.

```APIDOC
## set_https()

### Description
Sets the HTTPS proxy configuration based on the fields of the `Sysproxy` instance.

### Returns
- `Result<()>`: A `Result` indicating success or failure.
```

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

### Convert Result Ok to Option

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

The `ok` method consumes the Result and returns an Option containing the success value if it's Ok, otherwise None. This is useful when you only care about the success value and want to discard errors.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

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

### Set Bypass List

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the bypass list for the system proxy.

```APIDOC
## set_bypass()

### Description
Sets the bypass list for the system proxy based on the `bypass` field of the `Sysproxy` instance.

### Returns
- `Result<()>`: A `Result` indicating success or failure.
```

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

### unwrap

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Returns the contained Ok value. Panics if the value is an Err, with a panic message provided by the Err's value.

```APIDOC
## unwrap

### Description
Returns the contained `Ok` value. Panics if the value is an `Err`, with a panic message provided by the `Err`’s value.

### Method
`unwrap()`

### Request Example
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

### Response Example
```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```
```

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

### fn cmp(&self, other: &Result<T, E>) -> Ordering

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Compares two Results for ordering. Requires `T` and `E` to implement `Ord`.

```APIDOC
## fn cmp(&self, other: &Result<T, E>) -> Ordering

### Description
This method returns an `Ordering` between `self` and `other`. This comparison requires that both the `Ok` and `Err` types implement the `Ord` trait.

### Parameters
#### Path Parameters
- **other** (&Result<T, E>) - Required - The other Result to compare against.
```

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

### impl<T, E> Result<T, E>

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Core implementations for the Result type, including methods to check if the result is Ok or Err.

```APIDOC
## impl<T, E> Result<T, E>

### `is_ok`

```rust
pub const fn is_ok(&self) -> bool
```

Returns `true` if the result is `Ok`.

#### Examples

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

### `is_ok_and`

```rust
pub fn is_ok_and<F>(self, f: F) -> bool
where F: FnOnce(T) -> bool,
```

Returns `true` if the result is `Ok` and the value inside of it matches a predicate.

#### Examples

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

### `is_err`

```rust
pub const fn is_err(&self) -> bool
```

Returns `true` if the result is `Err`.

#### Examples

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

### `is_err_and`

```rust
pub fn is_err_and<F>(self, f: F) -> bool
where F: FnOnce(E) -> bool,
```

Returns `true` if the result is `Err` and the value inside of it matches a predicate.
```

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

### Compare Sysproxy Instances for Equality

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Tests if two Sysproxy instances are equal. This is a standard implementation for the PartialEq trait.

```rust
fn eq(&self, other: &Sysproxy) -> bool
```

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

### Clone to Uninitialized Memory (Nightly)

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Performs copy-assignment from self to uninitialized memory. This is an experimental nightly-only API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### Sysproxy Structure

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/lib.rs.html

Defines the structure for system proxy settings, including enable status, host, port, and bypass list.

```APIDOC
## Sysproxy

### Description
Represents the system proxy configuration.

### Fields
- **enable** (bool) - Indicates if the proxy is enabled.
- **host** (String) - The proxy server hostname or IP address.
- **port** (u16) - The proxy server port number.
- **bypass** (String) - A string containing hosts or domains to bypass the proxy.
```

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

### Sysproxy Struct Definition

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Defines the structure for holding system proxy configuration, including enable status, host, port, and bypass list.

```APIDOC
## Struct Sysproxy

### Fields
- `enable`: bool
- `host`: String
- `port`: u16
- `bypass`: String
```

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

### fn from_residual<E, F>(residual: Result<Infallible, E>) -> Result<T, F>

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Constructs a Result from a compatible `Residual` type. This is an experimental API.

```APIDOC
## fn from_residual<E, F>(residual: Result<Infallible, E>) -> Result<T, F>

### Description
Constructs the type from a compatible `Residual` type. This is a nightly-only experimental API (`try_trait_v2`).

### Parameters
#### Path Parameters
- **residual** (Result<Infallible, E>) - Required - The residual to construct from.

### Response
#### Success Response (Result<T, F>)
- **T** - The success type.
- **F** - The error type.
```

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

### impl<T, E> Result<&T, E>

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Implementations for Result with references, providing methods to copy or clone the contained value.

```APIDOC
## impl<T, E> Result<&T, E>

### `copied`

```rust
pub const fn copied(self) -> Result<T, E>
where T: Copy,
```

Maps a `Result<&T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part.

#### Examples

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

### `cloned`

```rust
pub fn cloned(self) -> Result<T, E>
where T: Clone,
```

Maps a `Result<&T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part.

#### Examples

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```
```

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

### Combine Results with `and`

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Returns the second Result if the first is Ok, otherwise returns the first Result's Err. Arguments are eagerly evaluated.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));
```

```rust
let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));
```

```rust
let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));
```

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

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

### Set Specific Proxy Type

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Helper function to set proxy details (host and port) for a specific service type (e.g., http, https, socks) using `gsettings`.

```rust
impl Sysproxy {
    // ... other methods
    pub fn set_http(&self) -> Result<()> {
        set_proxy(self, "http")
    }

    pub fn set_https(&self) -> Result<()> {
        set_proxy(self, "https")
    }

    pub fn set_socks(&self) -> Result<()> {
        set_proxy(self, "socks")
    }
}

fn gsettings() -> Command {
    Command::new("gsettings")
}

fn set_proxy(proxy: &Sysproxy, service: &str) -> Result<()> {
    let schema = format!("{CMD_KEY}.{service}");
    let schema = schema.as_str();

    let host = format!("'{}'", proxy.host);
    let host = host.as_str();
    let port = format!("{}", proxy.port);
    let port = port.as_str();

    gsettings().args(["set", schema, "host", host]).status()?;
    gsettings().args(["set", schema, "port", port]).status()?;

    Ok(())
}
```

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

### Implement TryInto<U> for T

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/enum.Error.html

Enables fallible conversion from type T to type U. This is the reciprocal of TryFrom.

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
}
```

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

### Sysproxy Struct Definition

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Defines the structure for system proxy settings, containing fields for enabling the proxy, host address, port number, and a bypass list.

```rust
pub struct Sysproxy {
    pub enable: bool,
    pub host: String,
    pub port: u16,
    pub bypass: String,
}
```

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

### Set Proxy Enable Status

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Sets the manual proxy enablement status in system settings. Accepts a boolean to determine whether to set the mode to 'manual' or 'none'.

```rust
impl Sysproxy {
    // ... other methods
    pub fn set_enable(&self) -> Result<()> {
        let mode = if self.enable { "'manual'" } else { "'none'" };
        gsettings().args(["set", CMD_KEY, "mode", mode]).status()?;
        Ok(())
    }
// ... other methods
```

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

### Unwrapping with unwrap

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

The `unwrap` method returns the contained Ok value, consuming the Result. It panics if the Result is Err. Its use is generally discouraged in favor of safer methods like `?` or pattern matching.

```rust
let x: Result<u32, &str> = Ok(10);
assert_eq!(x.unwrap(), 10);
```

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

### unwrap_or(self, default: T) -> T

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Returns the contained `Ok` value or a provided default. Arguments passed to `unwrap_or` are eagerly evaluated.

```APIDOC
## pub fn unwrap_or(self, default: T) -> T

### Description
Returns the contained `Ok` value or a provided default.
Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `unwrap_or_else`, which is lazily evaluated.

### Parameters
* `default`: The default value to return if `self` is `Err`.

### Request Example
```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

### Response
#### Success Response (T)
Returns the `Ok` value if `self` is `Ok`.

#### Success Response (T)
Returns the `default` value if `self` is `Err`.
```

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

### fn le(&self, other: &Rhs) -> bool

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Tests if the first Result is less than or equal to the second. Requires `T` and `E` to implement `PartialOrd`.

```APIDOC
## fn le(&self, other: &Rhs) -> bool

### Description
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. This comparison requires that both the `Ok` and `Err` types implement the `PartialOrd` trait.

### Parameters
#### Path Parameters
- **other** (&Rhs) - Required - The other value to compare against.
```

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

### Implement From<Error> for Error

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/enum.Error.html

Allows converting an existing Error into itself. This is a common pattern for error handling and type conversions.

```rust
impl From<Error> for Error {
    fn from(source: Error) -> Self
}
```

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

### into_err

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Returns the contained Err value, but never panics. This is a nightly-only experimental API.

```APIDOC
## into_err

### Description
Returns the contained `Err` value, but never panics. Unlike `unwrap_err`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap_err` as a maintainability safeguard that will fail to compile if the ok type of the `Result` is later changed to a type that can actually occur. This is a nightly-only experimental API.

### Method
`into_err()`

### Request Example
```rust
fn only_bad_news() -> Result<!, String> {
    Err("Oops, it failed".into())
}

let error: String = only_bad_news().into_err();
println!("{error}");
```
```

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

### map_or_default()

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Maps a Result<T, E> to U using a function for Ok, or the default value of U for Err.

```APIDOC
## pub const fn map_or_default<U, F>(self, f: F) -> U
where F: FnOnce(T) -> U, U: Default,

🔬This is a nightly-only experimental API. (`result_option_map_or_default`)
Maps a `Result<T, E>` to a `U` by applying function `f` to the contained value if the result is `Ok`, otherwise if `Err`, returns the default value for the type `U`.

### Description
Applies function `f` to the `Ok` value, or returns the default value of type `U` if the `Result` is `Err`.

### Method
`map_or_default(f)`

### Parameters
- `f` (FnOnce(T) -> U): The function to apply to the `Ok` value.

### Response
- `U`: The result of applying `f` or the default value of `U`.

### Request Example
```rust
#![feature(result_option_map_or_default)]

let x: Result<_, &str> = Ok("foo");
let y: Result<&str, _> = Err("bar");

assert_eq!(x.map_or_default(|x| x.len()), 3);
assert_eq!(y.map_or_default(|y| y.len()), 0);
```
```

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

### Into Ok Value (Never Panics)

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/type.Result.html

Safely extracts the Ok value, guaranteed not to panic. This is useful when the error type is uninhabitable (!).

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

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

### Set Proxy Bypass List

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the bypass list for the system proxy based on the current Sysproxy instance. Returns a Result indicating success or failure.

```rust
pub fn set_bypass(&self) -> Result<()>
```

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

### Set Proxy Bypass List

Source: https://docs.rs/sysproxy/0.3.0/src/sysproxy/linux.rs.html

Configures the list of hosts or domains that should be bypassed by the proxy settings.

```APIDOC
## set_bypass(&self)

### Description
Sets the list of hosts to be ignored by the system proxy.

### Returns
- `Result<()>`: Ok if the bypass list was updated successfully, or an error.

### Example
```rust
let mut proxy = Sysproxy::get_system_proxy()?;
proxy.bypass = "localhost,127.0.0.1".to_string();
proxy.set_bypass()?;
```
```

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

### Set Proxy Enable Status

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/struct.Sysproxy.html

Sets the enable status for the system proxy based on the current Sysproxy instance. Returns a Result indicating success or failure.

```rust
pub fn set_enable(&self) -> Result<()>
```

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

### Implement TryFrom<U> for T

Source: https://docs.rs/sysproxy/0.3.0/sysproxy/enum.Error.html

Provides a fallible conversion from type U to type T. Returns a Result, allowing for error handling during conversion.

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
{
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
}
```
Tokens:
Raw