Dittolive Ditto

https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/
Admin
The `dittolive_ditto` Rust SDK provides a cross-platform, peer-to-peer database that enables...
Tokens:335,906
Snippets:2,542
Trust Score:8.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Ditto New Instance Creation

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/mod

Constructs a Ditto instance with sensible defaults, requiring manual sync start and license setting.

```rust
/// Construct a [`Ditto`] instance with sensible defaults.
    ///
    /// This instance will still need to have a license set (if necessary) and sync functionality
    /// manually started.
    pub fn new(app_id: AppId) -> Ditto {
        Ditto::builder()
            .with_root(Arc::new(
                PersistentRoot::from_current_exe().expect("Invalid Ditto Root"),
            ))
            .with_identity(|ditto_root| identity::OfflinePlayground::new(ditto_root, app_id))
            .expect("Invalid Ditto Identity")
            .with_minimum_log_level(LogLevel::Info)
            .build()
            .expect("Failed to build Ditto Instance")
    }
```

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

### Ditto Sync Module

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/sync/index

Documentation for the sync module, which handles data synchronization within the Ditto ecosystem. It includes sections on examples and available structs.

```rust
// Documentation for the sync module
// See: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/sync/index.html
```

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

### Rust Diff Initialization Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/dql/struct

Demonstrates how to create an empty `Diff` struct and populate its `insertions` field. This is useful for manually constructing diffs or starting with an empty state.

```rust
let mut diff = Diff::empty();
diff.insertions.extend([1, 2, 3]);
```

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

### Ditto Utils Main Module

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/utils/prelude

Documentation for the main utilities module, including macros, prelude, string utilities, and set operations.

```rust
mod extension_traits;
mod macros;
mod prelude;
mod set_arc;
mod zstr;
```

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

### DQL Write and Read Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/dql/index

Demonstrates how to write and read data using the Ditto Query Language (DQL). This example is part of the dql module documentation.

```rust
/*
Example: Write and Read with DQL
https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/dql/index.html#example-write-and-read-with-dql
*/
// Code for writing and reading with DQL would go here.
```

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

### DittoBuilder Initialization and Configuration

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/builder

Demonstrates how to initialize and configure a Ditto instance using the DittoBuilder. This includes setting the root directory, minimum log level, and temporary directory.

```rust
use ffi_sdk::Platform;
use super::*;
use crate::identity::Identity;

pub struct DittoBuilder {
    ditto_root: Option<Arc<dyn DittoRoot>>,
    identity: Option<Arc<dyn Identity>>,
    minimum_log_level: Option<LogLevel>,
    transport_config: Option<TransportConfig>,
}

impl DittoBuilder {
    #[doc(hidden)]
    #[deprecated(note = "Use `Ditto::builder()` instead")]
    pub fn new() -> DittoBuilder {
        DittoBuilder {
            ditto_root: None,
            identity: None,
            minimum_log_level: None,
            transport_config: None,
        }
    }

    pub fn with_root(mut self, ditto_root: Arc<dyn DittoRoot>) -> Self {
        self.ditto_root = Some(ditto_root);
        self
    }

    pub fn with_minimum_log_level(mut self, log_level: LogLevel) -> Self {
        self.minimum_log_level = Some(log_level);
        self
    }

    pub fn with_temp_dir(mut self) -> Self {
        let root = TempRoot::new();
        self.ditto_root = Some(Arc::new(root));
        self
    }

    pub fn with_identity<F, I>(mut self, factory: F) -> Result<Self, DittoError>
    where
        F: FnOnce(Arc<dyn DittoRoot>) -> Result<I, DittoError>,
        I: Identity + 'static,
    {
        match &self.ditto_root {
            Some(root) => {
                // ... implementation details ...
            }
            None => Err(DittoError::NoRoot),
        }
    }
}
```

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

### Ditto SDK Initialization and Logging

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/builder

Details the process of initializing the Ditto SDK with version information and setting up the logger. This includes determining the platform and SDK version.

