JXL Oxide

https://docs.rs/jxl-oxide/
Admin
JXL Oxide is a JPEG XL decoder written in pure Rust that provides a simple interface to decode JPEG...
Tokens:167,829
Snippets:1,392
Trust Score:9.1
Update:1 week ago
Show doc for...
Tokens:
Raw
### String::capacity example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Shows how to get the capacity of a `String` using `capacity`. The example creates a `String` with capacity 10 and asserts it is at least 10.

```rust
let s = String::with_capacity(10);

assert!(s.capacity() >= 10);
```

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

### into_ok example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use into_ok to get the Ok value without panicking, using a Result with the never type as the error.

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

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

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

### as_ref example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use as_ref to get a Result with references to the original values, leaving the original intact.

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

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

### as_mut example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Demonstrates using as_mut to get a Result with mutable references, allowing modification of 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);
```

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

### trim_prefix examples

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Examples for trim_prefix, which removes a prefix if present and returns &str for chaining.

```rust
// Prefix present - removes it
assert_eq!("foo:bar".trim_prefix("foo:"), "bar");
assert_eq!("foofoo".trim_prefix("foo"), "foo");

// Prefix absent - returns original string
assert_eq!("foo:bar".trim_prefix("bar"), "foo:bar");

// Method chaining example
assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");
```

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

### is_ok() Example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Example of using the is_ok() method to check if a Result is Ok.

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

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

### len() example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Shows how to get the byte length of a string. Note that the length is in bytes, not characters or graphemes.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

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

### is_ok_and() Example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Example of using the is_ok_and() method to check if a Result is Ok and the value matches a predicate.

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

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

### or example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Returns the Ok value of self if Ok, otherwise returns the provided result. The example shows various combinations of Ok and Err results.

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

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

### trim_start_matches with char slice

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Example for trim_start_matches using a slice of chars to remove matching characters from the start of a string.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

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

### expect example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Returns the contained Ok value, panicking with a message if Err. The first example shows a panic, the second shows the recommended message style.

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

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

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

### unwrap_or example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Returns the contained Ok value or a provided default. The example shows both Ok and Err cases.

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

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

### strip_prefix examples

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Examples for strip_prefix, which removes a prefix exactly once and returns Option<&str>.

```rust
assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
assert_eq!("foo:bar".strip_prefix("bar"), None);
assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
```

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

### map example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use map to apply a function to the Ok value of a Result, leaving Err untouched. The example parses numbers from lines and prints them doubled.

```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}"),
        Err(..) => {}
    }
}
```

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

### get() example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Returns a subslice of the string without panicking. Returns `None` if the index is out of bounds or not on a UTF-8 boundary.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### into_err example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use into_err to get the Err value without panicking, using a Result with the never type as the Ok type.

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

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

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

### trim_suffix examples

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Examples for trim_suffix, which removes a suffix if present and returns &str for chaining.

```rust
// Suffix present - removes it
assert_eq!("bar:foo".trim_suffix(":foo"), "bar");
assert_eq!("foofoo".trim_suffix("foo"), "foo");

// Suffix absent - returns original string
assert_eq!("bar:foo".trim_suffix("bar"), "bar:foo");
```

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

### is_err_and example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use is_err_and to check if a Result is Err and the error value matches a predicate. Includes examples with different error kinds and ownership.

```rust
use std::io::{Error, ErrorKind};

let x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);

let x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

let x: Result<u32, Error> = Ok(123);
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

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

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

### and_then with metadata example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Uses and_then to chain metadata retrieval and modified time. Shows that on Windows, "/" maps to "C:\". The example asserts that a valid path returns Ok and an invalid path returns an error of kind 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);
```

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

### String::as_str example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Shows how to extract a string slice from a `String` using `as_str`. The example creates a `String` from "foo" and asserts the slice equals "foo".

```rust
let s = String::from("foo");

assert_eq!("foo", s.as_str());
```

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

### inspect example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Calls a function with a reference to the contained value if Ok, and returns the original result. The example chains inspect with map and expect to parse and cube a number.

```rust
let x: u8 = "4"
    .parse::<u8>()
    .inspect(|x| println!("original: {x}"))
    .map(|x| x.pow(3))
    .expect("literal `4` should parse as a `u8`");
