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
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::collections::HashMap;
use http::Request;
use http::Response;

pub struct Context {
    pub request: Request,
    pub response: Response,
    pub contexts: HashMap<String, Value>,
    stop: bool
}

impl Context {
    pub fn new(request: Request) -> Context {
        let response = Response::empty(200);

        Context {
            request: request,
            response: response,
            contexts: HashMap::new(),
            stop: false
        }
    }

    pub fn stop(&mut self) {
        self.stop = true;
    }

    pub fn next(&self) -> bool {
        !self.stop
    }
}

pub enum Value {
    String(String),
    Int32(i32),
    Int64(i64),
    Usize(usize),
    Isize(isize),
    Double(f64),
    Array(Vec<Value>),
    Map(HashMap<Value, Value>),
    Boolean(bool),
    Binary(Vec<u8>),
}

impl Value {
    pub fn as_str(&self) -> Option<&str> {
        match *self {
            Value::String(ref s) => Some(s),
            _ => None,
        }
    }

    pub fn as_i32(&self) -> Option<i32> {
        match *self {
            Value::Int32(ref i) => Some(*i),
            _ => None
        }
    }

    pub fn as_i64(&self) -> Option<i64> {
        match *self {
            Value::Int64(ref i) => Some(*i),
            _ => None
        }
    }

    pub fn as_usize(&self) -> Option<usize> {
        match *self {
            Value::Usize(ref i) => Some(*i),
            _ => None
        }
    }

    pub fn as_isize(&self) -> Option<isize> {
        match *self {
            Value::Isize(ref i) => Some(*i),
            _ => None
        }
    }

    pub fn as_f64(&self) -> Option<f64> {
        match *self {
            Value::Double(ref i) => Some(*i),
            _ => None
        }
    }

    pub fn as_vec(&self) -> Option<&Vec<Value>> {
        match *self {
            Value::Array(ref i) => Some(i),
            _ => None
        }
    }

    pub fn as_map(&self) -> Option<&HashMap<Value, Value>> {
        match *self {
            Value::Map(ref i) => Some(i),
            _ => None
        }
    }

    pub fn as_bool(&self) -> Option<bool> {
        match *self {
            Value::Boolean(ref i) => Some(*i),
            _ => None
        }
    }

    pub fn as_binary(&self) -> Option<&Vec<u8>> {
        match *self {
            Value::Binary(ref i) => Some(i),
            _ => None
        }
    }
}