```rust
use ffi_sdk::Platform;

impl DittoBuilder {
    fn platform() -> Platform {
        using!(match () {
            use ffi_sdk::Platform;
            | _case if cfg!(target_os = "windows") => Platform::Windows,
            | _case if cfg!(target_os = "android") => Platform::Android,
            | _case if cfg!(target_os = "macos") => Platform::Mac,
            | _case if cfg!(target_os = "ios") => Platform::Ios,
            | _case if cfg!(target_os = "tvos") => Platform::Tvos,
            | _case if cfg!(target_os = "linux") => Platform::Linux,
            | _default => Platform::Unknown,
        })
    }

    fn sdk_version() -> String {
        let sdk_semver = env!("CARGO_PKG_VERSION");
        sdk_semver.to_string()
    }

    fn init_sdk_version() {
        let platform = Self::platform();
        let sdk_semver = Self::sdk_version();
        let c_version = char_p::new(sdk_semver);
        ffi_sdk::ditto_init_sdk_version(platform, ffi_sdk::Language::Rust, c_version.as_ref());
    }

    fn init_logging(&self) {
        if let Some(level) = self.minimum_log_level {
            ffi_sdk::ditto_logger_minimum_log_level(level);
        }
        ffi_sdk::ditto_logger_init();
        ffi_sdk::ditto_logger_enabled(true);
    }
}
```

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

### DQL Observe Document Updates Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/dql/index

Illustrates how to observe document updates using the Ditto Query Language (DQL). This example is part of the dql module documentation.

```rust
/*
Example: Observe document updates with DQL
https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/dql/index.html#example-observe-document-updates-with-dql
*/
// Code for observing document updates with DQL would go here.
```

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

### Ditto Utils Main Module

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/dql/query

Documentation for the main utilities module, including macros, prelude, string utilities, and set operations.

```rust
mod extension_traits;
mod macros;
mod prelude;
mod set_arc;
mod zstr;
```

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

### Rust Result Example: Subtracting with Underflow Check

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/error/type

An example showcasing `collect()` with `Result` to process a vector, specifically checking for underflow during subtraction. It returns an `Err` if any element causes an underflow.

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

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

### Rust Result Example: Incrementing Vector Elements

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/error/type

An example demonstrating the use of `collect()` with `Result` to process a vector of numbers, returning an `Ok` result if all operations succeed, or the first `Err` encountered.

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

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

### Ditto Utils Main Module

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/observer

Documentation for the main utilities module, including macros, prelude, string utilities, and set operations.

```rust
mod extension_traits;
mod macros;
mod prelude;
mod set_arc;
mod zstr;
```

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

### Get Attachment Path

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/attachment/mod

Retrieves the complete file system path for a Ditto attachment. This method requires an active Ditto instance and will panic if Ditto has been released. It interacts with the FFI SDK to get the path.

```rust
pub fn path(&self) -> PathBuf {
    // FIXME(Ronan) Ideally wrap this function in a Result
    let ditto = self.ditto.try_upgrade().unwrap();
    let p = ffi_sdk::ditto_get_complete_attachment_path(&ditto, &self.attachment_handle);
    let p_string = p.to_string();
    p_string.into()
}
```

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

### Ditto Utils Main Module

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/attachment/fetch_event

Documentation for the main utilities module, including macros, prelude, string utilities, and set operations.

```rust
mod extension_traits;
mod macros;
mod prelude;
mod set_arc;
mod zstr;
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/dql/differ

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Rust Result Example: Partial Processing on Error

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/error/type

Illustrates how `collect()` with `Result` stops processing the iterator upon encountering the first `Err`. This example shows that subsequent elements are not processed, as demonstrated by a shared counter.

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

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

### Rust Mutex is_poisoned Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/disk_usage/type

Illustrates how to check if a Mutex has been poisoned. A Mutex becomes poisoned if a thread panics while holding the lock. This example shows how to detect and potentially react to a poisoned Mutex.

```rust
use std::sync::{Arc, Mutex};
use std::thread;

let mutex = Arc::new(Mutex::new(0));
let c_mutex = Arc::clone(&mutex);