```

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

### String::try_reserve example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Shows using `try_reserve` to pre-reserve memory and handle potential errors. The example defines a function that tries to reserve memory for the input data and returns an error if it fails.

```rust
use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // Pre-reserve the memory, exiting if we can't
    output.try_reserve(data.len())?;

    // Now we know this can't OOM in the middle of our complex work
    output.push_str(data);

    Ok(output)
}
```

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

### replace: basic usage and non-matching pattern

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Shows how to use str::replace to replace all occurrences of a pattern. The first example replaces "old" with "new" and "is" with "an". The second example shows that when the pattern doesn't match, the original string is returned as a String.

```rust
assert_eq!("this is new", s.replace("old", "new"));
assert_eq!("than an old", s.replace("is", "an"));
```

```rust
let s = "this is old";
assert_eq!(s, s.replace("cookie monster", "little lamb"));
```

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

### repeat panic upon overflow

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

This example will panic at runtime because the capacity overflows.

```rust
// this will panic at runtime
let huge = "0123456789abcdef".repeat(usize::MAX);
```

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

### unwrap_or_default example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use unwrap_or_default to convert a string to an integer, returning 0 for poorly-formed strings.

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

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

### Product example: parsing and multiplying numbers

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use the Product implementation on Result to multiply parsed numbers, returning Err if any parse fails.

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

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

### ok example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Demonstrates converting a Result to an Option using ok, returning Some(value) for Ok and None for Err.

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

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

### Feed byte buffers asynchronously with build_uninit, feed_bytes, and try_init

Source: https://docs.rs/jxl-oxide/latest/index.html

In async contexts, create an uninitialized image with build_uninit, feed byte buffers with feed_bytes, and call try_init to check initialization. The loop continues until InitializeResult::Initialized is returned, then prints the image header.

```rust
let mut uninit_image = JxlImage::builder().build_uninit();
let image = loop {
    uninit_image.feed_bytes(reader.read().await?);
    match uninit_image.try_init()? {
        InitializeResult::NeedMoreData(uninit) => {
            uninit_image = uninit;
        }
        InitializeResult::Initialized(image) => {
            break image;
        }
    }
};
println!("{:?}", image.image_header()); // Prints the image header
```

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

### unwrap basic usage

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use Result::unwrap to get the contained Ok value. This example asserts that unwrap returns the value 2.

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

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

### is_char_boundary() example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Checks if a byte index is a valid UTF-8 code point boundary. The start and end of the string are considered boundaries, and `false` is returned for indices greater than the string length.

```rust
let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));
```

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

### is_err() Example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Example of using the is_err() method to check if a Result is Err.

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

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

### Feed bytes and initialize an UninitializedJxlImage

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/struct.UninitializedJxlImage.html

Shows how to build an uninitialized image, feed bytes incrementally, and loop until initialization completes. The loop handles NeedMoreData by reassigning the uninitialized image and breaks when Initialized is returned, then prints the image header.

```rust
let mut uninit_image = JxlImage::builder().build_uninit();
let image = loop {
    let buf = read_bytes()?;
    uninit_image.feed_bytes(buf)?;
    match uninit_image.try_init()? {
        InitializeResult::NeedMoreData(uninit) => {
            uninit_image = uninit;
        }
        InitializeResult::Initialized(image) => {
            break image;
        }
    }
};
println!("{:?}", image.image_header());
```

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

### strip_suffix examples

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Examples for strip_suffix, which removes a suffix exactly once and returns Option<&str>.

```rust
assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
assert_eq!("bar:foo".strip_suffix("bar"), None);
assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
```

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

### replace example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Shows how replace creates a new String and replaces all matches of a pattern with a replacement string.

```rust
let s = "this is old";
```

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

### JxlImage::open_with_defaults

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/struct.JxlImage.html

Opens an image in the filesystem with default options.

```APIDOC
## JxlImage::open_with_defaults

### Description
Opens an image in the filesystem with default options.

### Method
`pub fn open_with_defaults(path: impl AsRef<Path>) -> Result<JxlImage>`

### Parameters
- `path` (impl AsRef<Path>) - Required - The path to the image file.

### Returns
- `Result<JxlImage>` - The decoded image or an error.

