OpenTelemetry HTTP

https://docs.rs/opentelemetry-http/latest/opentelemetry_http/
Admin
OpenTelemetry HTTP is a Rust crate that provides HTTP client abstractions and header propagation...
Tokens:111,400
Snippets:931
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Manually Create Box from Global Allocator

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html

This example shows how to manually create a Box from scratch using the global allocator. This is an advanced use case that requires careful memory management.

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}
```

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

### Get NonNull Pointer to Box Contents (Nightly)

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Retrieve a NonNull pointer to the Box's contents. This experimental API allows for safe mutation through the pointer, as demonstrated by the example where writes do not invalidate other NonNull pointers derived from the same Box.

```rust
#![feature(box_as_non_null)]

unsafe {
    let mut b = Box::new(0);
    let ptr1 = Box::as_non_null(&mut b);
    ptr1.write(1);
    let ptr2 = Box::as_non_null(&mut b);
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`:
    ptr1.write(3);
}
```

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

### try_get_i8

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html

Safely gets a signed 8-bit integer from `self`.

```APIDOC
## fn try_get_i8(&mut self) -> Result<i8, TryGetError>

### Description
Safely gets a signed 8-bit integer from `self`.

### Method
(Implicitly a method call on a mutable reference)

### Parameters
- `self`: A mutable reference to the source from which to read.

### Returns
- `Result<i8, TryGetError>`: Ok(i8) containing the signed 8-bit integer if successful, or a TryGetError if the read failed.
```

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

### Manually Create Box from Global Allocator with NonNull

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html

This example shows how to manually create a Box from scratch using the global allocator and a NonNull pointer. This is a nightly-only experimental API.

```rust
#![feature(box_vec_non_null)]

use std::alloc::{alloc, Layout};
use std::ptr::NonNull;

unsafe {
    let non_null = NonNull::new(alloc(Layout::new::<i32>()).cast::<i32>())
        .expect("allocation failed");
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null(non_null);
}
```

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

### take

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Creates an adaptor that reads at most a specified limit of bytes from the buffer.

```APIDOC
## take

### Description
Creates an adaptor which will read at most `limit` bytes from `self`.

### Method
`take(limit: usize) -> Take<Self>`

### Parameters
- **limit** (usize) - Required - The maximum number of bytes to read.

### Response
- Returns `Take<Self>`: An adaptor that limits the number of bytes read from the underlying buffer.
```

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

### try_get_u8

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html

Safely gets an unsigned 8-bit integer from `self`.

```APIDOC
## fn try_get_u8(&mut self) -> Result<u8, TryGetError>

### Description
Safely gets an unsigned 8-bit integer from `self`.

### Method
(Implicitly a method call on a mutable reference)

### Parameters
- `self`: A mutable reference to the source from which to read.

### Returns
- `Result<u8, TryGetError>`: Ok(u8) containing the unsigned 8-bit integer if successful, or a TryGetError if the read failed.
```

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

### try_get_u8

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempts to get an unsigned 8-bit integer from the source.

```APIDOC
## try_get_u8

### Description
Gets an unsigned 8-bit integer from `self`.

### Signature
`fn try_get_u8(&mut self) -> Result<u8, TryGetError>`

### Response
#### Success Response (Ok)
- Returns `Ok(u8)` containing the unsigned 8-bit integer.

#### Error Response (Err)
- Returns `Err(TryGetError)` if there are not enough bytes to read an unsigned 8-bit integer.
```

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

### Box::new

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Allocates memory on the heap and places a value into it. This is the standard way to create a Box.

```APIDOC
## Box::new

### Description
Allocates memory on the heap and then places `x` into it. This doesn’t actually allocate if `T` is zero-sized.

### Method
Associated function

### Parameters
- **x** (T) - The value to place in the Box.

### Response
- **Box<T>** - A Box containing the value `x`.

### Request Example
```rust
let five = Box::new(5);
```
```

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

### Box::new_uninit

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Constructs a new Box with uninitialized contents. Use with caution and ensure proper initialization.

```APIDOC
## Box::new_uninit

### Description
Constructs a new box with uninitialized contents. This method is useful when you want to defer initialization of the boxed value.

### Method
Associated function

### Response
- **Box<MaybeUninit<T>>** - A Box containing uninitialized memory.

### Request Example
```rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```
```

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

### try_get_i8

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Gets a signed 8 bit integer from `self`.

```APIDOC
## fn try_get_i8(&mut self) -> Result<i8, TryGetError>

### Description
Gets a signed 8 bit integer from `self`.

### Method
Implicit (method call on `self`)

### Parameters
None

### Return Value
Result<i8, TryGetError>: Ok(i8) if successful, or an error.

### Source
[Link to source code]
```

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

### try_get_u8

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Gets an unsigned 8 bit integer from `self`.

```APIDOC
## fn try_get_u8(&mut self) -> Result<u8, TryGetError>

### Description
Gets an unsigned 8 bit integer from `self`.

### Method
Implicit (method call on `self`)

### Parameters
None

### Return Value
Result<u8, TryGetError>: Ok(u8) if successful, or an error.

### Source
[Link to source code]
```

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

### Box::new_uninit_in

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Constructs a new Box with uninitialized contents using a specified allocator. This API is experimental and requires the `allocator_api` feature.

```APIDOC
## Box::new_uninit_in

### Description
Constructs a new box with uninitialized contents in the provided allocator.

### Method
`new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>`

### Parameters
- `alloc` (A): The allocator to use.

### Constraints
- `A: Allocator`

### Notes
- This is a nightly-only experimental API (`allocator_api`).

### Examples
```rust
#![feature(allocator_api)]

use std::alloc.System;

let mut five = Box::<u32, _>::new_uninit_in(System);
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```
```

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

### Box::try_new_uninit

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Attempts to construct a Box with uninitialized contents, returning an error if allocation fails.

```APIDOC
## Box::try_new_uninit

### Description
Constructs a new box with uninitialized contents on the heap, returning an error if the allocation fails. This is a fallible version of `Box::new_uninit`.

### Method
Associated function

### Response
- **Result<Box<MaybeUninit<T>>, AllocError>** - Ok containing the Box if successful, or an AllocError if allocation fails.

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

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```
```

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

### Buf::get_u128

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=

Gets an unsigned 128 bit integer from `self`.

```APIDOC
## fn get_u128(&mut self) -> u128

### Description
Gets an unsigned 128 bit integer from `self`.

### Method
fn get_u128

### Returns
An unsigned 128 bit integer.
```

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

### Buf::get_i8

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=

Gets a signed 8 bit integer from `self`.

```APIDOC
## fn get_i8(&mut self) -> i8

### Description
Gets a signed 8 bit integer from `self`.

### Method
fn get_i8

### Returns
A signed 8 bit integer.
```

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

### Recreate Box from Raw Pointer

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html

This example demonstrates how to recreate a Box from a raw pointer obtained using Box::into_raw. This is useful for managing memory and ensuring proper cleanup.

```rust
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
```

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

### Buf::get_u8

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=

Gets an unsigned 8 bit integer from `self`.

```APIDOC
## fn get_u8(&mut self) -> u8

### Description
Gets an unsigned 8 bit integer from `self`.

### Method
fn get_u8

### Returns
An unsigned 8 bit integer.
```

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

### Box::new

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html

Allocates memory on the heap and places a value into it. This is the standard way to create a Box. It optimizes for zero-sized types by not allocating memory.

```APIDOC
## Box::new

### Description
Allocates memory on the heap and then places `x` into it. This doesn
't actually allocate if `T` is zero-sized.

### Method
Associated function

### Parameters
- **x** (T) - The value to place in the Box.

### Response
- **Box<T>** - A Box containing the value `x`.

### Example
```rust
let five = Box::new(5);
```
```

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

### Box::try_new_uninit

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Constructs a new box with uninitialized contents on the heap, returning an error if the allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_new_uninit

### Description
Constructs a new box with uninitialized contents on the heap, returning an error if the allocation fails.

### Method
Associated function

### Response
- **Result<Box<MaybeUninit<T>>, AllocError>** - Ok containing a box with uninitialized contents on success, or an `AllocError` on failure.

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

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```
```

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

### chunk_mut

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Returns a mutable slice starting at the current BufMut position.

```APIDOC
## chunk_mut

### Description
Returns a mutable slice starting at the current `BufMut` position and of length between 0 and `BufMut::remaining_mut()`.
Note that this _can_ be shorter than the whole remainder of the buffer (this allows non-continuous implementation).

### Method
`chunk_mut(&mut self) -> &mut UninitSlice`

### Parameters
None

### Response
- Returns `&mut UninitSlice`: A mutable slice of uninitialized memory.
```

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

### Box::try_new_uninit

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs a new box with uninitialized contents on the heap, returning an error if the allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_new_uninit

### Description
Constructs a new box with uninitialized contents on the heap, returning an error if the allocation fails.

### Method
Associated function (Nightly-only experimental API: `allocator_api`)

### Response
- **Result<Box<MaybeUninit<T>>, AllocError>** - Ok containing a box with uninitialized contents on success, or an `AllocError` on failure.

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

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```
```

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

### try_get_int_ne

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed n-byte integer from the buffer in native-endian byte order.

```APIDOC
## try_get_int_ne

### Description
Gets a signed n-byte integer from `self` in native-endian byte order.

### Method
`try_get_int_ne(nbytes: usize)`

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read for the integer.

### Response
- Returns `Result<i64, TryGetError>`: The signed integer if successful, or a `TryGetError` if the operation fails.
```

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

### try_get_int_le

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed n-byte integer from the buffer in little-endian byte order.

```APIDOC
## try_get_int_le

### Description
Gets a signed n-byte integer from `self` in little-endian byte order.

### Method
`try_get_int_le(nbytes: usize)`

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read for the integer.

### Response
- Returns `Result<i64, TryGetError>`: The signed integer if successful, or a `TryGetError` if the operation fails.
```

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

### Manually Allocating and Constructing Box with NonNull

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates manual memory allocation and constructing a Box using NonNull pointers. This is an experimental API requiring careful memory management.

```rust
#![feature(box_vec_non_null)]

use std::alloc::{alloc, Layout};
use std::ptr::NonNull;

unsafe {
    let non_null = NonNull::new(alloc(Layout::new::<i32>()).cast::<i32>())
        .expect("allocation failed");
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null(non_null);
}

```

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

### try_get_int

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed n-byte integer from the buffer in big-endian byte order.

```APIDOC
## try_get_int

### Description
Gets a signed n-byte integer from `self` in big-endian byte order.

### Method
`try_get_int(nbytes: usize)`

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read for the integer.

### Response
- Returns `Result<i64, TryGetError>`: The signed integer if successful, or a `TryGetError` if the operation fails.
```

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

### Box::clone_from_ref

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Allocates memory on the heap then clones `src` into it. This is a nightly-only experimental API.

```APIDOC
## Box::clone_from_ref

### Description
Allocates memory on the heap then clones `src` into it. This doesn’t actually allocate if `src` is zero-sized.

### Method
Associated function (Nightly-only experimental API: `clone_from_ref`)

### Parameters
- **src** (&T) - The reference to the value to clone.

### Response
- **Box<T>** - A new box containing a clone of `src`.

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

let hello: Box<str> = Box::clone_from_ref("hello");
```
```

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

### try_get_uint_ne

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets an unsigned n-byte integer from the buffer in native-endian byte order.

```APIDOC
## try_get_uint_ne

### Description
Gets an unsigned n-byte integer from `self` in native-endian byte order.

### Method
`try_get_uint_ne(nbytes: usize)`

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read for the integer.

### Response
- Returns `Result<u64, TryGetError>`: The unsigned integer if successful, or a `TryGetError` if the operation fails.
```

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

### Box::try_new_uninit_in

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Attempts to construct a new Box with uninitialized contents using a specified allocator, returning an error on allocation failure. This is a nightly-only experimental API.

```APIDOC
## Box::try_new_uninit_in

### Description
Constructs a new box with uninitialized contents in the provided allocator, returning an error if the allocation fails.

### Method
`try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>`

### Parameters
- `alloc` (A): The allocator to use.

### Constraints
- `A: Allocator`

### Notes
- This is a nightly-only experimental API (`allocator_api`).

### Examples
```rust
#![feature(allocator_api)]

use std::alloc.System;

let mut five = Box::<u32, _>::try_new_uninit_in(System)?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```
```

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

### Box::clone_from_ref

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Allocates memory on the heap then clones src into it. This is a nightly-only experimental API.

```APIDOC
## Box::clone_from_ref

### Description
Allocates memory on the heap then clones `src` into it. This doesn’t actually allocate if `src` is zero-sized.

### Method
Associated function

### Parameters
- **src** (&T) - Description: The reference to clone from.

### Response
- **Box<T>** - A new box containing a clone of `src`.

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

let hello: Box<str> = Box::clone_from_ref("hello");
```
```

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

### try_get_uint_le

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets an unsigned n-byte integer from the buffer in little-endian byte order.

```APIDOC
## try_get_uint_le

### Description
Gets an unsigned n-byte integer from `self` in little-endian byte order.

### Method
`try_get_uint_le(nbytes: usize)`

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read for the integer.

### Response
- Returns `Result<u64, TryGetError>`: The unsigned integer if successful, or a `TryGetError` if the operation fails.
```

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

### try_get_uint

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets an unsigned n-byte integer from the buffer in big-endian byte order.

```APIDOC
## try_get_uint

### Description
Gets an unsigned n-byte integer from `self` in big-endian byte order.

### Method
`try_get_uint(nbytes: usize)`

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read for the integer.

### Response
- Returns `Result<u64, TryGetError>`: The unsigned integer if successful, or a `TryGetError` if the operation fails.
```

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

### HeaderInjector try_from Example

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/trait.HttpClient.html?search=u32+-%3E+bool

Demonstrates the `try_from` method for `HeaderInjector` where `u32` is used as a generic parameter `U` and `bool` as `T`.

```rust
opentelemetry_http::HeaderInjector::try_from
**U** -> Result<**T** >
where
u32 matches **U**
bool matches **T**
```

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

### try_get_i128_ne

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed 128-bit integer from the buffer in native-endian byte order.

```APIDOC
## try_get_i128_ne

### Description
Gets a signed 128-bit integer from `self` in native-endian byte order.

### Method
`try_get_i128_ne()`

### Parameters
None

### Response
- Returns `Result<i128, TryGetError>`: The signed 128-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### Manually create Box from raw pointer

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Manually creates a `Box` from scratch using the system allocator by allocating memory, writing a value, and then constructing the `Box`.

```rust
#![feature(allocator_api, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw_in(ptr, System);
}
```

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

### try_get_i128_le

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed 128-bit integer from the buffer in little-endian byte order.

```APIDOC
## try_get_i128_le

### Description
Gets a signed 128-bit integer from `self` in little-endian byte order.

### Method
`try_get_i128_le()`

### Parameters
None

### Response
- Returns `Result<i128, TryGetError>`: The signed 128-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### Box::try_clone_from_ref

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Allocates memory on the heap then clones src into it, returning an error if allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_clone_from_ref

### Description
Allocates memory on the heap then clones `src` into it, returning an error if allocation fails. This doesn’t actually allocate if `src` is zero-sized.

### Method
Associated function

### Parameters
- **src** (&T) - Description: The reference to clone from.

### Response
- **Result<Box<T>, AllocError>** - Ok containing a new box with a clone of `src` on success, or an `AllocError` on failure.

### Request Example
```rust
#![feature(clone_from_ref)]
#![feature(allocator_api)]

let hello: Box<str> = Box::try_clone_from_ref("hello")?;
```
```

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

### Box::try_new

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Allocates memory on the heap then places `x` into it, returning an error if the allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_new

### Description
Allocates memory on the heap then places `x` into it, returning an error if the allocation fails. This doesn’t actually allocate if `T` is zero-sized.

### Method
Associated function (Nightly-only experimental API: `allocator_api`)

### Parameters
- **x** (T) - The value to place in the box.

### Response
- **Result<Box<T>, AllocError>** - Ok containing a box with the value `x` on success, or an `AllocError` on failure.

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

let five = Box::try_new(5)?;
```
```

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

### try_get_i128

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed 128-bit integer from the buffer in big-endian byte order.

```APIDOC
## try_get_i128

### Description
Gets a signed 128-bit integer from `self` in big-endian byte order.

### Method
`try_get_i128()`

### Parameters
None

### Response
- Returns `Result<i128, TryGetError>`: The signed 128-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### try_get_u128_ne

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets an unsigned 128-bit integer from the buffer in native-endian byte order.

```APIDOC
## try_get_u128_ne

### Description
Gets an unsigned 128-bit integer from `self` in native-endian byte order.

### Method
`try_get_u128_ne()`

### Parameters
None

### Response
- Returns `Result<u128, TryGetError>`: The unsigned 128-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### Box::try_clone_from_ref

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Allocates memory on the heap then clones `src` into it, returning an error if allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_clone_from_ref

### Description
Allocates memory on the heap then clones `src` into it, returning an error if allocation fails. This doesn’t actually allocate if `src` is zero-sized.

### Method
Associated function (Nightly-only experimental API: `clone_from_ref`)

### Parameters
- **src** (&T) - The reference to the value to clone.

### Response
- **Result<Box<T>, AllocError>** - Ok containing a new box with a clone of `src` on success, or an `AllocError` on failure.

### Request Example
```rust
#![feature(clone_from_ref)]
#![feature(allocator_api)]

let hello: Box<str> = Box::try_clone_from_ref("hello")?;
```
```

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

### HeaderExtractor try_from Example

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/trait.HttpClient.html?search=u32+-%3E+bool

Demonstrates the `try_from` method for `HeaderExtractor` where `u32` is used as a generic parameter `U` and `bool` as `T`.

```rust
opentelemetry_http::HeaderExtractor::try_from
**U** -> Result<**T** >
where
u32 matches **U**
bool matches **T**
```

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

### try_get_u128_le

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets an unsigned 128-bit integer from the buffer in little-endian byte order.

```APIDOC
## try_get_u128_le

### Description
Gets an unsigned 128-bit integer from `self` in little-endian byte order.

### Method
`try_get_u128_le()`

### Parameters
None

### Response
- Returns `Result<u128, TryGetError>`: The unsigned 128-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### From<Cow<'b, str>> for Box<dyn Error + Sync + Send + 'a>

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Converts a Cow<'b, str> into a Box<dyn Error + Sync + Send + 'a>. This is available on non-`no_global_oom_handling` configurations.

```APIDOC
## fn from(err: Cow<'b, str>) -> Box<dyn Error + Sync + Send + 'a>

### Description
Converts a `Cow` into a box of dyn `Error` + `Send` + `Sync`.

### Examples
```rust
use std::error::Error;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    size_of::<Box<dyn Error + Send + Sync>>() == size_of_val(&a_boxed_error))
```
```

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