let _ = thread::spawn(move || {
    let _lock = c_mutex.lock().unwrap();
    panic!(); // the mutex gets poisoned
}).join();
assert_eq!(mutex.is_poisoned(), true);
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/attachment/fetcher

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Rust: Mutably Access JSON Object Elements

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/presence/type

Provides an example of how to mutably access and modify elements within a JSON object (serde_json::map::Map<String, Value>) using string keys. Similar to immutable access, this operation panics if the key does not exist. The example shows assigning a new JSON value to a specific key.

```rust
map["key"] = json!("value");
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/prelude

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Identity Management

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/index

Ditto requires an Identity to start syncing with other peers.

```rust
use dittolive_ditto::identity::Identity;

// Example usage:
// let identity = Identity::new("my_device_id");
// ditto.start_sync(identity);
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/attachment/token

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get QueryResult Item Count

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/dql/query_result

Returns the total number of `QueryResultItem`s available in the `QueryResult`.

```rust
/// Return the number of available [`QueryResultItem`].
pub fn item_count(&self) -> usize {
    self.count
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/observer

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/error

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Example Usage of Small Peer Info

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/small_peer_info/mod

Demonstrates how to use the SmallPeerInfo API to set and retrieve device metadata for a peer.

```rust
use dittolive_ditto::prelude::*;

# fn example(ditto: &Ditto) -> anyhow::Result<()> {
let small_peer_info = ditto.small_peer_info();

small_peer_info.set_metadata(&serde_json::json!({
    "deviceType": "cashRegister"
}))?;

let metadata: serde_json::Value = small_peer_info.metadata()?;
assert_eq!(metadata["deviceType"].as_str().unwrap(), "cashRegister");
# Ok(())
# }
```

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

### Exporting Logs to File in Rust

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/logger/struct

Example of how to call the `export_to_file` method on a `DittoLogger` instance in Rust to save logs to a specified file path.

```rust
use std::path::Path;
use dittolive_ditto::logger::DittoLogger;

