Warp10

https://docs.rs/warp10/2.0.0/warp10/
Admin
Documentation for a Warp10 client library, detailing its structures, enums, and traits for...
Tokens:25,776
Snippets:244
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Get Host and Port

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Client.html

Retrieves the host and an optional port string from the client's configuration.

```rust
pub fn host_and_maybe_port(&self) -> String
```

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

### Getting a Reference to the Ok Value

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

The `as_ref()` method converts a `&Result<T, E>` to `Result<&T, &E>`, providing immutable references to the contained values without consuming the original Result.

```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"));
```

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

### Get Writer

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Client.html

Obtains a Writer instance for sending data to Warp10, requiring an authentication token.

```rust
pub fn get_writer(&self, token: String) -> Writer<'_>
```

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

### Iterating Over Ok Value in Rust Result

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Illustrates how to get an iterator that yields the Ok value if present, using iter().

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

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

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

### Error Description Method (Deprecated)

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Error.html

Deprecated method for getting a string description of the error. It is recommended to use the Display implementation or `to_string()` instead.

```rust
fn description(&self) -> &str
```

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

### New Client Instance

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Client.html

Creates a new Client instance with the specified URI. Returns a Result containing the Client or an error.

```rust
pub fn new(uri: &str) -> Result<Client>
```

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

### Basic Result Usage

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Demonstrates the basic usage of Result with Ok and assert_eq.

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

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

### Client::new

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Client.html

Creates a new Client instance with the specified URI. Returns a Result containing the Client or an error.

```APIDOC
## Client::new

### Description
Creates a new Client instance with the specified URI.

### Method
`new`

### Parameters
#### Path Parameters
- **uri** (string) - Required - The URI for the client connection.

### Returns
- Result<Client> - A Result containing the new Client or an error.
```

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

### Handling File Metadata with `Result`

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Shows how to use `Result` and its methods like `and_then` to safely access file metadata, handling potential errors like 'NotFound'.

```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);
```

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

### Getting a Mutable Reference to the Value

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

The `as_mut()` method converts a `&mut Result<T, E>` to `Result<&mut T, &mut E>`, allowing mutable access to the contained values.

```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);
```

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

### Generic CloneToUninit Implementation (Nightly)

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Label.html

An experimental nightly-only API for performing copy-assignment from self to uninitialized memory.

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

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

### Writer::new

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Writer.html

Creates a new Writer instance. This is the entry point for interacting with the Writer functionality.

```APIDOC
## Writer::new

### Description
Creates a new Writer instance, used for posting data.

### Signature
`pub fn new(client: &'a Client, token: Token<'a>) -> Self`

### Parameters
* **client** (`&'a Client`) - A reference to the Client object.
* **token** (`Token<'a>`) - The authentication token.
```

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

### Client::host_and_maybe_port

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Client.html

Returns the host and an optional port as a String.

```APIDOC
## Client::host_and_maybe_port

### Description
Returns the host and an optional port as a String.

### Method
`host_and_maybe_port`

### Returns
- String - The host and optional port.
```

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

### Label Constructor

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Label.html

Creates a new Label with a given name and value. This is the primary way to instantiate a Label.

```rust
pub fn new(name: &str, value: &str) -> Label
```

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

### Recommended expect() Message Style

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Provides guidance on crafting effective error messages for the expect() method, focusing on the expected condition.

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

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

### Writer Constructor

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Writer.html

Creates a new instance of the Writer. Requires a reference to a Client and a Token.

```rust
pub fn new(client: &'a Client, token: Token<'a>) -> Self
```

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

### Error Provide Method (Nightly)

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Error.html

A nightly-only experimental API for providing type-based access to context intended for error reports.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

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

### Sync Post Method

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Writer.html

Synchronously sends a vector of Data using the Writer. Returns a Result containing a Warp10Response.

```rust
pub fn post_sync(&self, data: Vec<Data>) -> Result<Warp10Response>
```

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

### Using expect() to Unwrap Result with Panic

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Shows how to retrieve the Ok value from a Result, panicking with a custom message if it's an Err. Use with caution.

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

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

### Async Post Method

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Writer.html

Asynchronously sends a vector of Data using the Writer. Returns a Result containing a Warp10Response.

```rust
pub async fn post(&self, data: Vec<Data>) -> Result<Warp10Response>
```

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

### Data::new

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Data.html

Constructs a new Data instance with all fields, including a specific date.

```APIDOC
## pub fn new