### try_get_u128

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets an unsigned 128-bit integer from the buffer in big-endian byte order.

```APIDOC
## try_get_u128

### Description
Gets an unsigned 128-bit integer from `self` in big-endian byte order.

### Method
`try_get_u128()`

### Parameters
None

### Response
- Returns `Result<u128, TryGetError>`: The unsigned 128-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### Box::try_new

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Allocates memory on the heap then places x into it, returning an error if the allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_new

### Description
Allocates memory on the heap then places `x` into it, returning an error if the allocation fails. This doesn’t actually allocate if `T` is zero-sized.

### Method
Associated function

### Parameters
- **x** (T) - Description: The value to place in the box.

### Response
- **Result<Box<T>, AllocError>** - Ok containing a box with the value `x` on success, or an `AllocError` on failure.

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

let five = Box::try_new(5)?;
```
```

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

### try_get_i64_ne

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed 64-bit integer from the buffer in native-endian byte order.

```APIDOC
## try_get_i64_ne

### Description
Gets a signed 64-bit integer from `self` in native-endian byte order.

### Method
`try_get_i64_ne()`

### Parameters
None

### Response
- Returns `Result<i64, TryGetError>`: The signed 64-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### Box::try_new_zeroed

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Constructs a new Box with uninitialized contents, with the memory being filled with 0 bytes on the heap. This is a nightly-only experimental API.