async fn export_logs(logger: &DittoLogger, path: &Path) -> Result<u64, dittolive_ditto::error::DittoError> {
    logger.export_to_file(path).await
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/identity/auth/login_provider

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Builder Initialization

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/mod

Entrypoint for constructing a Ditto instance using the builder pattern, allowing configuration of root and identity.

```rust
/// Entrypoint to constructing `Ditto` with the builder pattern.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use std::sync::Arc;
    /// use dittolive_ditto::prelude::*;
    ///
    /// fn main() -> anyhow::Result<()> {
    ///     let app_id = AppId::from_env("DITTO_APP_ID")?;
    ///     let playground_token = std::env::var("DITTO_PLAYGROUND_TOKEN")?;
    ///     let cloud_sync = true;
    ///     let custom_auth_url = None;
    ///
    ///     // Initialize Ditto
    ///     let ditto = Ditto::builder()
    ///         .with_root(Arc::new(PersistentRoot::from_current_exe()?))
    ///         .with_identity(|ditto_root| {
    ///             identity::OnlinePlayground::new(
    ///                 ditto_root,
    ///                 app_id,
    ///                 playground_token,
    ///                 cloud_sync,
    ///                 custom_auth_url,
    ///             )
    ///         })? 
    ///         .build()?;
    ///
    ///     Ok(())
    /// }
    /// ```
    ///
    /// [See the crate docs for examples of what to do next using `Ditto`][0].
    ///
    /// [0]: crate#playground-quickstart
    pub fn builder() -> DittoBuilder {
        #[allow(deprecated)]
        DittoBuilder::new()
    }
```

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

### Get Observers

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/mod

Provides temporary access to the set of currently registered observers. A read lock is held until the returned value is dropped.

```rust
pub fn observers(&self) -> impl '_ + Deref<Target = SetArc<StoreObserver>> {
    let observers: repr_c::Vec<repr_c::Box<FfiStoreObserver>> = 
        ffi_sdk::dittoffi_store_observers(&self.ditto);
    let observers: Vec<_> = observers.into();
    let observers = observers
        .into_iter()
        .map(|handle: repr_c::Box<FfiStoreObserver>| Arc::new(StoreObserver { handle }))
        .collect::<SetArc<_>>();

    Box::new(observers)
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Rust Mutex Poisoning Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/disk_usage/type

Demonstrates how a Mutex can become poisoned when a thread panics while holding the lock, and how to recover the data.

```rust
use std::sync::{Arc, Mutex};
use std::thread;

let mutex = Arc::new(Mutex::new(0));
let c_mutex = Arc::clone(&mutex);

let _ = thread::spawn(move || {
    let _lock = c_mutex.lock().unwrap();
    panic!(); // the mutex gets poisoned
}).join();

assert_eq!(mutex.is_poisoned(), true);
let x = mutex.lock().unwrap_or_else(|mut e| {
    **e.get_mut() = 1;
    mutex.clear_poison();
    e.into_inner()
});
assert_eq!(mutex.is_poisoned(), false);
assert_eq!(*x, 1);
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/dql/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get Transport Configuration

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/mod

Retrieves a snapshot of the currently configured transports for the Ditto instance. This function serializes configuration data from the underlying SDK.

```rust
/// Returns a snapshot of the currently configured transports.
///
/// # Example
///
/// ```
/// # use dittolive_ditto::prelude::*;
/// # fn example(ditto: &Ditto) {
/// let transport_config = ditto.transport_config();
/// println!("Current transport config: {transport_config:#?}");
/// # }
/// ```
pub fn transport_config(&self) -> TransportConfig {
    let transport_config_cbor = ffi_sdk::dittoffi_ditto_transport_config(&self.ditto);
    serde_cbor::from_slice::<TransportConfig>(transport_config_cbor.as_slice())
        .expect("bug: failed to deserialize TransportConfig from core")
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/attachment/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get SDK Version

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/mod

Provides a way to access the version of the Ditto SDK. It takes a closure that accepts the SDK version string as an argument.

```rust
/// Return the version of the SDK.
pub fn with_sdk_version<R>(ret: impl FnOnce(&'_ str) -> R) -> R {
    ret(ffi_sdk::ditto_get_sdk_version().to_str())
}
```

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

### Ditto Store Main Module

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/dql/query

Documentation for the main store module, including observer patterns for data monitoring.

```rust
mod query_builder;
mod timeseries;
mod transactions;
mod observer;
```

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

### Rust Result into_ok Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/error/type

Demonstrates the use of `into_ok` to extract the Ok value from a Result, which is guaranteed not to panic. This method is useful for infallible Results.

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

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

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/utils/zstr

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Store Transaction Rollback Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/store/transactions/index

Demonstrates a common pitfall where returning a reference to `TransactionCompletionAction::Rollback` results in an implicit commit instead of a rollback.

```rust
// WARNING - this looks like it should roll back but actually commits
let action = ditto
    .store()
    .transaction(async |txn| {
        // do some stuff

        // something bad has happened, we should rollback here
        if something_went_wrong() {
            // WARNING - this does NOT roll back
            return Ok::<_, DittoError>(&TransactionCompletionAction::Rollback);
        }

        Ok::<_, DittoError>(&TransactionCompletionAction::Commit)
    })
    .await
    .unwrap();
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/lib

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/dql/query_result

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/sync/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Transaction Struct and Methods (Rust)

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/transactions/api

Represents an atomic transaction in the Ditto store. Provides methods to get transaction information and execute DQL queries.

```rust
/// Represents a transaction in the Ditto store.
///
/// A [`Transaction`] is used to group multiple operations into a single atomic unit. This ensures
/// that either all operations within the transaction are applied, or none of them are, maintaining
/// the integrity of the data.
///
/// Please consult the documentation of [`ditto.store().transaction()`][Store::transaction] or the
/// [module-level docs][module] for more information on how to create and use transactions. For a
/// complete guide on transactions, please refer to the [Ditto documentation][docs]
///
/// [module]: crate::store::transactions
/// [docs]: https://docs.ditto.live/sdk/latest/crud/transactions
pub struct Transaction {
    pub(crate) ptr: repr_c::Box<ffi_sdk::FfiTransaction>,
}

impl Transaction {
    /// Information about the current transaction.
    pub fn info(&self) -> TransactionInfo {
        self._info()
    }

    /// Executes a DQL query and returns matching items as a [`QueryResult`].
    ///
    /// Note that this method only returns results from the local store without waiting for any
    /// [`SyncSubscription`][crate::sync::SyncSubscription]s to have caught up with the latest
    /// changes. Only use this method if your program must proceed with immediate results. Use a
    /// [`StoreObserver`][crate::store::StoreObserver] (obtained from
    /// [`ditto.store().register_observer()`][crate::store::Store::register_observer]) to receive
    /// updates to query results as soon as they have been synced to this peer.
    pub async fn execute<Q>(&self, query: Q) -> Result<QueryResult, DittoError>
    where
        Q: IntoQuery,
        Q::Args: serde::Serialize,
    {
        self._execute(query).await
    }
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/transactions/impls

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get Connection Type

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/presence/connection_request_handler

Determines the network transport type for the current connection request. It uses the `ConnectionType::from_ffi` helper and the `dittoffi_connection_request_connection_type` function from the `ffi_sdk`.

```rust
pub fn connection_type(&self) -> ConnectionType {
    ConnectionType::from_ffi(::ffi_sdk::dittoffi_connection_request_connection_type(
        &*self.raw,
    ))
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/presence/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get Minimum Log Level

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/logger

Retrieves the current minimum log level for Ditto. Logs exported to files are not constrained by this setting and include all warnings and above.

```rust
/// Get the current minimum log level.
///
/// Logs exported through [`export_to_file()`] are not affected by this
/// setting and include all logs at [`LogLevel::Warning`] and above.
///
pub fn get_minimum_log_level() -> LogLevel {
    ffi_sdk::ditto_logger_minimum_level_get()
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/presence/observer

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Example Usage of IntoQuery

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/dql/query_v2

Demonstrates how to use the IntoQuery trait to create QueryV2 objects from a simple string and from a tuple containing a query string and JSON arguments.

```rust
# use dittolive_ditto::prelude::*;
# use serde_json::json;
let select_query = "SELECT * FROM cars".into_query();

let insert_query = (
    "INSERT INTO cars DOCUMENTS (:doc)",
    json!({"doc": {"foo": "bar"}})
).into_query();
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/utils/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get Collection Names

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/mod

Retrieves a list of all collection names present in the local store. This function iterates through the C-level collection names and converts them into Rust strings.

```rust
/// Returns a list of the names of collections in the local store.
pub fn collection_names(&self) -> Result<Vec<String>, DittoError> {
    let c_collections = { ffi_sdk::ditto_get_collection_names(&*self.ditto).ok()? };

    Ok(c_collections
        .iter()
        .map(|x: &char_p::Box| -> String { x.clone().into_string() })
        .collect())
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/presence/connection_request_handler

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Rust Result into_err Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/error/type

Shows how to use `into_err` to retrieve the Err value from a Result. This method is also infallible and suitable for Results where the Ok type is uninhabited.

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

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

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

### Rust Result transpose() Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/error/type

Shows how the transpose() method converts a Result<Option<T>, E> into an Option<Result<T, E>>. It handles cases where the inner value is Some or None.

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

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

### Ditto Platform Overview and Features

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/index

Provides an overview of the Ditto platform, highlighting its peer-to-peer synchronization capabilities, automatic network transport management (Bluetooth, P2P Wi-Fi, LAN), and data handling essentials. It also links to external resources for deeper dives into specific topics.

```APIDOC
Ditto Platform:
  Description: A cross-platform, peer-to-peer database that allows apps to sync with and without internet connectivity.
  Features:
    - Peer-to-peer synchronization
    - Automatic network transport management (Bluetooth, P2P Wi-Fi, LAN)
    - Direct communication between devices without internet
  Key Topics:
    - Ditto Edge Sync Platform Basics: https://docs.ditto.live/basic/about
    - Mesh Networking 101: https://docs.ditto.live/basic/mesh-networking-101
    - Data-Handling Essentials: https://docs.ditto.live/basic/data-handling-essentials
    - Ditto Query Language (DQL): https://docs.ditto.live/dql
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/disk_usage/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Rust Result cloned() Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/error/type

Demonstrates the usage of the cloned() method on a mutable reference within a Result. This method clones the inner value if it implements the Clone trait.

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

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/transport/v3/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get Peer Key String

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/presence/connection_request_handler

Retrieves the unique peer key of the remote peer as an `Arc<str>`. This function utilizes `dittoffi_connection_request_peer_key_string` from the `ffi_sdk` and caches the result for performance.

```rust
pub fn peer_key_string(&self) -> Arc<str> {
    self.cached_peer_key
        .get_or_init(|| {
            ffi_sdk::dittoffi_connection_request_peer_key_string(&*self.raw)
                .to_str()
                .into()
        })
        .retain()
}
```

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

### Rust CompatExt Trait Implementations

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/small_peer_info/enum

Provides compatibility adapters for types using the `CompatExt` trait. This includes methods to get adapters for owned values, shared references, and mutable references.

```rust
fn compat(self) -> Compat<T>;
fn compat_ref(&self) -> Compat<&T>;
fn compat_mut(&mut self) -> Compat<&mut T>;
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/sync/sync_subscription

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Synchronization Control

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/mod

Provides methods to control the network synchronization behavior of a Ditto instance. This includes starting, stopping, and checking the status of synchronization across transports.

```rust
/// Starts the network transports. Ditto will connect to other devices.
///
/// By default, Ditto will enable all peer-to-peer transport types.
/// The network configuration can be customized using [`set_transport_config`].
///
/// Performance of initial sync when bootstrapping a new peer can be improved
/// by calling [`disable_sync_with_v3`] before calling `start_sync`. Only
/// do this when all peers in the mesh are known to be running Ditto v4 or higher.
///
/// [`set_transport_config`]: Self::set_transport_config
/// [`disable_sync_with_v3`]: Self::disable_sync_with_v3
pub fn start_sync(&self) -> Result<(), DittoError> {
    let result = ffi_sdk::dittoffi_ditto_try_start_sync(&self.ditto);
    if let Some(error) = result.error {
        if ffi_sdk::dittoffi_error_code(&*error) == ffi_sdk::FfiErrorCode::ActivationNotActivated {
            return Err(ErrorKind::NotActivated.into());
        }
        return Err(DittoError::from(error));
    }
    Ok(())
}

/// Stop syncing on all transports.
///
/// You may continue to use the Ditto store locally but no data
/// will sync to or from other devices.
pub fn stop_sync(&self) {
    ffi_sdk::dittoffi_ditto_stop_sync(&self.ditto);
}

/// Returns `true` if sync is currently active, otherwise returns `false`.
///
/// Use [`Ditto::start_sync`] to activate and [`Ditto::stop_sync`] to deactivate sync.
pub fn is_sync_active(&self) -> bool {
    ffi_sdk::dittoffi_ditto_is_sync_active(&self.ditto)
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/fs

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Rust Result copied() Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/error/type

Illustrates the copied() method for Result<&mut T, E> where T implements the Copy trait. It maps the Result to a Result<T, E> by copying the inner value.

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

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/identity/auth/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get Current Presence Graph

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/presence/mod

Retrieves an immediate snapshot of the Ditto mesh's peer connections. This graph includes information about the local peer and all connected remote peers.

```rust
use dittolive_ditto::prelude::*;

fn example(ditto: &Ditto) -> anyhow::Result<()> {
    // Get an immediate `PresenceGraph` showing current connections
    let graph = ditto.presence().graph();
    let my_key = &graph.local_peer.peer_key_string;
    let my_connections = &graph.local_peer.connections;

    Ok(())
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/ditto/builder

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get Mutable Values Iterator for Serde JSON Map

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/presence/type

Retrieves an iterator that allows mutable access to the values within a serde_json::Map. This is useful for modifying values in place.

```rust
pub fn values_mut(&mut self) -> ValuesMut<'_>
```

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

### ManuallyDropMut Trait Implementation

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/presence/enum

Implements the `ManuallyDropMut` trait for any type `T`. It defines an associated type `Ret` as `ManuallyDrop<T>` and provides a `manually_drop_mut` method to get a mutable reference to the `ManuallyDrop` wrapper.

```rust
impl<T> ManuallyDropMut for T {
    type Ret = ManuallyDrop<T>;
    fn manually_drop_mut<'__>(&'__ mut self) -> &'__ mut ManuallyDrop<T>;
}
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/timeseries/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/identity/auth/authenticator

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Register Observer With Signal Next V2

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/mod

Installs a store observer that triggers a change handler when query results change. The handler controls callback frequency using `signal_next`.

```rust
pub fn register_observer_with_signal_next_v2<Q, F>(
    &self,
    query: Q,
    on_change: F,
) -> Result<Arc<StoreObserver>, DittoError>
where
    Q: IntoQuery,
    Q::Args: Serialize,
    F: ChangeHandlerWithSignalNext,
{
    let ditto = Ditto::upgrade(&self.weak_ditto_fields)?;
    let query = query.into_query()?;

    let new_obs = Arc::new(StoreObserver::with_signal_next(
        &ditto,
        &query.string,
        query.args_cbor.as_deref(),
        on_change,
    )?);
    Ok(new_obs)
}
```

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

### Ditto Transaction with Rollback Example

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/transactions/mod

Demonstrates how to use the `transaction` method in the Ditto Rust SDK. It includes a warning that a specific condition might not actually roll back the transaction as expected.

```rust
# use dittolive_ditto::prelude::*
# #[tokio::main]
# async fn main() {
# let ditto: Ditto = todo!();
# fn something_went_wrong() -> bool { true }
# // WARNING - this looks like it should roll back but actually commits
# let action = ditto
#     .store()
#     .transaction(async |txn| {
#         // do some stuff
#
#         // something bad has happened, we should rollback here
#         if something_went_wrong() {
#             // WARNING - this does NOT roll back
#             return Ok::<_, DittoError>(&TransactionCompletionAction::Rollback);
#         }
#
#         Ok::<_, DittoError>(&TransactionCompletionAction::Commit)
#     })
#     .await
#     .unwrap();
# }
```

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

### Ditto Small Peer Info API

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/small_peer_info/mod

Provides methods to manage and retrieve small peer information, including enabling/disabling collection, setting and getting metadata, and configuring synchronization scope.

```APIDOC
SmallPeerInfo:
  __init__(ditto: Arc<ffi_sdk::BoxedDitto>)
    ditto: Handle to the live Ditto instance

  is_enabled() -> bool
    Indicates whether small peer info collection is currently enabled, defaults to `true`.
    Small peer info consists of information scraped into a system collection at repeated intervals and synced to the Big Peer for device dashboard and debugging purposes.
    Note: whether the background ingestion process is enabled or not is a separate decision to whether this information is allowed to sync to other peers (including the big peer). This is controlled by [`DittoSmallPeerInfoSyncScope`].

  set_enabled(enabled: bool)
    Sets whether small peer info collection is currently enabled.

  metadata() -> anyhow::Result<serde_json::Value>
    Retrieves the current small peer metadata.

  set_metadata(metadata: serde_json::Value) -> anyhow::Result<()>
    Sets the small peer metadata.

  sync_scope() -> DittoSmallPeerInfoSyncScope
    Returns the current sync scope for small peer info.

  set_sync_scope(sync_scope: DittoSmallPeerInfoSyncScope)
    Sets the sync scope for small peer info.

DittoSmallPeerInfoSyncScope:
  BigPeerOnly: Replicates small peer info only to the Big Peer.
  AllPeers: Replicates small peer info to all connected peers.
  Disabled: Disables replication of small peer info to any peers.
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/store/transactions/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get Identity Service Metadata as JsonObject

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/presence/connection_request_handler

Retrieves the identity service metadata for a remote peer, deserialized into an `Arc<JsonObject>`. This method caches the metadata for efficiency and relies on `identity_service_metadata_serde` for deserialization.

```rust
pub fn identity_service_metadata(&self) -> Arc<JsonObject> {
    self.cached_identity_service_metadata
        .get_or_init(|| {
            Arc::new(
                self.identity_service_metadata_serde()
                    .expect("incorrect json from `dittoffi`"),
            )
        })
        .retain()
}
```

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

### Ditto Core Builder and Module

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/identity/auth/login_provider

Core functionalities of the Ditto library, including the builder pattern for configuring Ditto instances. This is fundamental for setting up and initializing Ditto services.

```rust
builder.rs
mod.rs
```

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

### ManuallyDropMut Trait Implementation (Rust)

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/prelude/struct

Implementation of the ManuallyDropMut trait for a generic type T. It defines an associated type Ret which is ManuallyDrop<T> and provides a method to get a mutable reference to ManuallyDrop<T>.

```rust
type Ret = [ManuallyDrop](https://doc.rust-lang.org/1.85.0/core/mem/manually_drop/struct.ManuallyDrop.html)<T>

fn manually_drop_mut<'__>(&'__ mut self) -> &'__ mut [ManuallyDrop](https://doc.rust-lang.org/1.85.0/core/mem/manually_drop/struct.ManuallyDrop.html)<T>
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/identity/mod

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Ditto Query Builder Core and Subscription

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/transport/transport_config

Documentation for the core query builder module and subscription handling. This includes the main query builder logic and mechanisms for subscribing to data changes.

```rust
mod.rs
subscription.rs
update.rs
```

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

### Get and Cache Peer Metadata

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/presence/mod

Retrieves the peer's metadata, deserializing it from a JSON string and caching the result for efficiency. The metadata is stored in an `Arc<JsonObject>` and updated only when the underlying JSON string changes.

```rust
pub fn peer_metadata(&self) -> Arc<JsonObject> {
    let json_str = self.peer_metadata_json_str();
    let mut cache = self
        .peer_metadata_cache
        .lock()
        .unwrap_or_else(|it| it.into_inner());
    if json_str != cache.json_str {
        *cache = PeerMetadataCache {
            value: Arc::new(
                ::serde_json::from_str(&json_str).expect("incorrect json from `dittoffi`"),
            ),
            json_str,
        };
    }
    cache.value.retain()
}
```

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

### Ditto Store Main Module

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/utils/prelude

Documentation for the main store module, including observer patterns for data monitoring.

```rust
mod query_builder;
mod timeseries;
mod transactions;
mod observer;
```

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

### Get Mutated Document IDs

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/src/dittolive_ditto/dql/query_result

Retrieves a vector of `DocumentId`s for documents that were modified by the DQL query. Returns an empty vector if no documents were mutated. Note that these IDs are not cached and should be stored if needed for longer durations.

```rust
/// IDs of documents that were mutated by the DQL query. Empty
/// array if no documents have been mutated.
///
/// > Important: The returned document IDs are not cached, make sure to call
/// > this method once and keep the return value for as long as needed.
pub fn mutated_document_ids(&self) -> Vec<DocumentId> {
    let mutated_document_number =
        ffi_sdk::dittoffi_query_result_mutated_document_id_count(&self.raw);

    (0..mutated_document_number)
        .map(|idx| ffi_sdk::dittoffi_query_result_mutated_document_id_at(&self.raw, idx))
        .map(|raw_slice| DocumentId::from(Box::<[u8]>::from(raw_slice)))
        .collect()
}
```

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

### Rust ManuallyDropMut Trait Implementation for DittoBuilder

Source: https://software.ditto.live/rust/Ditto/4.11.0/x86_64-unknown-linux-gnu/docs/dittolive_ditto/struct

Implements the `ManuallyDropMut` trait for `T`. It defines an associated type `Ret` as `ManuallyDrop<T>` and provides a `manually_drop_mut` method to get a mutable reference to the `ManuallyDrop` wrapper.

```rust
impl<T> ManuallyDropMut for T {
    type Ret = ManuallyDrop<T>;

    fn manually_drop_mut<'__>(&'__ mut self) -> &'__ mut ManuallyDrop<T> {
        // ... implementation details ...
    }
}
```
Tokens:
Raw