```

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

### and_then example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use and_then for control flow, calling a function that returns a Result only when the original Result is Ok.

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

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

### strip_circumfix examples

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Examples for strip_circumfix, which removes both a prefix and suffix exactly once, returning Option<&str>.

```rust
assert_eq!("bar:hello:foo".strip_circumfix("bar:", ":foo"), Some("hello"));
assert_eq!("bar:foo".strip_circumfix("foo", "foo"), None);
assert_eq!("foo:bar;".strip_circumfix("foo:", ';'), Some("bar"));
assert_eq!("foo:bar:baz".strip_circumfix("foo:bar:", ":bar:baz"), None);
```

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

### split: Separators at start or end

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Shows that separators at the start or end of a string are neighbored by empty strings.

```rust
let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);
```

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

### is_ascii example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Checks if a string contains only ASCII characters. The example includes a non-ASCII string with 'ü' and '❤'.

```rust
let ascii = "hello!\n";
let non_ascii = "Grüße, Jürgen ❤";
```

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

### split: Simple patterns

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Demonstrates splitting a string slice by `char`, `&str`, and closures, collecting into a `Vec<&str>`. Includes edge cases like empty strings and no matches.

```rust
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "AABBCC".split("DD").collect();
assert_eq!(v, ["AABBCC"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
```

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

### matches example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Returns an iterator over disjoint matches of a pattern in the string. Example collects all occurrences of "abc".

```rust
let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);
```

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

### Set a custom CMS and request a color encoding

Source: https://docs.rs/jxl-oxide/latest/src/jxl_oxide/lib.rs.html

Shows how to set an external CMS using set_cms and request a color encoding (Display P3 with perceptual intent) using request_color_encoding.

```rust
//! # use jxl_oxide::{EnumColourEncoding, JxlImage, RenderingIntent};
//! # use jxl_oxide::NullCms as MyCustomCms;
//! # let reader = std::io::empty();
//! let mut image = JxlImage::builder().read(reader).expect("Failed to read image header");
//! image.set_cms(MyCustomCms);
//!
//! let color_encoding = EnumColourEncoding::display_p3(RenderingIntent::Perceptual);
//! image.request_color_encoding(color_encoding);
```

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

### unwrap_or_else example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Returns the contained Ok value or computes it from a closure. The example defines a count function that returns the length of a string.

```rust
fn count(x: &str) -> usize { x.len() }

assert_eq!(Ok(2).unwrap_or_else(count), 2);
assert_eq!(Err("foo").unwrap_or_else(count), 3);
```

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

### iter example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Returns an iterator over the possibly contained value, yielding one value if Ok and none if Err. The example shows both cases.

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

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

### Open a JPEG XL image from a file with JxlImage::builder().open

Source: https://docs.rs/jxl-oxide/latest/index.html

Constructs a JxlImage by opening a file path. The builder's open method reads the file and returns a JxlImage after parsing the header. The example prints the image header.

```rust
let image = JxlImage::builder().open("input.jxl").expect("Failed to read image header");
println!("{:?}", image.image_header()); // Prints the image header
```

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

### pub fn repeat(&self, n: usize) -> String

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Creates a new String by repeating a string n times. Panics if the capacity would overflow.

```APIDOC
## pub fn repeat(&self, n: usize) -> String

### Description
Creates a new `String` by repeating a string `n` times.

### Method
pub fn repeat(&self, n: usize) -> String

### Parameters
- **self** (&str) - The string to repeat.
- **n** (usize) - The number of times to repeat the string.

### Return Value
- **String** - The repeated string.

### Panics
This function will panic if the capacity would overflow.

### Examples
```rust
assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));

// this will panic at runtime
let huge = "0123456789abcdef".repeat(usize::MAX);
```
```

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

### Incremental decoding with UninitializedJxlImage and try_init

Source: https://docs.rs/jxl-oxide/latest/src/jxl_oxide/lib.rs.html

Shows the recommended pattern for incremental decoding: feed bytes into an uninitialized image, call try_init, and loop until initialization completes. The example uses a helper read_bytes() that returns a byte slice; the loop breaks when InitializeResult::Initialized is returned, then prints the image header.

```rust
/// Empty, uninitialized JPEG XL image.
///
/// # Examples
/// ```no_run
/// # fn read_bytes() -> jxl_oxide::Result<&'static [u8]> { Ok(&[]) }
/// # use jxl_oxide::{JxlImage, InitializeResult};
/// # fn main() -> jxl_oxide::Result<()> {
/// let mut uninit_image = JxlImage::builder().build_uninit();
/// let image = loop {
///     let buf = read_bytes()?;
///     uninit_image.feed_bytes(buf)?;
///     match uninit_image.try_init()? {
///         InitializeResult::NeedMoreData(uninit) => {
///             uninit_image = uninit;
///         }
///         InitializeResult::Initialized(image) => {
///             break image;
///         }
///     }
/// };
/// println!("{:?}", image.image_header());
/// # Ok(())
/// # }
/// ```
```

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

### as_deref example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Converts Result<T, E> to Result<&<T as Deref>::Target, &E> by dereferencing the Ok variant. The example shows both Ok and Err cases.

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

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

### String::as_mut_str example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Demonstrates converting a `String` to a mutable string slice with `as_mut_str`, then modifying it in place. The example uppercases the string and asserts the result.

```rust
let mut s = String::from("foobar");
let s_mut_str = s.as_mut_str();

s_mut_str.make_ascii_uppercase();

assert_eq!("FOOBAR", s_mut_str);
```

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

### and_then example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Chains fallible operations that may return Err. The example uses a function sq_then_to_string that squares a number and returns a string, or an error if overflow.

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

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

### pub fn is_loading_done(&self) -> bool

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/struct.Frame.html

Checks if loading is done.

```APIDOC
## is_loading_done

### Description
Checks if loading is done.

### Method
is_loading_done

### Signature
`pub fn is_loading_done(&self) -> bool`

### Parameters
None

### Returns
- `bool` - `true` if loading is done, `false` otherwise.
```

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

### iter_mut example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Returns a mutable iterator over the possibly contained value, allowing modification of the Ok value. The example shows modifying the value and the Err case.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

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

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

### to_lowercase: basic usage, sigma, and no-case languages

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Shows how to use str::to_lowercase to convert a string to lowercase. Includes basic usage, handling of Greek sigma (context-dependent), and languages without case (Chinese).

```rust
let s = "HELLO WORLD";

assert_eq!("hello world", s.to_lowercase());
```

```rust
let sigma = "Σ";

assert_eq!("σ", sigma.to_lowercase());

// but at the end of a word, it's ς, not σ:
let odysseus = "ὈΔΥΣΣΕΎΣ";

assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());