```APIDOC
## Box::try_new_zeroed

### Description
Constructs a new `Box` with uninitialized contents, with the memory being filled with `0` bytes on the heap.

### Method
Associated function

### Response
- **Result<Box<MaybeUninit<T>>, AllocError>** - Ok containing a box with zeroed uninitialized contents on success, or an `AllocError` on failure.

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

let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
```
```

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

### try_get_i64_le

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed 64-bit integer from the buffer in little-endian byte order.

```APIDOC
## try_get_i64_le

### Description
Gets a signed 64-bit integer from `self` in little-endian byte order.

### Method
`try_get_i64_le()`

### Parameters
None

### Response
- Returns `Result<i64, TryGetError>`: The signed 64-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### Allocator::by_ref

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html

Creates a "by reference" adapter for this instance of `Allocator`. This is an experimental API.

```APIDOC
## by_ref

### Description
Creates a “by reference” adapter for this instance of `Allocator`.

### Method
`fn by_ref(&self) -> &Self where Self: Sized`

### Returns
A reference to the `Allocator` instance.

### Notes
This is a nightly-only experimental API. Requires the `allocator_api` feature.

```

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

### try_get_i64

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets a signed 64-bit integer from the buffer in big-endian byte order.

```APIDOC
## try_get_i64

### Description
Gets a signed 64-bit integer from `self` in big-endian byte order.

### Method
`try_get_i64()`

### Parameters
None

### Response
- Returns `Result<i64, TryGetError>`: The signed 64-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### into_raw_with_allocator

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Consumes the Box, returning a raw pointer and the allocator. The caller is responsible for memory management after this call. This is a nightly-only experimental API.

```APIDOC
## Box::into_raw_with_allocator<T, A>(b: Box<T, A>) -> (*mut T, A)