### Description

Creates a new `Data` instance, requiring a date, an optional geo value, a name, a vector of labels, and a value.

### Signature

```rust
pub fn new(date: OffsetDateTime, geo: Option<GeoValue>, name: String, labels: Vec<Label>, value: Value) -> Data
```
```

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

### Token New Function

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Token.html

Constructs a new Token instance. It requires a reference to a Client and a String token.

```rust
pub fn new(client: &'a Client, token: String) -> Self
```

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

### PartialEq Implementation for Label

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Label.html

Enables comparison of two Label instances for equality or inequality.

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

```rust
fn ne(&self, other: &Rhs) -> bool
```

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

### Clone Implementation for Data

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Data.html

Provides methods to duplicate Data instances. `clone` returns a new duplicate, while `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> Data
```

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

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

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

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Implementation for Result<Option<T>, E> with the transpose method.

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

#### pub const fn transpose(self) -> Option<Result<T, E>>

Transposes a `Result` of an `Option` into an `Option` of a `Result`.
`Ok(None)` will be mapped to `None`. `Ok(Some(_))` and `Err(_)` will be mapped to `Some(Ok(_))` and `Some(Err(_))`.

##### Examples

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```
```

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

### Product of Parsed Numbers

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Demonstrates multiplying numbers parsed from strings. Returns Ok with the product if all parse successfully, otherwise returns the first Err encountered.

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

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

### Constructor for Data with Timestamp

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Data.html

Creates a new Data instance with a specific timestamp, optional geo-location, name, labels, and value. Use when the exact time is important.

```rust
pub fn new( date: OffsetDateTime, geo: Option<GeoValue>, name: String, labels: Vec<Label>, value: Value, ) -> Data
```

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

### PartialEq Implementation for Data

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Data.html

Enables equality comparison between Data instances. `eq` tests for equality, and `ne` tests for inequality.

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

```rust
fn ne(&self, other: &Rhs) -> bool
```

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

### Warp10Response::new Constructor

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Warp10Response.html

Creates a new Warp10Response instance with a given status code and payload string.

```rust
pub fn new(status: StatusCode, payload: String) -> Self
```

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

### From<Error> for Error Implementation

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Error.html

Demonstrates the conversion from an existing Error type into itself, likely for internal error management or consistency.

```rust
fn from(err: Error) -> Error
```

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

### impl PartialEq for Data

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Data.html

Enables equality comparison between Data instances.

```APIDOC
## impl PartialEq for Data

### Description

This implementation provides methods for comparing two `Data` instances for equality.

### Methods

- `eq(&self, other: &Data) -> bool`: Tests for `self` and `other` values to be equal.
- `ne(&self, other: &Rhs) -> bool`: Tests for inequality (`!=`).
```

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

### impl From<i64> for Value

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Enables conversion from i64 to Value enum.

```APIDOC
## impl From<i64> for Value

### fn from(l: Long) -> Self

Converts to this type from the input type.
```

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

### StructuralPartialEq Implementation for Label

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Label.html

Indicates that Label implements structural partial equality.

```rust
impl StructuralPartialEq for Label
```

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

### Using `or` to Provide a Default Result

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Illustrates how `or` returns the `Ok` value of the first `Result` if it's `Ok`, otherwise it returns the second `Result`.

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

let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));

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

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

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

### impl From<f64> for Value

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Enables conversion from f64 to Value enum.

```APIDOC
## impl From<f64> for Value

### fn from(d: Double) -> Self

Converts to this type from the input type.
```

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

### into_ok

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

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.

```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.

### Method
`into_ok()`

### Parameters
None

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

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

### Response
#### Success Response
The contained `Ok` value.

#### Response Example
```rust
"this is fine"
```
```

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

### impl Clone for Data

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Data.html

Provides functionality to create a duplicate of a Data instance.

```APIDOC
## impl Clone for Data

### Description

This implementation allows for creating copies of `Data` instances. It includes methods for basic cloning and clone-from assignment.

### Methods

- `clone(&self) -> Data`: Returns a duplicate of the value.
- `clone_from(&mut self, source: &Self)`: Performs copy-assignment from `source`.
```

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

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

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Implementations for Result<&mut T, E> including methods to copy or clone the contained mutable reference.

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

#### pub const fn copied(self) -> Result<T, E>

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

##### Examples

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

#### pub fn cloned(self) -> Result<T, E>

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

##### Examples

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

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

### Mapping to a Default Value (Nightly)

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

The `map_or_default()` method (experimental, nightly-only) maps the `Ok` value using a function or returns the default value of the target type if the Result is `Err`.

```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);
```

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

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

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Core implementations for the Result<T, E> type, including checking if the result is Ok or Err.

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

#### 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);
```

