memcached/
lib.rs

1//!
2
3#![deny(
4    missing_docs,
5    bare_trait_objects,
6    missing_copy_implementations,
7    single_use_lifetimes,
8    trivial_numeric_casts,
9    unreachable_pub,
10    unused_extern_crates,
11    unused_import_braces,
12    unused_qualifications,
13    unused_results,
14    variant_size_differences,
15    // unsafe_code,
16    trivial_casts,
17    // missing_debug_implementations,
18    // 把所有warnings级别的改为deny
19    warnings,
20    clippy::all,
21    clippy::correctness,
22    clippy::restriction,
23    clippy::style,
24    clippy::complexity,
25    clippy::perf,
26    clippy::cargo,
27    // clippy::nursery ,
28    clippy::pedantic
29)]
30#![allow(
31    clippy::missing_inline_in_public_items,
32    clippy::missing_errors_doc,
33    clippy::module_name_repetitions,
34    clippy::missing_docs_in_private_items,
35    clippy::implicit_return,
36    clippy::as_conversions,
37    clippy::dbg_macro,
38    clippy::pub_enum_variant_names,
39    clippy::multiple_crate_versions,
40    clippy::doc_markdown,
41    clippy::cast_possible_truncation, //
42    clippy::integer_arithmetic, //
43    trivial_casts,
44)]
45
46mod client;
47mod connection;
48/// memcached error
49pub mod error;
50mod protocol;
51mod stream;
52
53/// memcached result
54pub type Result<T> = std::result::Result<T, error::MemcachedError>;
55pub use client::{connectable::Connectable, Client};
56
57/// Create a memcached client instance and connect to memcached server.
58/// The default connection pool has only one connection.
59///
60/// ## Example
61///
62/// ```rust
63/// let client = memcached::connect("memcache://127.0.0.1:12345").unwrap();
64/// ```
65pub fn connect(url: &str) -> Result<Client> {
66    Client::connect(url)
67}
68
69/// Create a client, you can specify multiple url, connection pool size, key hash connection pool function.
70///
71/// ## Example
72///
73/// ```rust
74/// let client = memcached::Client::connect_with(vec!["memcache://127.0.0.1:12345".to_owned()], 2, |s|1).unwrap();
75/// ```
76pub fn connect_withconnect_with(
77    urls: Vec<String>,
78    pool_size: u64,
79    hash_function: fn(&str) -> u64,
80) -> Result<Client> {
81    Client::connect_with(urls, pool_size, hash_function)
82}
83
84#[allow(clippy::result_unwrap_used, clippy::option_unwrap_used)]
85#[cfg(test)]
86mod tests {
87    #[async_std::test]
88    async fn it_works() -> crate::Result<()> {
89        let client = crate::connect("memcache://127.0.0.1:12345")?;
90        client
91            .set::<&[u8], _>("abcd", &[1, 2, 3, 4, 5], 100)
92            .await?;
93        let t: Option<Vec<u8>> = client.get("abcd").await?;
94        assert_eq!(t.unwrap(), vec![1, 2, 3, 4, 5]);
95        client.set("abc", "hello", 100).await?;
96        let t: Option<String> = client.get("abc").await?;
97        assert_eq!(t, Some("hello".to_owned()));
98        Ok(())
99    }
100}