### Description
Consumes the `Box`, returning a wrapped raw pointer and the allocator. The pointer will be properly aligned and non-null. After calling this function, the caller is responsible for the memory previously managed by the `Box`. The easiest way to do this is to convert the raw pointer back into a `Box` with the `Box::from_raw_in` function.

### Method
Associated function (call as `Box::into_raw_with_allocator(b)`)

### Parameters
- **b**: `Box<T, A>` - The Box to consume.

### Return Value
- `(*mut T, A)` - A tuple containing a raw pointer to the data and the allocator.

### Notes
- This is a nightly-only experimental API (`allocator_api`).

### Examples
Converting the raw pointer back into a `Box` with `Box::from_raw_in` for automatic cleanup:
```rust
#![feature(allocator_api)]

use std::alloc::System;

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
```

Manual cleanup by explicitly running the destructor and deallocating the memory:
```rust
#![feature(allocator_api)]

use std::alloc::{Allocator, Layout, System};
use std::ptr::{self, NonNull};

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
unsafe {
    ptr::drop_in_place(ptr);
    let non_null = NonNull::new_unchecked(ptr);
    alloc.deallocate(non_null.cast(), Layout::new::<String>());
}
```
```

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

### try_get_u64_ne

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Gets an unsigned 64-bit integer from the buffer in native-endian byte order.

```APIDOC
## try_get_u64_ne

