Struct MemoryAdapter

pub struct MemoryAdapter { /* private fields */ }

Implementations

impl MemoryAdapter

pub fn new() -> MemoryAdapter

Examples found in repository

examples/3.rs (line 10)

fn main() {
  let mut server = Server::new();
  let database = memory::MemoryAdapter::new();
  server.resource("/cats", move |req: Request| {
    database.handle(req)
  });
  server.listen("127.0.0.1:3000");
}

examples/5.rs (line 11)

fn main() {
  let mut server = Server::new();
  use std::sync::Arc;
  let database = Arc::new(memory::MemoryAdapter::new());
  server.resource("/cats", move |req: Request| {
    let database1 = database.clone();
    req
      .and_then(move |req| {
        database1.handle(req)
      })
  });
  server.listen("127.0.0.1:3000");
}

examples/4.rs (line 10)

fn main() {
  let mut server = Server::new();
  let database = memory::MemoryAdapter::new();
  server.resource("/cats", move |req: Request| {
    database.handle(req).and_then(|mut reply| {
      {
          let mut data = reply.data_mut().unwrap();
          data.insert("example".to_string(), json!("data"));
      }
      reply
    })
  });
  server.listen("127.0.0.1:3000");
}

examples/7.rs (line 12)

fn main() {
  let mut server = Server::new();
  use std::sync::Arc;
  use std::ops::Deref;
  let database = Arc::new(memory::MemoryAdapter::new());
  let chan = Arc::new(memory::MemoryChannel::new());
  server.resource("/cats", move |req: Request| {
    let database1 = database.clone();
    let chan1 = chan.clone();
    let chan2 = chan.clone();
    req
      .and_then(move |req| {
        match req.method() {
          Method::Listen => chan1.handle(req),
          _ => database1.handle(req),
        }
      })
      .and_then(move |reply| {
        util::send_from_reply(reply, chan2.deref())
      })
  });
  server.listen("127.0.0.1:3000");
}

examples/6.rs (line 11)

fn main() {
  let mut server = Server::new();
  use std::sync::Arc;
  let database = Arc::new(memory::MemoryAdapter::new());
  server.resource("/cats", move |req: Request| {
    let database1 = database.clone();
    req
      .and_then(move |req| {
        if req.method() == Method::Delete {
          if let &JsonValue::String(ref password) = req.param("password") {
            if password != "meow" {
              return Error::forbidden("incorrect password");
            }
          } else {
            return Error::unauthorized("please provide a password");
          }
        }
        req.boxed()
      })
      .and_then(move |req| {
        database1.handle(req)
      })
  });
  server.listen("127.0.0.1:3000");
}

examples/hello.rs (line 12)

fn main() {
  let mut s = Server::new();
  s.resource("/meow", |_req: Request| {
    Error::forbidden("not allowed! sorry.")
  });
  let adapter = Arc::new(memory::MemoryAdapter::new());
  let channel = Arc::new(memory::MemoryChannel::new());
  s.resource("/hello2", move |req: Request| {
    req
      .and_then(|req| {
        req.into_reply(JsonObject::new())
      })
  });
  s.resource("/hello", move |req: Request| {
    let adapter = adapter.clone();
    let channel1 = channel.clone();
    // let channel2 = channel.clone();
    req
      .and_then(move |req| {
        match req.method().clone() {
          Method::Action(_) => Error::forbidden("not allowed! sorry."),
          Method::Listen => channel1.handle(req),
          _ => adapter.handle(req),
        }
      })
      // .and_then(move |reply| { util::send_from_reply(reply, channel2.deref()) })
  });
  s.listen("127.0.0.1:3000");
}

Trait Implementations

impl Adapter for MemoryAdapter

fn list( &self, params: &JsonObject, ) -> BoxFuture<JsonObject, (ErrorKind, JsonValue)>

currently this function only supports equality matching — we’d probably want to add more kinds of matching and querying in the future, maybe by building into query object

fn get( &self, id: &str, _params: &JsonObject, ) -> BoxFuture<JsonObject, (ErrorKind, JsonValue)>

fn post( &self, data: &JsonObject, _params: &JsonObject, ) -> BoxFuture<JsonObject, (ErrorKind, JsonValue)>

fn patch( &self, id: &str, data: &JsonObject, _params: &JsonObject, ) -> BoxFuture<JsonObject, (ErrorKind, JsonValue)>

fn delete( &self, id: &str, _params: &JsonObject, ) -> BoxFuture<JsonObject, (ErrorKind, JsonValue)>

fn handle(&self, req: Request) -> BoxFuture<Reply, Error>

Takes a Request, passes it to the appropriate function, and turns the response into a proper Reply future. If you’re using an Adapter in your webapp, this is the function you want to call.