@@ -7,20 +7,20 @@ use regex::bytes::Regex;
7
7
use serde:: { Deserialize , Deserializer , Serialize , Serializer } ;
8
8
use serde:: de:: Error ;
9
9
use types:: { GetType , LhsValue , RhsValue , RhsValues , Type } ;
10
+ use ordermap:: OrderMap ;
10
11
11
12
use std:: borrow:: { Borrow , Cow } ;
12
- use std:: collections:: HashMap ;
13
13
use std:: hash:: Hash ;
14
14
use std:: iter:: FromIterator ;
15
15
16
16
pub struct Context < K , T > {
17
- fields : HashMap < K , T > ,
17
+ fields : OrderMap < K , T > ,
18
18
}
19
19
20
20
impl < K : Hash + Eq , T > FromIterator < ( K , T ) > for Context < K , T > {
21
21
fn from_iter < I : IntoIterator < Item = ( K , T ) > > ( iter : I ) -> Self {
22
22
Context {
23
- fields : HashMap :: from_iter ( iter) ,
23
+ fields : OrderMap :: from_iter ( iter) ,
24
24
}
25
25
}
26
26
}
@@ -32,8 +32,8 @@ fn combining_op(input: &str) -> (Option<CombiningOp>, &str) {
32
32
}
33
33
}
34
34
35
- impl < K : Borrow < str > + Hash + Eq , T : GetType > Context < K , T > {
36
- fn simple_filter < ' i > ( & self , input : & ' i str ) -> LexResult < ' i , Filter < ' i > > {
35
+ impl < ' c , K : Borrow < str > + Hash + Eq , T : GetType > Context < K , T > {
36
+ fn simple_filter < ' i > ( & ' c self , input : & ' i str ) -> LexResult < ' i , Filter < ' c > > {
37
37
if let Ok ( ( op, input) ) = UnaryOp :: lex ( input) {
38
38
let input = input. trim_left ( ) ;
39
39
let ( arg, input) = self . simple_filter ( input) ?;
@@ -52,10 +52,12 @@ impl<K: Borrow<str> + Hash + Eq, T: GetType> Context<K, T> {
52
52
53
53
let ( lhs, input) = Field :: lex ( input) ?;
54
54
55
- let lhs_type = self . fields
56
- . get ( lhs. path ( ) )
57
- . ok_or_else ( || ( LexErrorKind :: UnknownField , lhs. path ( ) ) ) ?
58
- . get_type ( ) ;
55
+ let ( _, lhs, lhs_type) = self . fields
56
+ . get_full ( lhs. path ( ) )
57
+ . ok_or_else ( || ( LexErrorKind :: UnknownField , lhs. path ( ) ) ) ?;
58
+
59
+ let lhs = Field :: new ( lhs. borrow ( ) ) ;
60
+ let lhs_type = lhs_type. get_type ( ) ;
59
61
60
62
let input = input. trim_left ( ) ;
61
63
@@ -104,11 +106,11 @@ impl<K: Borrow<str> + Hash + Eq, T: GetType> Context<K, T> {
104
106
}
105
107
106
108
fn filter_prec < ' i > (
107
- & self ,
108
- mut lhs : Filter < ' i > ,
109
+ & ' c self ,
110
+ mut lhs : Filter < ' c > ,
109
111
min_prec : Option < CombiningOp > ,
110
112
mut lookahead : ( Option < CombiningOp > , & ' i str ) ,
111
- ) -> LexResult < ' i , Filter < ' i > > {
113
+ ) -> LexResult < ' i , Filter < ' c > > {
112
114
while let Some ( op) = lookahead. 0 {
113
115
let mut rhs = self . simple_filter ( lookahead. 1 ) ?;
114
116
loop {
@@ -135,13 +137,13 @@ impl<K: Borrow<str> + Hash + Eq, T: GetType> Context<K, T> {
135
137
Ok ( ( lhs, lookahead. 1 ) )
136
138
}
137
139
138
- fn combined_filter < ' i > ( & self , input : & ' i str ) -> LexResult < ' i , Filter < ' i > > {
140
+ fn combined_filter < ' i > ( & ' c self , input : & ' i str ) -> LexResult < ' i , Filter < ' c > > {
139
141
let ( lhs, input) = self . simple_filter ( input) ?;
140
142
let lookahead = combining_op ( input) ;
141
143
self . filter_prec ( lhs, None , lookahead)
142
144
}
143
145
144
- pub fn parse < ' i > ( & self , input : & ' i str ) -> Result < Filter < ' i > , LexError < ' i > > {
146
+ pub fn parse < ' i > ( & ' c self , input : & ' i str ) -> Result < Filter < ' c > , LexError < ' i > > {
145
147
let ( res, input) = self . combined_filter ( input) ?;
146
148
if input. is_empty ( ) {
147
149
Ok ( res)
0 commit comments