### Description
Gets an unsigned 64-bit integer from `self` in native-endian byte order.

### Method
`try_get_u64_ne()`

### Parameters
None

### Response
- Returns `Result<u64, TryGetError>`: The unsigned 64-bit integer if successful, or a `TryGetError` if the operation fails.
```

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

### Manually Allocating and Constructing Box

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates manual memory allocation using std::alloc and constructing a Box from the allocated memory. This is an advanced use case requiring careful memory management.

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}

```

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

### get_int

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a signed n-byte integer from the source in big-endian byte order.

```APIDOC
## get_int

### Description
Gets a signed n-byte integer from `self` in big-endian byte order.

### Parameters
#### Query Parameters
- **nbytes** (usize) - Required - The number of bytes to read for the signed integer.

### Signature
`fn get_int(&mut self, nbytes: usize) -> i64`
```

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

### Create a Box<T> with a value

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Allocates memory on the heap and places a value into it. This is the most common way to create a Box.

```rust
let five = Box::new(5);
```

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

### get_u128_be

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets an unsigned 128-bit integer from the source in big-endian byte order.

```APIDOC
## get_u128_be

### Description
Gets an unsigned 128-bit integer from `self` in big-endian byte order.

### Signature
`fn get_u128_be(&mut self) -> u128`
```

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