#### 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);
```

#### 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);
```

#### 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.
```

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

### Token Set Headers Function

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Token.html

Sets the headers for the Token. This method modifies a mutable HeaderMap.

```rust
pub fn set_headers(&self, headers: &mut HeaderMap)
```

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

### impl From<i32> for Value

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Enables conversion from i32 to Value enum.

```APIDOC
## impl From<i32> for Value

### fn from(i: Int) -> Self

Converts to this type from the input type.
```

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

### unwrap

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`.

```APIDOC
## pub fn unwrap(self) -> T
where E: Debug,
Returns the contained `Ok` value, consuming the `self` value.
Because this function may panic, its use is generally discouraged. Panics are meant for unrecoverable errors, and may abort the entire program.
Instead, prefer to use the `?` (try) operator, or pattern matching to handle the `Err` case explicitly, or call `unwrap_or`, `unwrap_or_else`, or `unwrap_or_default`.

### Response
#### Success Response (T)
- **T** - The contained success value.

### Panics
Panics if the value is an `Err`.

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

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

### unwrap

Source: https://docs.rs/warp10/2.0.0/warp10/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()`

### Parameters
None

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

### Response
#### Success Response
The contained `Ok` value.

#### Response Example
```rust
2
```

### Error Handling
Panics if the `Result` is an `Err`.
```

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

### Update Client URI

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Client.html

Returns a reference to the client's URI. This method allows inspecting the current URI configuration.

```rust
pub fn update_uri(&self) -> &Uri
```

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

### ok

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Converts `Result<T, E>` into `Option<T>`, consuming the result. If the result is `Ok(v)`, it returns `Some(v)`. If the result is `Err(_)`, it returns `None`.

```APIDOC
## ok

### Description
Converts from `Result<T, E>` to `Option<T>`. This method consumes the `Result`.

### Method
`ok`

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

### 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);
```
```

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

### And: Combine Results (Eager Evaluation)

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

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

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

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

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"));

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"));
```

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

### Providing a Default Value with `unwrap_or`

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Shows how `unwrap_or` returns the `Ok` value or a pre-computed default value if the `Result` is `Err`.

```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);
```

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

### Copying Result<&mut T, E> to Result<T, E>

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

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

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

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

### ToString Method

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Error.html

Converts a value implementing the Display trait into a String representation.

```rust
fn to_string(&self) -> String
```

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

### expect

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`.

```APIDOC
## pub fn expect(self, msg: &str) -> T
where E: Debug,
Returns the contained `Ok` value, consuming the `self` value.
Because this function may panic, its use is generally discouraged. Instead, prefer to use pattern matching and handle the `Err` case explicitly, or call `unwrap_or`, `unwrap_or_else`, or `unwrap_or_default`.

### Parameters
#### Path Parameters
- **msg** (&str) - Required - The panic message to display if the `Result` is an `Err`.

### Response
#### Success Response (T)
- **T** - The contained success value.

### Panics
Panics if the value is an `Err`, with a panic message including the passed message, and the content of the `Err`.

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

### Recommended Message Style
We recommend that `expect` messages are used to describe the reason you _expect_ the `Result` should be `Ok`.
```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

