### Run daoxide examples

Source: https://docs.rs/daoxide

Commands to execute the provided example Rust programs for minimal client, object I/O, and pool/container management.

```bash
cargo run --example minimal_client
cargo run --example object_io
cargo run --example pool_container

```

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

### Build Documentation with Cargo

Source: https://docs.rs/daoxide

Builds the documentation for the entire workspace, including all features, without dependencies. Use this to generate project documentation.

```bash
cargo doc --workspace --all-features --no-deps
```

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

### Connect to DAOS and perform basic operations

Source: https://docs.rs/daoxide

Demonstrates the high-level facade API for connecting to DAOS, allocating an object ID, and performing put/get operations.

```rust
use daoxide::prelude::*;

fn main() -> daoxide::Result<()> {
    let client = DaosClient::builder()
        .pool_label("mypool")
        .container_label("mycontainer")
        .build()?;

    let oid = client.alloc_oid(
        ObjectType::KvHashed,
        ObjectClass::UNKNOWN,
        ObjectClassHints::NONE,
    )?;

    client.put(oid, b"dkey1", b"akey1", b"hello world")?;

    let mut buffer = vec![0u8; 1024];
    client.get(oid, b"dkey1", b"akey1", &mut buffer[..11])?;

    println!("Retrieved: {:?}", String::from_utf8_lossy(&buffer[..11]));
    Ok(())
}

```

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

### Connect to DAOS and manage containers

Source: https://docs.rs/daoxide

Demonstrates the mid-level API for connecting to a DAOS pool and creating/querying a container.

```rust
use daoxide::pool::{PoolBuilder, flags::POOL_CONNECT_NONE};
use daoxide::container::{ContainerOpen, flags::CONT_OPEN_RW};

fn main() -> daoxide::Result<()> {
    let runtime = daoxide::runtime::DaosRuntime::new()?;

    let pool = PoolBuilder::new()
        .label("mypool")
        .system("daos_server")
        .flags(POOL_CONNECT_NONE)
        .build()?;

    let container = pool.create_container("testcontainer")?;
    let info = container.query()?;
    println!("Container UUID: {:?}", info.uuid);

    Ok(())
}

```

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

### Perform low-level object I/O operations

Source: https://docs.rs/daoxide

Demonstrates the low-level API for performing key-value operations on a DAOS object using DKey, AKey, and IoBuffer.

```rust
use daoxide::io::{DKey, AKey, IoBuffer, Iod, IodSingleBuilder, Sgl};
use daoxide::prelude::*;

let object = client.object_builder()
    .open(oid, ObjectOpenMode::ReadWrite)?;

let dkey = DKey::new(b"my_dkey")?;
let akey = AKey::new(b"my_akey")?;
let value = IoBuffer::from_vec(b"hello world".to_vec());

let iod = Iod::Single(
    IodSingleBuilder::new(akey.clone())
        .value_len(value.len())
        .build()?,
);
let sgl = Sgl::builder().push(value).build()?;

object.update(&Tx::none(), &dkey, &iod, &sgl)?;


```

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

### Run tests with single thread

Source: https://docs.rs/daoxide

Command to execute all tests in the workspace with all features enabled, ensuring tests run sequentially using --test-threads=1.

```bash
# Tests (must use --test-threads=1)
cargo test --workspace --all-features -- --test-threads=1

```

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

### Check code formatting

Source: https://docs.rs/daoxide

Command to check code formatting across the entire workspace using cargo fmt.

```bash
# Code formatting check
cargo fmt --all -- --check

```

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

### Add daoxide dependency with async feature

Source: https://docs.rs/daoxide

Include the daoxide crate in your Cargo.toml file, enabling the 'async' feature for asynchronous runtime support.

```toml
[dependencies]
daoxide = { version = "0.1", features = ["async"] }

```

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

### Parallel Testing with Thread Limit

Source: https://docs.rs/daoxide

Runs all tests in the workspace with all features enabled, specifically limiting parallel test execution to one thread. This is a workaround for potential issues with global state (`RUNTIME_REFCOUNT`) during parallel testing.

```bash
cargo test --workspace --all-features -- --test-threads=1
```

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

### Run Clippy checks

Source: https://docs.rs/daoxide

Command to run Clippy linter on the workspace with all targets and features, treating warnings as errors.

```bash
# Clippy check
cargo clippy --workspace --all-targets --all-features -- -D warnings

```

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

### Verify MSRV with Cargo

Source: https://docs.rs/daoxide

Compiles the project in release mode using a specific Rust toolchain version (1.85 in this case) to verify the Minimum Supported Rust Version (MSRV).

```bash
cargo +1.85 build --release
```

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

### Feature Matrix Validation with Cargo Check

Source: https://docs.rs/daoxide

Validates the project's features using `cargo check`. This includes checking without default features, checking each feature independently, and checking with all features enabled.

```bash
cargo check --no-default-features
```

```bash
cargo check --features mock
```

```bash
cargo check --features async
```

```bash
cargo check --all-features
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.