### get_int_ne

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Gets a signed n-byte integer from `self` in native-endian byte order.

```APIDOC
## fn get_int_ne(&mut self, nbytes: usize) -> i64

### Description
Gets a signed n-byte integer from `self` in native-endian byte order.

### Method
Implicit (method call on `self`)

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read.

### Return Value
i64: The signed integer.

### Source
[Link to source code]
```

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

### clone_from_ref_in

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Allocates memory in the given allocator then clones `src` into it. This is a nightly-only experimental API.

```APIDOC
## clone_from_ref_in

### Description
Allocates memory in the given allocator then clones `src` into it. This doesn’t actually allocate if `src` is zero-sized.

### Method
`pub fn clone_from_ref_in(src: &T, alloc: A) -> Box<T, A>`

### Parameters
- `src` (&T): The value to clone.
- `alloc` (A): The allocator to use for memory allocation.

### Returns
A `Box<T, A>` containing the cloned value.

### Notes
This is a nightly-only experimental API. (`clone_from_ref`)

### Examples
```rust
#![feature(clone_from_ref)]
#![feature(allocator_api)]

use std::alloc::System;

let hello: Box<str, System> = Box::clone_from_ref_in("hello", System);
```
```

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

### Attempting to Create an Uninitialized Box with a Specific Allocator

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Use `Box::try_new_uninit_in` to attempt creating an uninitialized Box with a specified allocator, returning a Result. This is a nightly-only feature.

