Fields§
§hash_function: fn(_: &str) -> u64
Implementations§
source§impl<'a> Client
impl<'a> Client
pub fn new<C: Connectable<'a>>(target: C) -> Result<Self, MemcacheError>
sourcepub fn set_read_timeout(
&mut self,
timeout: Option<Duration>
) -> Result<(), MemcacheError>
pub fn set_read_timeout(
&mut self,
timeout: Option<Duration>
) -> Result<(), MemcacheError>
Set the socket read timeout for tcp conections.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.set_read_timeout(Some(::std::time::Duration::from_secs(3))).unwrap();
sourcepub fn set_write_timeout(
&mut self,
timeout: Option<Duration>
) -> Result<(), MemcacheError>
pub fn set_write_timeout(
&mut self,
timeout: Option<Duration>
) -> Result<(), MemcacheError>
Set the socket write timeout for tcp conections.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.set_write_timeout(Some(::std::time::Duration::from_secs(3))).unwrap();
sourcepub fn version(&mut self) -> Result<Vec<(String, String)>, MemcacheError>
pub fn version(&mut self) -> Result<Vec<(String, String)>, MemcacheError>
Get the memcached server version.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.version().unwrap();
sourcepub fn flush(&mut self) -> Result<(), MemcacheError>
pub fn flush(&mut self) -> Result<(), MemcacheError>
Flush all cache on memcached server immediately.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.flush().unwrap();
sourcepub fn flush_with_delay(&mut self, delay: u32) -> Result<(), MemcacheError>
pub fn flush_with_delay(&mut self, delay: u32) -> Result<(), MemcacheError>
Flush all cache on memcached server with a delay seconds.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.flush_with_delay(10).unwrap();
sourcepub fn get<V: FromMemcacheValue>(
&mut self,
key: &str
) -> Result<Option<V>, MemcacheError>
pub fn get<V: FromMemcacheValue>(
&mut self,
key: &str
) -> Result<Option<V>, MemcacheError>
Get a key from memcached server.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
let _: Option<String> = client.get("foo").unwrap();
sourcepub fn gets<V: FromMemcacheValue>(
&mut self,
keys: Vec<&str>
) -> Result<HashMap<String, V>, MemcacheError>
pub fn gets<V: FromMemcacheValue>(
&mut self,
keys: Vec<&str>
) -> Result<HashMap<String, V>, MemcacheError>
Get multiple keys from memcached server. Using this function instead of calling get
multiple times can reduce netwark workloads.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.set("foo", "42", 0).unwrap();
let result: std::collections::HashMap<String, String> = client.gets(vec!["foo", "bar", "baz"]).unwrap();
assert_eq!(result.len(), 1);
assert_eq!(result["foo"], "42");
sourcepub fn set<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V,
expiration: u32
) -> Result<(), MemcacheError>
pub fn set<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V,
expiration: u32
) -> Result<(), MemcacheError>
Set a key with associate value into memcached server with expiration seconds.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.set("foo", "bar", 10).unwrap();
sourcepub fn add<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V,
expiration: u32
) -> Result<(), MemcacheError>
pub fn add<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V,
expiration: u32
) -> Result<(), MemcacheError>
Add a key with associate value into memcached server with expiration seconds.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
let key = "add_test";
client.delete(key).unwrap();
client.add(key, "bar", 100000000).unwrap();
sourcepub fn replace<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V,
expiration: u32
) -> Result<(), MemcacheError>
pub fn replace<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V,
expiration: u32
) -> Result<(), MemcacheError>
Replace a key with associate value into memcached server with expiration seconds.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
let key = "replace_test";
client.set(key, "bar", 0).unwrap();
client.replace(key, "baz", 100000000).unwrap();
sourcepub fn append<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V
) -> Result<(), MemcacheError>
pub fn append<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V
) -> Result<(), MemcacheError>
Append value to the key.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
let key = "key_to_append";
client.set(key, "hello", 0).unwrap();
client.append(key, ", world!").unwrap();
let result: String = client.get(key).unwrap().unwrap();
assert_eq!(result, "hello, world!");
sourcepub fn prepend<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V
) -> Result<(), MemcacheError>
pub fn prepend<V: ToMemcacheValue<Connection>>(
&mut self,
key: &str,
value: V
) -> Result<(), MemcacheError>
Prepend value to the key.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
let key = "key_to_append";
client.set(key, "world!", 0).unwrap();
client.prepend(key, "hello, ").unwrap();
let result: String = client.get(key).unwrap().unwrap();
assert_eq!(result, "hello, world!");
sourcepub fn delete(&mut self, key: &str) -> Result<bool, MemcacheError>
pub fn delete(&mut self, key: &str) -> Result<bool, MemcacheError>
Delete a key from memcached server.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.delete("foo").unwrap();
sourcepub fn increment(&mut self, key: &str, amount: u64) -> Result<u64, MemcacheError>
pub fn increment(&mut self, key: &str, amount: u64) -> Result<u64, MemcacheError>
Increment the value with amount.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.increment("counter", 42).unwrap();
sourcepub fn decrement(&mut self, key: &str, amount: u64) -> Result<u64, MemcacheError>
pub fn decrement(&mut self, key: &str, amount: u64) -> Result<u64, MemcacheError>
Decrement the value with amount.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
client.decrement("counter", 42).unwrap();
sourcepub fn touch(&mut self, key: &str, expiration: u32) -> Result<bool, MemcacheError>
pub fn touch(&mut self, key: &str, expiration: u32) -> Result<bool, MemcacheError>
Set a new expiration time for a exist key.
Example:
let mut client = memcache::Client::new("memcache://localhost:12345").unwrap();
assert_eq!(client.touch("not_exists_key", 12345).unwrap(), false);
client.set("foo", "bar", 123).unwrap();
assert_eq!(client.touch("foo", 12345).unwrap(), true);