**Hint** : If you’re having trouble remembering how to phrase expect error messages remember to focus on the word “should” as in “env variable should be set by blah” or “the given binary should be available and executable by the current user”.
For more detail on expect message styles and the reasoning behind our recommendation please refer to the section on “Common Message Styles” in the `std::error` module docs.
```

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

### impl StructuralPartialEq for Data

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Data.html

Enables structural partial equality comparison for Data instances.

```APIDOC
## impl StructuralPartialEq for Data

### Description

This trait implementation allows for structural partial equality comparisons on `Data` instances, which may differ from standard equality in certain scenarios.
```

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

### as_ref

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Converts `&Result<T, E>` into `Result<&T, &E>`, producing a new `Result` containing references into the original, leaving the original unchanged.

```APIDOC
## as_ref

### Description
Converts from `&Result<T, E>` to `Result<&T, &E>`. Produces a new `Result`, containing a reference into the original, leaving the original in place.

### Method
`as_ref`

### Response
- `Result<&T, &E>`: A `Result` containing references to the contained value or error.

### Example
```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"));
```
```

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

### Converting Result<T, E> to Result<&T, &E> with as_deref

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Demonstrates converting a Result containing a type that implements Deref into a Result of references to the dereferenced type.

```rust
let x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&str, &u32> = Ok("hello");
assert_eq!(x.as_deref(), y);

let x: Result<String, u32> = Err(42);
let y: Result<&str, &u32> = Err(&42);
assert_eq!(x.as_deref(), y);
```

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

### Cloning Result<&mut T, E> to Result<T, E>

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

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

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

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

### Chaining Fallible Operations with `and_then`

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Demonstrates chaining operations that can return a Result, using `and_then` to process `Ok` values or propagate `Err`.

```rust
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {
    x.checked_mul(x).map(|sq| sq.to_string()).ok_or("overflowed")
}

assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```

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

### Converting Result to Option with Ok Value

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

The `ok()` method converts a `Result<T, E>` into an `Option<T>`. If the Result is `Ok(v)`, it returns `Some(v)`. If it's `Err(_)`, it returns `None`.

```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);
```

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

### try_into

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Performs the conversion of an enum value.

```APIDOC
## try_into

### Description
Performs the conversion.

### Method
N/A (This appears to be a trait method, not an HTTP endpoint)

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Into Ok for Infallible Results

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Safely extracts the Ok value from a Result that is guaranteed not to be an Err. This API is nightly-only.

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

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

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

### Clone Implementation for Label

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Label.html

Provides methods to duplicate a Label value or copy from another Label.

```rust
fn clone(&self) -> Label
```

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

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

### map_or_default

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Maps a `Result<T, E>` to a `U` by applying a function `f` if `Ok`, otherwise returns the default value for `U`. This is an experimental nightly-only API.

```APIDOC
## map_or_default

### Description
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`. This is a nightly-only experimental API.

### Method
`map_or_default<U, F>`

### Parameters
- `f`: A closure that takes the `Ok` value of type `T` and returns a value of type `U`.

### Response
- `U`: The result of the closure if `Ok`, or the default value of `U` if `Err`.

### 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);
```
```

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

### Unwrap or Default for Parsing

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Converts a string to an integer, returning 0 if parsing fails. Useful for handling potentially invalid input.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

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

### Cloning Result<&T, E> to Result<T, E>

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

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

```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));
```

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

### PartialEq

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Provides equality comparison for the Result type. Two Results are equal if they are both Ok and contain equal values, or if they are both Err and contain equal errors.

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

### Description
Tests for `self` and `other` values to be equal, and is used by `==`. Two `Result`s are equal if they are both `Ok` and contain equal values, or if they are both `Err` and contain equal errors.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let ok1: Result<i32, &str> = Ok(1);
let ok2: Result<i32, &str> = Ok(1);
let err1: Result<i32, &str> = Err("error");
let err2: Result<i32, &str> = Err("error");

