Struct Connection 

pub struct Connection {
    pub inner: ClientService<TcpStream, MemcachedProto>,
}

Fields

inner: ClientService<TcpStream, MemcachedProto>

Implementations

impl Connection

pub fn get<K, R>(&self, key: &K) -> BoxFuture<R, MemcacheError>

where K: AsArgument, R: FromResponse,

Examples found in repository

examples/simple.rs (line 18)

fn main() {
    let addr = "127.0.0.1:11211".parse().unwrap();
    let mut lp = Core::new().unwrap();

    let res = Client::connect(&addr, &lp.handle())
        .and_then(|conn| {
            conn.set(b"Hello", b"world", 3600)
                .and_then(move |_| {
                    conn.get(b"Hello")
                })
        });

    let val: Vec<u8> = lp.run(res).unwrap();
    println!("{:?}", val);
}

pub fn set<K, V, E>( &self, key: &K, value: &V, expiration: E, ) -> BoxFuture<(), MemcacheError>

where K: AsArgument, V: AsArgument, E: Expiration,

Examples found in repository

examples/simple.rs (line 16)

fn main() {
    let addr = "127.0.0.1:11211".parse().unwrap();
    let mut lp = Core::new().unwrap();

    let res = Client::connect(&addr, &lp.handle())
        .and_then(|conn| {
            conn.set(b"Hello", b"world", 3600)
                .and_then(move |_| {
                    conn.get(b"Hello")
                })
        });

    let val: Vec<u8> = lp.run(res).unwrap();
    println!("{:?}", val);
}

pub fn add<K, V, E>( &self, key: &K, value: &V, expiration: E, ) -> BoxFuture<(), MemcacheError>

where K: AsArgument, V: AsArgument, E: Expiration,

pub fn send(&self, req: Request) -> BoxFuture<Response, MemcacheError>

Send Request to server.

This method can be used if you need to send a rich request and there is no available wrapper method.

Trait Implementations

impl Service for Connection

type Request = Request

Requests handled by the service.

type Response = Response

Responses given by the service.

type Error = MemcacheError

Errors produced by the service.

type Future = Box<dyn Future<Item = <Connection as Service>::Response, Error = <Connection as Service>::Error> + Send>

The future response value.

fn call(&self, req: Self::Request) -> Self::Future

Process the request and return the response asynchronously.