```Rust
#![feature(allocator_api)]

use std::alloc::System;

let mut five = Box::<u32, _>::try_new_uninit_in(System)?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```

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

### get_int_le

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Gets a signed n-byte integer from `self` in little-endian byte order.

```APIDOC
## fn get_int_le(&mut self, nbytes: usize) -> i64

### Description
Gets a signed n-byte integer from `self` in little-endian byte order.

### Method
Implicit (method call on `self`)

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read.

### Return Value
i64: The signed integer.

### Source
[Link to source code]
```

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

### Box::try_new_zeroed

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs a new Box with uninitialized contents, memory filled with 0 bytes on the heap, returning an error if allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_new_zeroed

### Description
Constructs a new `Box` with uninitialized contents, with the memory being filled with `0` bytes on the heap, returning an error if allocation fails.

### Method
Associated function (Nightly-only experimental API: `allocator_api`)

### Response
- **Result<Box<MaybeUninit<T>>, AllocError>** - Ok containing a box with zeroed contents on success, or an `AllocError` on failure.

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

let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
```
```

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

### get_int

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Gets a signed n-byte integer from `self` in big-endian byte order.

```APIDOC
## fn get_int(&mut self, nbytes: usize) -> i64

### Description
Gets a signed n-byte integer from `self` in big-endian byte order.

### Method
Implicit (method call on `self`)

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read.

### Return Value
i64: The signed integer.

### Source
[Link to source code]
```

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

### Manually create Box from NonNull pointer

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Manually creates a `Box` from scratch using the system allocator by allocating memory, casting it, writing a value, and then constructing the `Box`.

```rust
#![feature(allocator_api)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let non_null = System.allocate(Layout::new::<i32>())?.cast::<i32>();
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null_in(non_null, System);
}
```

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

### get_uint_ne

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Gets an unsigned n-byte integer from `self` in native-endian byte order.

```APIDOC
## fn get_uint_ne(&mut self, nbytes: usize) -> u64

### Description
Gets an unsigned n-byte integer from `self` in native-endian byte order.

### Method
Implicit (method call on `self`)

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read.

### Return Value
u64: The unsigned integer.

### Source
[Link to source code]
```

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

### Box::take Example

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Consumes a Box without deallocating its memory, returning the value and a Box to the uninitialized memory. Useful for reusing allocations. This is a nightly-only experimental API.

```rust
#![feature(box_take)]

let c = Box::new(5);

// take the value out of the box
let (value, uninit) = Box::take(c);
assert_eq!(value, 5);
```

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

### get_uint_le

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Gets an unsigned n-byte integer from `self` in little-endian byte order.

```APIDOC
## fn get_uint_le(&mut self, nbytes: usize) -> u64

### Description
Gets an unsigned n-byte integer from `self` in little-endian byte order.

### Method
Implicit (method call on `self`)

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read.

### Return Value
u64: The unsigned integer.

### Source
[Link to source code]
```

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