assert!(ok1 == ok2);
assert!(err1 == err2);
assert!(ok1 != err1);
```

### Response
#### Success Response (200)
- **bool** - `true` if the `Result` values are equal, `false` otherwise.

#### Response Example
```rust
true
```
```

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

### Description
Tests for `!=`. This is the negation of the `eq` method.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let ok1: Result<i32, &str> = Ok(1);
let ok2: Result<i32, &str> = Ok(2);

assert!(ok1 != ok2);
```

### Response
#### Success Response (200)
- **bool** - `true` if the `Result` values are not equal, `false` otherwise.

#### Response Example
```rust
true
```
```

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

### Client Struct Definition

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Client.html

Defines the Client struct for interacting with Warp10. It contains private fields.

```rust
pub struct Client { /* private fields */ }
```

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

### Converting Result<T, E> to Result<&mut T, &mut E> with as_deref_mut

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Shows how to convert a mutable Result containing a type that implements DerefMut into a mutable Result of mutable references to the dereferenced type.

```rust
let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
```

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

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

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Implementations for Result<&T, E> including methods to copy or clone the contained value.

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

#### pub const fn copied(self) -> Result<T, E>

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));
```

#### pub fn cloned(self) -> Result<T, E>

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));
```
```

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

### Create a New GeoValue

Source: https://docs.rs/warp10/2.0.0/warp10/struct.GeoValue.html

Constructs a new GeoValue instance with latitude, longitude, and an optional elevation. Use this to initialize GeoValue objects.

```rust
pub fn new(lat: Double, lon: Double, elev: Option<Long>) -> GeoValue
```

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

### impl PartialEq for Value

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Allows for equality comparison between Value enum instances.

```APIDOC
## impl PartialEq for Value

### fn eq(&self, other: &Value) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.

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

Tests for `!=`.
```

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

### impl Warp10Serializable for Data

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Data.html

Provides a method to serialize Data instances into a string format compatible with Warp10.

```APIDOC
## impl Warp10Serializable for Data

### Description

Enables the serialization of `Data` instances into a string format that can be used with the Warp10 platform.

### Methods

- `warp10_serialize(&self) -> String`: Serializes the `Data` instance into a string.
```

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

### inspect

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Calls a function with a reference to the contained value if `Ok`. Returns the original result.

```APIDOC
## pub fn inspect<F>(self, f: F) -> Result<T, E>
where F: FnOnce(&T),
Calls a function with a reference to the contained value if `Ok`. Returns the original result.
This method is useful for performing side effects, like logging, when a `Result` is `Ok`.

### Parameters
#### Path Parameters
- **f** (FnOnce(&T)) - Required - A closure that takes a reference to the success value.

### Response
#### Success Response (Ok(T))
- **T** - The original success value.

#### Error Response (Err(E))
- **E** - The original error value.

### Example
```rust
let x: u8 = "4"
    .parse::<u8>()
    .inspect(|x| println!("original: {x}"))
    .map(|x| x.pow(3))
    .expect("failed to parse number");
```
```

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

### Client::update_uri

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Client.html

Returns a reference to the Uri associated with the client.

```APIDOC
## Client::update_uri

### Description
Returns a reference to the Uri associated with the client.

### Method
`update_uri`

### Returns
- &Uri - A reference to the client's Uri.
```

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

### and

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Returns res if the result is Ok, otherwise returns the Err value of self. Arguments passed to and are eagerly evaluated.

```APIDOC
## and

### Description
Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`. Arguments passed to `and` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `and_then`, which is lazily evaluated.

### Method
`and<U>(self, res: Result<U, E>) -> Result<U, E>`

### Parameters
* **res** (Result<U, E>) - The result to return if `self` is `Ok`.

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

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"));
```

### Response
#### Success Response
Returns `res` if `self` is `Ok`, otherwise returns the `Err` value of `self`.

#### Response Example
```rust
Err("late error") // or Ok("different result type") depending on input
```
```

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

### Warp10Serializable Implementation for Label

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Label.html

Provides a method to serialize a Label into a String format compatible with Warp10.

```rust
fn warp10_serialize(&self) -> String
```

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

### with_subscriber

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Error.html

Attaches a provided Subscriber to the type, returning a WithDispatch wrapper. The subscriber must be convertible into a Dispatch.

```APIDOC
## fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>

