liboxia 0.0.1

Liboxia is a Rust library designed for both native Rust applications and for integration with other languages via its C Foreign Function Interface (FFI). It serves as a client SDK for Oxia, a distributed key-value store, enabling robust, asynchronous data operations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

use crate::address::ensure_protocol;
use crate::client::{Client, ClientImpl};
use crate::client_options::OxiaClientOptions;
use crate::errors::OxiaError;
use std::time::Duration;

#[derive(Debug, Clone, Default)]
pub struct OxiaClientBuilder {
    service_address: Option<String>,
    namespace: Option<String>,
    identity: Option<String>,
    batch_linger: Option<Duration>,
    batch_max_size: Option<u32>,
}

impl OxiaClientBuilder {
    pub fn new() -> Self {
        OxiaClientBuilder::default()
    }

    pub fn service_address(mut self, service_address: String) -> Self {
        self.service_address = Some(ensure_protocol(service_address));
        self
    }

    pub fn namespace(mut self, namespace: String) -> Self {
        self.namespace = Some(namespace);
        self
    }

    pub fn identity(mut self, identity: String) -> Self {
        self.identity = Some(identity);
        self
    }

    pub fn batch_linger(mut self, batch_linger: Duration) -> Self {
        self.batch_linger = Some(batch_linger);
        self
    }

    pub fn batch_max_size(mut self, batch_max_size: u32) -> Self {
        self.batch_max_size = Some(batch_max_size);
        self
    }

    pub async fn build(self) -> Result<impl Client, OxiaError> {
        let mut options = OxiaClientOptions::default();
        if let Some(service_address) = self.service_address {
            options.service_address = service_address
        }
        if let Some(namespace) = self.namespace {
            options.namespace = namespace;
        }
        if let Some(identity) = self.identity {
            options.identity = identity;
        }
        if let Some(batch_linger) = self.batch_linger {
            options.batch_linger = batch_linger;
        }
        if let Some(batch_max_size) = self.batch_max_size {
            options.batch_max_size = batch_max_size;
        }
        ClientImpl::new(options).await
    }
}