let odysseus_king_of_ithaca = "Ο ΟΔΥΣΣΈΑΣ ΒΑΣΙΛΙΆΣ ΤΗΣ ΙΘΆΚΗΣ";

assert_eq!("ο οδυσσέας βασιλιάς της ιθάκης", odysseus_king_of_ithaca.to_lowercase());
```

```rust
let new_year = "农历新年";

assert_eq!(new_year, new_year.to_lowercase());
```

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

### inspect_err example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Calls a function with a reference to the contained error if Err, and returns the original result. The example reads a file and prints an error message on failure.

```rust
use std::{fs, io};

fn read() -> io::Result<String> {
    fs::read_to_string("address.txt")
        .inspect_err(|e| eprintln!("failed to read file: {e}"))
}
```

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

### Sum example: summing integers with error handling

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Shows how to use the Sum implementation on Result to sum integers, returning Err if any element is negative.

```rust
let f = |&x: &i32| if x < 0 { Err("Negative element found") } else { Ok(x) };
let v = vec![1, 2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Ok(3));
let v = vec![1, -2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Err("Negative element found"));
```

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

### starts_with() - Check prefix with &str

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Returns `true` if the pattern matches a prefix of the string. The pattern can be a `&str`, `char`, slice of `char`s, or closure.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

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

### match_indices: collect matches with start indices

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Uses `match_indices` to collect matches along with their starting indices. Overlapping matches are not included; only the first match is reported.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
```

```rust
let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);
```

```rust
let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

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

### err example

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Demonstrates converting a Result to an Option using err, returning Some(error) for Err and None for Ok.

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

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

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

### pub const fn is_ok(&self) -> bool

Source: https://docs.rs/jxl-oxide/latest/jxl_oxide/type.Result.html

Returns true if the result is Ok.

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

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

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

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

```

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

### chars basic usage example

Source: https://docs.rs/jxl-oxide-common/1.0.0/jxl_oxide_common/struct.Name.html

Returns an iterator over the `char`s of a string slice. The example counts characters and iterates through them, showing that `char` represents Unicode scalar values.

```rust
let word = "goodbye";

let count = word.chars().count();
assert_eq!(7, count);

let mut chars = word.chars();

assert_eq!(Some('g'), chars.next());
assert_eq!(Some('o'), chars.next());
assert_eq!(Some('o'), chars.next());
assert_eq!(Some('d'), chars.next());
assert_eq!(Some('b'), chars.next());
assert_eq!(Some('y'), chars.next());
assert_eq!(Some('e'), chars.next());

assert_eq!(None, chars.next());
```
Tokens:
Raw