### take

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=std%3A%3Avec

Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Parameters
- **n** (usize) - The maximum number of elements to yield.

### Returns
A `Take` iterator that yields at most `n` elements.
```

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

### get_uint

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Gets an unsigned n-byte integer from `self` in big-endian byte order.

```APIDOC
## fn get_uint(&mut self, nbytes: usize) -> u64

### Description
Gets an unsigned n-byte integer from `self` in big-endian byte order.

### Method
Implicit (method call on `self`)

### Parameters
- **nbytes** (usize) - Required - The number of bytes to read.

### Return Value
u64: The unsigned integer.

### Source
[Link to source code]
```

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

### Cloning a Box<T, A>

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Demonstrates how to create a new Box with a clone of the original contents. Ensures the cloned value is identical but a unique object in memory.

```rust
let x = Box::new(5);
let y = x.clone();

// The value is the same
assert_eq!(x, y);

// But they are unique objects
assert_ne!(&*x as *const i32, &*y as *const i32);
```

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

### Any Trait Implementation for HeaderExtractor

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/struct.HeaderExtractor.html?search=u32+-%3E+bool

Provides the type_id method to get the TypeId of the HeaderExtractor.

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

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

### Box::try_new_zeroed_in

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html

Constructs a new `Box` with uninitialized contents, filled with `0` bytes in the provided allocator, returning an error if the allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_new_zeroed_in

### Description
Constructs a new `Box` with uninitialized contents, with the memory being filled with `0` bytes in the provided allocator, returning an error if the allocation fails.

### Method
`try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>`

### Parameters
- **alloc** (A) - The allocator to use.

### Response
#### Success Response
- **Box<MaybeUninit<T>, A>** - The newly created box with zeroed contents.
#### Error Response
- **AllocError** - If the allocation fails.

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

use std::alloc::System;

let zero = Box::<u32, _>::try_new_zeroed_in(System)?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
```
```

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

### Implement Any for T

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/struct.HeaderExtractor.html

Gets the TypeId of self. This is a standard trait implementation for trait objects.

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

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

### try_get_u64_le

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempts to get an unsigned 64-bit integer from the source in little-endian byte order.

```APIDOC
## try_get_u64_le

### Description
Gets an unsigned 64-bit integer from `self` in little-endian byte order.

### Signature
`fn try_get_u64_le(&mut self) -> Result<u64, TryGetError>`

### Response
#### Success Response (Ok)
- Returns `Ok(u64)` containing the unsigned 64-bit integer.

#### Error Response (Err)
- Returns `Err(TryGetError)` if there are not enough bytes to read an unsigned 64-bit integer.
```

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

### Equivalent manual cleanup using Box::from_non_null

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Shows an alternative method for manual cleanup by converting the `NonNull` pointer back to a `Box` within an `unsafe` block, leveraging the `Box` destructor for deallocation.

```rust
#![feature(box_vec_non_null)]

let x = Box::new(String::from("Hello"));
let non_null = Box::into_non_null(x);
unsafe {
    drop(Box::from_non_null(non_null));
}

```

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

### From<Cow<'b, str>> for Box<dyn Error + 'a>

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=u32+-%3E+bool

Converts a Cow<'b, str> into a Box<dyn Error + 'a>. This is available on non-`no_global_oom_handling` configurations.

```APIDOC
## fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a>

### Description
Converts a `Cow` into a box of dyn `Error`.

### Examples
```rust
use std::error::Error;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(size_of::<Box<dyn Error>>() == size_of_val(&a_boxed_error))
```
```

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

### try_get_u64

Source: https://docs.rs/opentelemetry-http/latest/opentelemetry_http/type.HttpError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempts to get an unsigned 64-bit integer from the source in big-endian byte order.

```APIDOC
## try_get_u64

### Description
Gets an unsigned 64-bit integer from `self` in big-endian byte order.

### Signature
`fn try_get_u64(&mut self) -> Result<u64, TryGetError>`

### Response
#### Success Response (Ok)
- Returns `Ok(u64)` containing the unsigned 64-bit integer.

#### Error Response (Err)
- Returns `Err(TryGetError)` if there are not enough bytes to read an unsigned 64-bit integer.
```
Tokens:
Raw