civet 0.8.3

civetweb-based server implementation for conduit
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

use libc::c_char;
use std::ffi::CString;

pub struct Config {
    port: Option<u16>,
    threads: Option<u32>,
    enable_keep_alive: Option<bool>,
}

impl Config {
    pub fn new() -> Config {
        Config {
            port: None,
            threads: None,
            enable_keep_alive: None,
        }
    }

    pub fn port(&mut self, port: u16) -> &mut Config {
        self.port = Some(port);
        self
    }

    pub fn threads(&mut self, threads: u32) -> &mut Config {
        self.threads = Some(threads);
        self
    }

    pub fn keep_alive(&mut self, keep_alive: bool) -> &mut Config {
        self.enable_keep_alive = Some(keep_alive);
        self
    }
}

pub fn config_to_options(config: &Config) -> (Vec<CString>, Vec<*const c_char>) {
    let Config { port, threads, enable_keep_alive } = *config;
    let mut options = Vec::new();
    opt(&mut options, "listening_ports", port.map(|i| i.to_string()));
    opt(&mut options, "num_threads", threads.map(|i| i.to_string()));
    opt(&mut options, "enable_keep_alive", enable_keep_alive.map(|b| {
        (if b {"yes"} else {"no"}).to_string()
    }));
    let mut ptrs: Vec<*const c_char> = options.iter().map(|a| {
        a.as_ptr()
    }).collect();
    ptrs.push(0 as *const c_char);
    return (options, ptrs);

    fn opt(v: &mut Vec<CString>, name: &str, opt: Option<String>) {
        if let Some(t) = opt {
            v.push(CString::new(name).unwrap());
            v.push(CString::new(t).unwrap());
        }
    }
}