### Description
Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper.

### Method Signature
`fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>`

### Type Parameters
- `S`: A type that can be converted into a `Dispatch`.
```

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

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

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Implementation for Result<Result<T, E>, E> with the flatten method to remove one level of nesting.

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

#### pub const fn flatten(self) -> Result<T, E>

Converts from `Result<Result<T, E>, E>` to `Result<T, E>`

##### Examples

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

Flattening only removes one level of nesting at a time:

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```
```

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

### Try Into Conversion

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Performs a fallible conversion into another type using the TryFrom trait. Returns a Result indicating success or failure.

```rust
type Error = <U as TryFrom<T>>::Error
```

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

### impl From<String> for Value

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Enables conversion from String to Value enum.

```APIDOC
## impl From<String> for Value

### fn from(s: String) -> Self

Converts to this type from the input type.
```

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

### impl Clone for Value

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Allows cloning Value enum instances.

```APIDOC
## impl Clone for Value

### fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from `source`.
```

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

### To Owned

Source: https://docs.rs/warp10/2.0.0/warp10/enum.Value.html

Creates owned data from borrowed data, usually by cloning. This is useful for obtaining ownership of data.

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

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

### Inspecting Ok Values in Rust Result

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Shows how to perform a side effect (like printing) on the Ok value of a Result without altering it, using the inspect method.

```rust
let x: u8 = "4"
    .parse::<u8>()
    .inspect(|x| println!("original: {x}"))
    .map(|x| x.pow(3))
    .expect("failed to parse number");
```

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

### Mapping an Ok Value with a Function

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

The `map()` method applies a function to the contained `Ok` value, transforming it into a new `Result`. `Err` values are passed through unchanged.

```rust
let line = "1\n2\n3\n4\n";

for num in line.lines() {
    match num.parse::<i32>().map(|i| i * 2) {
        Ok(n) => println!(/*{n}*/), // Placeholder for actual print
        Err(..) => {} // Ignore parsing errors
    }
}
```

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

### Expect Err Panic on Ok

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Demonstrates expect_err panicking when the Result is Ok, including the provided message and the Ok value.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

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

### Copying Result<&T, E> to Result<T, E>

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

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

```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));
```

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

### And Then: Chain Operations on Ok Results

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Calls a closure with the Ok value if the Result is Ok, allowing for chained operations. Otherwise, returns the Err value.

```rust
let x: Result<u32, &str> = Ok(2);
let y = x.and_then(|v| Ok(v + 1));
assert_eq!(y, Ok(3));
```

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

### Result Panic on Err

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Shows how unwrap() panics when the Result is an Err, displaying the error message.

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

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

### WithSubscriber Trait Implementation (1)

Source: https://docs.rs/warp10/2.0.0/warp10/struct.Writer.html

Implements the WithSubscriber trait for attaching subscribers for telemetry.

```rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
```

```rust
fn with_current_subscriber(self) -> WithDispatch<Self>
```

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

### as_deref_mut

Source: https://docs.rs/warp10/2.0.0/warp10/type.Result.html

Converts from `Result<T, E>` to `Result<&mut <T as DerefMut>::Target, &mut E>`. Coerces the `Ok` variant via `DerefMut`.

```APIDOC
## pub fn as_deref_mut(&mut self) -> Result<&mut <T as DerefMut>::Target, &mut E>
where T: DerefMut,
Converts from `Result<T, E>` (or `&mut Result<T, E>`) to `Result<&mut <T as DerefMut>::Target, &mut E>`.
Coerces the `Ok` variant of the original `Result` via `DerefMut` and returns the new `Result`.
This method allows mutable access to the dereferenced value within an `Ok` Result.

### Response
#### Success Response (Ok(&mut <T as DerefMut>::Target))
- **&mut <T as DerefMut>::Target** - A mutable reference to the dereferenced success value.

#### Error Response (&mut E)
- **&mut E** - A mutable reference to the original error value.

### Example
```rust
let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
```
```
Tokens:
Raw