Trait Adapter

pub trait Adapter: Send + Sync {
    // Required methods
    fn list(
        &self,
        params: &JsonObject,
    ) -> BoxFuture<JsonObject, (ErrorKind, JsonValue)>;
    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)>;

    // Provided method
    fn handle(&self, req: Request) -> BoxFuture<Reply, Error> { ... }
}

Converts a Request to a static Reply from a database.

An Adapter talks to a database. If you’re using an Adapter, and not implementing your own, you probably just want to use the handle function. By implementing the five functions list, get, post, patch and delete, an Adapter gets the handle function for free.

You most likely won’t want to implement your own Adapter, since these are generic and don’t contain project-specific code. Backtalk implements memory::MemoryAdapter for development, but you will hopefully eventually be able to find third-party adapters for various databases in other crates.

Required Methods

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

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)>

Provided Methods

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.

Examples found in repository

examples/3.rs (line 12)

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 16)

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 12)

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 22)

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 28)

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 29)

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");
}

Implementors

impl Adapter for MemoryAdapter