sled_web::client

Struct Client

Source 
pub struct Client { /* private fields */ }
Expand description

A hyper Client wrapper that simplifies communication with the sled Tree server.

Implementations§

Source§

impl Client

Source

pub fn new(uri: Uri) -> Self

Create a new Client pointing towards the given Uri.

The Uri should contain the Scheme and Authority parts of the URI but not the following path. This following path will be created as necessary within each of the request calls.

Examples found in repository?
examples/client.rs (line 8)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn get(&self, key: Key) -> impl Future<Item = Option<Value>, Error = Error>

A method for performing the Get request.

Given the key for an entry in the sled::Tree, produce a Future with the value.

Examples found in repository?
examples/client.rs (line 11)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn del(&self, key: Key) -> impl Future<Item = Option<Value>, Error = Error>

A method for performing the Del request.

Given the key for an entry in the sled::Tree, delete the entry and return a Future with the removed value.

Source

pub fn set( &self, key: Key, value: Value, ) -> impl Future<Item = (), Error = Error>

A method for performing the Set request.

Send the given key and value to the database for insertion into the sled::Tree.

Examples found in repository?
examples/client.rs (line 19)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn cas( &self, key: Key, old: Option<Value>, new: Option<Value>, ) -> impl Future<Item = Result<(), Option<Value>>, Error = Error>

A method for performing the Cas request.

Compare and swap. Capable of unique creation, conditional modification, or deletion.

If old is None, this will only set the value if it doesn’t exist yet. If new is None, will delete the value if old is correct. If both old and new are Some, will modify the value if old is correct.

If Tree is read-only, will do nothing.

Source

pub fn merge( &self, key: Key, value: Value, ) -> impl Future<Item = (), Error = Error>

A method for performing the Merge request.

Merge a new value into the total state for a key.

Source

pub fn flush(&self) -> impl Future<Item = (), Error = Error>

A method for performing the Flush request.

Flushes any pending IO buffers to disk to ensure durability.

Source

pub fn iter(&self) -> impl Stream<Item = Entry, Error = Error>

A method for performing the Iter request.

The result is a Stream of ordered key value pairs.

Examples found in repository?
examples/client.rs (line 32)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn scan(&self, key: Key) -> impl Stream<Item = Entry, Error = Error>

A method for performing the Scan request.

The result is a Stream of ordered key value pairs, starting from the given key.

Examples found in repository?
examples/client.rs (line 40)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn scan_range( &self, start: Key, end: Key, ) -> impl Stream<Item = Entry, Error = Error>

A method for performing the Scan request.

The result is a Stream of all ordered key value pairs within the given key range.

Examples found in repository?
examples/client.rs (line 48)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn max(&self) -> impl Future<Item = Option<Entry>, Error = Error>

A method for perfomring the Max request.

The result is a Future yielding the greatest entry in the sled::Tree.

Returns None if there are no entries within the tree.

Examples found in repository?
examples/client.rs (line 56)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn pred(&self, key: Key) -> impl Future<Item = Option<Entry>, Error = Error>

A method for performing the Pred request.

Given the key for an entry in the sled::Tree, produce a Future with the preceding entry.

Examples found in repository?
examples/client.rs (line 61)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn pred_incl( &self, key: Key, ) -> impl Future<Item = Option<Entry>, Error = Error>

A method for performing the PredIncl request.

Given the key for an entry in the sled::Tree, produce a Future with the preceding entry or the entry associated with the key if there is one.

Examples found in repository?
examples/client.rs (line 66)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn succ(&self, key: Key) -> impl Future<Item = Option<Entry>, Error = Error>

A method for performing the Succ request.

Given the key for an entry in the sled::Tree, produce a Future with the following entry.

Examples found in repository?
examples/client.rs (line 71)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}
Source

pub fn succ_incl( &self, key: Key, ) -> impl Future<Item = Option<Entry>, Error = Error>

A method for performing the SuccIncl request.

Given the key for an entry in the sled::Tree, produce a Future with the following entry or the entry associated with the key if there is one.

Examples found in repository?
examples/client.rs (line 76)
7fn main() {
8    let client = sled_web::Client::new("http://localhost:3000".parse().unwrap());
9
10    let get_a = client
11        .get(vec![6])
12        .map(|v| {
13            println!("Entry `6` was `None`, as expected");
14            assert!(v.is_none())
15        })
16        .map_err(|e| eprintln!("{}", e));
17
18    let set = client
19        .set(vec![6], vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
20        .map(|_| println!("Entry `6` successfully set"))
21        .map_err(|e| eprintln!("{}", e));
22
23    let get_b = client
24        .get(vec![6])
25        .map(|v| {
26            assert!(v.is_some());
27            println!("Successfully retrieved `6`: {:?}", v)
28        })
29        .map_err(|e| eprintln!("{}", e));
30
31    let iter = client
32        .iter()
33        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
34        .map_err(|e| eprintln!("Error: {}", e))
35        .collect()
36        .map(|_| ())
37        .map_err(|_| ());
38
39    let scan = client
40        .scan(vec![3])
41        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
42        .map_err(|e| eprintln!("Error: {}", e))
43        .collect()
44        .map(|_| ())
45        .map_err(|_| ());
46
47    let scan_range = client
48        .scan_range(vec![2], vec![5])
49        .map(|(k, v)| println!("  ({:?}, {:?})", k, v))
50        .map_err(|e| eprintln!("Error: {}", e))
51        .collect()
52        .map(|_| ())
53        .map_err(|_| ());
54
55    let max = client
56        .max()
57        .map(|entry| println!("Max: {:?}", entry))
58        .map_err(|e| eprintln!("Error: {}", e));
59
60    let pred = client
61        .pred(vec![4])
62        .map(|entry| println!("Pred to [4]: {:?}", entry))
63        .map_err(|e| eprintln!("Error: {}", e));
64
65    let pred_incl = client
66        .pred_incl(vec![4])
67        .map(|entry| println!("PredIncl to [4]: {:?}", entry))
68        .map_err(|e| eprintln!("Error: {}", e));
69
70    let succ = client
71        .succ(vec![2])
72        .map(|entry| println!("Succ to [2]: {:?}", entry))
73        .map_err(|e| eprintln!("Error: {}", e));
74
75    let succ_incl = client
76        .succ_incl(vec![2])
77        .map(|entry| println!("SuccIncl to [2]: {:?}", entry))
78        .map_err(|e| eprintln!("Error: {}", e));
79
80    hyper::rt::run({
81        get_a
82            .then(|_| set)
83            .then(|_| get_b)
84            .then(|_| {
85                println!("Iter all elements...");
86                iter
87            })
88            .then(|_| {
89                println!("Scan elements starting from `vec![3]`");
90                scan
91            })
92            .then(|_| {
93                println!("Scan range elements starting from `vec![2]` to `vec![5]`");
94                scan_range
95            })
96            .then(|_| max)
97            .then(|_| pred)
98            .then(|_| pred_incl)
99            .then(|_| succ)
100            .then(|_| succ_incl)
101    });
102}

Trait Implementations§

Source§

impl Clone for Client

Source§

fn clone(&self) -> Client

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for Client

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl !Freeze for Client

§

impl !RefUnwindSafe for Client

§

impl Send for Client

§

impl Sync for Client

§

impl Unpin for Client

§

impl !UnwindSafe for Client

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.