tii 0.0.6

A Low-Latency Web Server.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::{RequestContext, Response, TypeSystemError};
use std::any::Any;
use std::mem;

/// Context object for response filters
/// Contains both info of the request and response
#[derive(Debug)]
pub struct ResponseContext<'request> {
  request: &'request mut RequestContext,
  response: Response,
}

impl<'a> ResponseContext<'a> {
  /// Constructor
  pub fn new(request: &'a mut RequestContext, response: Response) -> ResponseContext<'a> {
    Self { request, response }
  }

  /// Get all info from request
  pub fn get_request(&self) -> &RequestContext {
    self.request
  }

  /// Get all info from response
  pub fn get_response(&self) -> &Response {
    &self.response
  }

  /// Get mutable request info
  pub fn get_request_mut(&mut self) -> &mut RequestContext {
    self.request
  }

  /// Get mutable response info
  pub fn get_response_mut(&mut self) -> &mut Response {
    &mut self.response
  }

  /// Completely replaces the response
  pub fn set_response(&mut self, response: Response) -> Response {
    mem::replace(&mut self.response, response)
  }

  /// Casts the response entity (if the response contains one) to the desired type and calls
  /// a closure with it
  /// # Errors
  /// if casting fails because the response entity is not of the correct type.
  pub fn cast_response_entity<DST: Any + ?Sized + 'static, RET: Any + 'static>(
    &self,
    receiver: impl FnOnce(&DST) -> RET + 'static,
  ) -> Result<RET, TypeSystemError> {
    self
      .response
      .get_body()
      .ok_or(TypeSystemError::SourceTypeUnknown)?
      .entity_cast::<DST, RET>(self.request.get_type_system(), receiver)
  }

  /// Casts the mutable response entity (if the response contains one) to the desired type and calls
  /// a closure with it
  /// # Errors
  /// if casting fails because the response entity is not of the correct type.
  pub fn cast_response_entity_mut<DST: Any + ?Sized + 'static, RET: Any + 'static>(
    &mut self,
    receiver: impl FnOnce(&mut DST) -> RET + 'static,
  ) -> Result<RET, TypeSystemError> {
    self
      .response
      .get_body_mut()
      .ok_or(TypeSystemError::SourceTypeUnknown)?
      .entity_cast_mut::<DST, RET>(self.request.get_type_system(), receiver)
  }

  /// Separates response and request info from each other.
  pub fn unwrap(self) -> (&'a RequestContext, Response) {
    (self.request, self.response)
  }
}