1
use crate::{
2
    commands::{
3
        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
4
        ResponseParserError,
5
    },
6
    filter::parse_filter,
7
};
8

            
9
pub struct Search;
10

            
11
pub struct SearchResponse {}
12

            
13
impl Command for Search {
14
    type Response = SearchResponse;
15
    const COMMAND: &'static str = "search";
16

            
17
    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
18
        let filter = parse_filter(&mut parts)?;
19

            
20
        let mut sort_or_window = parts.next();
21
        let mut sort = None;
22
        if let Some("sort") = sort_or_window {
23
            sort = Some(
24
                parts
25
                    .next()
26
                    .ok_or(RequestParserError::UnexpectedEOF)?
27
                    .to_string(),
28
            );
29
            sort_or_window = parts.next();
30
        }
31

            
32
        let mut window = None;
33
        if let Some("window") = sort_or_window {
34
            let w = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
35
            window = Some(
36
                w.parse()
37
                    .map_err(|_| RequestParserError::SyntaxError(0, w.to_string()))?,
38
            );
39
        }
40

            
41
        debug_assert!(parts.next().is_none());
42

            
43
        Ok((Request::Search(filter, sort, window), ""))
44
    }
45

            
46
    fn parse_response(
47
        parts: ResponseAttributes<'_>,
48
    ) -> Result<Self::Response, ResponseParserError> {
49
        unimplemented!()
50
    }
51
}