Struct Request

pub struct Request { /* private fields */ }

A request containing data from the client.

Implementations

impl Request

pub fn new( resource: String, method: Method, id: Option<String>, data: JsonObject, params: JsonObject, ) -> Request

pub fn into_reply(self, reply: JsonObject) -> Reply

Examples found in repository

examples/hello.rs (line 17)

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

pub fn method(&self) -> Method

Examples found in repository

examples/7.rs (line 20)

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

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

pub fn resource(&self) -> &str

pub fn id(&self) -> &Option<String>

pub fn params(&self) -> &JsonObject

pub fn params_mut(&mut self) -> &mut JsonObject

pub fn param(&self, key: &str) -> &JsonValue

Examples found in repository

examples/6.rs (line 17)

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

pub fn set_param(&mut self, key: String, val: JsonValue)

pub fn data(&self) -> &JsonObject

pub fn data_mut(&mut self) -> &mut JsonObject

pub fn boxed(self) -> BoxFuture<Request, Error>

Examples found in repository

examples/6.rs (line 25)

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

pub fn and_then<F, B>(self, f: F) -> AndThen<FutureResult<Request, Error>, B, F>

where F: FnOnce(Request) -> B, B: IntoFuture<Error = Error>,

Examples found in repository

examples/5.rs (lines 15-17)

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/7.rs (lines 19-24)

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 (lines 15-26)

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 (lines 16-18)

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 Debug for Request

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl IntoFuture for Request

type Item = Request

The item that the future may resolve with.

type Error = Error

The error that the future may resolve with.

type Future = FutureResult<Request, Error>

The future that this type can be converted into.

fn into_future(self) -> Self::Future

Consumes this object and produces a future.