STRLCPY/LoggerPlusPlus

Add date handling to filter definition and evaluation
Corey-Dean Arthur committed 4 years ago

b351f0da

1 parent a808aaf2

Revision indexing in progress... (symbol navigation in revisions will be accurate after indexed)

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/ASTComparison.java

		skipped 3 lines
4	4
5	5		import com.nccgroup.loggerplusplus.filter.Operator;
6	6		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
	7	+	import com.nccgroup.loggerplusplus.logentry.LogManager;
7	8		import org.apache.commons.text.StringEscapeUtils;
8	9
	10	+	import java.util.Date;
9	11		import java.util.Set;
10	12		import java.util.regex.Pattern;
11	13		import java.util.stream.Collectors;
		skipped 33 lines
45	47
46	48		private String convertObjectToString(Object obj){
47	49		if(obj instanceof Pattern){
48		-	if(operator == Operator.MATCHES) return "\"" + String.valueOf(obj) + "\"";
49		-	else return "/" + String.valueOf(obj) + "/";
	50	+	if(operator == Operator.MATCHES) return "\"" + obj + "\"";
	51	+	else return "/" + obj + "/";
50	52		}else if(obj instanceof String){
51	53		return "\"" + StringEscapeUtils.escapeJava((String) obj) + "\"";
52	54		}else if(obj instanceof Set){
		skipped 5 lines
58	60		}).collect(Collectors.joining(", ")));
59	61		sb.append("]");
60	62		return sb.toString();
	63	+	}else if(obj instanceof Date){
	64	+	return "\"" + LogManager.sdf.format(obj) + "\"";
61	65		}
62	66		return String.valueOf(obj);
63	67		}
		skipped 4 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/Filter.jj

		skipped 17 lines
18	18		import java.util.Arrays;
19	19		import java.util.LinkedHashSet;
20	20		import java.util.Set;
	21	+	import java.util.Date;
21	22		import java.util.ArrayList;
22	23		import java.util.regex.Pattern;
23	24		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
24		-	import com.nccgroup.loggerplusplus.logentry.FieldGroup;
	25	+	import com.nccgroup.loggerplusplus.logentry.FieldGroup;import com.nccgroup.loggerplusplus.logentry.LogManager;
25	26		import static com.nccgroup.loggerplusplus.logentry.LogEntryField.getFieldsInGroup;
26	27
27	28		public class FilterParser/@bgen(jjtree)/implements FilterParserTreeConstants/@egen/ {/@bgen(jjtree)/
		skipped 4 lines
32	33		public static ASTExpression parseFilter(String string) throws ParseException {
33	34		FilterParser FilterParser = new FilterParser(new StringReader(string));
34	35		ASTExpression node;
35		-	try{
36		-	node = FilterParser.Filter();
37		-	}catch(Exception e){
38		-	throw new ParseException(e.getMessage());
39		-	}
	36	+	node = FilterParser.Filter();
40	37		// VisitorData result = new SanityCheckVisitor().visit(node);
41	38		// if(!result.isSuccess()) throw new ParseException(result.getErrorString());
42	39		return node;
		skipped 167 lines
210	207		(left = Identifier() \| {throw new ParseException("The left side of a comparison must be a field identifier.");})
211	208
212	209		(
213		-	op = EqualityOperator() (
	210	+	op = EqualityOperator() (LOOKAHEAD(3)
	211	+	right = Date()
	212	+	{
	213	+	if(!Date.class.isAssignableFrom(((LogEntryField) left).getType())){
	214	+	throw new ParseException(String.format("Value of type Date cannot be compared against field \"%s\" of type \"%s\"", left, ((LogEntryField)left).getType()));
	215	+	}
	216	+	}
	217	+	\|
214	218		right = Value()
215	219		\|
216	220		{throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
		skipped 8 lines
225	229		\|
226	230		op = NumericOperator()
227	231		{
228		-	if(!Number.class.isAssignableFrom(((LogEntryField) left).getType())){
	232	+	if(!Number.class.isAssignableFrom(((LogEntryField) left).getType()) && !Date.class.isAssignableFrom(((LogEntryField) left).getType())){
229	233		throw new ParseException(String.format("Numeric operators cannot be used for field \"%s\" of type \"%s\"", left, ((LogEntryField) left).getType()));
230	234		}
231	235		}
		skipped 7 lines
239	243		}
240	244		}
241	245		\|
	246	+	right = Date()
	247	+	{
	248	+	if(!Date.class.isAssignableFrom(((LogEntryField) left).getType())){
	249	+	throw new ParseException(String.format("Value of type Date cannot be compared against field \"%s\" of type \"%s\"", left, ((LogEntryField)left).getType()));
	250	+	}
	251	+	}
	252	+	\|
242	253		{throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
243	254		)
244	255		\|
		skipped 169 lines
414	425
415	426
416	427		//TYPES
	428	+	Date Date() :
	429	+	{Token t;}
	430	+	{
	431	+	(
	432	+	<OPEN_SINGLE_QUOTE_STRING> t=<SINGLE_STRING_BODY> <CLOSE_SINGLE_QUOTE_STRING>
	433	+	\|
	434	+	<OPEN_DOUBLE_QUOTE_STRING> t=<DOUBLE_STRING_BODY> <CLOSE_DOUBLE_QUOTE_STRING>
	435	+	)
	436	+	{
	437	+	try{
	438	+	Date date = LogManager.sdf.parse(t.image);
	439	+	return date;
	440	+	}catch (Exception e){
	441	+	throw new ParseException("Invalid date format. Please use the format YYYY/MM/DD HH:MM:SS");
	442	+	}
	443	+	}
	444	+	}
417	445
418	446		BigDecimal Number() :
419	447		{Token t;}
		skipped 70 lines
490	518		[inverse=<INVERSE>]
491	519		t=<BOOLEAN>
492	520		{
493		-	return (inverse != null ^ Boolean.parseBoolean(t.image));
494		-	}
	521	+	return (inverse != null ^ java.lang.Boolean.parseBoolean(t.image));
	522	+	}
495	523		}
496	524
497	525		//END TYPES
		skipped 61 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/Filter.jjt

		skipped 16 lines
17	17		import java.util.Arrays;
18	18		import java.util.LinkedHashSet;
19	19		import java.util.Set;
	20	+	import java.util.Date;
20	21		import java.util.ArrayList;
21	22		import java.util.regex.Pattern;
22	23		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
23		-	import com.nccgroup.loggerplusplus.logentry.FieldGroup;
	24	+	import com.nccgroup.loggerplusplus.logentry.FieldGroup;import com.nccgroup.loggerplusplus.logentry.LogManager;
24	25		import static com.nccgroup.loggerplusplus.logentry.LogEntryField.getFieldsInGroup;
25	26
26	27		public class FilterParser {
		skipped 1 lines
28	29		public static ASTExpression parseFilter(String string) throws ParseException {
29	30		FilterParser FilterParser = new FilterParser(new StringReader(string));
30	31		ASTExpression node;
31		-	try{
32		-	node = FilterParser.Filter();
33		-	}catch(Exception e){
34		-	throw new ParseException(e.getMessage());
35		-	}
	32	+	node = FilterParser.Filter();
36	33		// VisitorData result = new SanityCheckVisitor().visit(node);
37	34		// if(!result.isSuccess()) throw new ParseException(result.getErrorString());
38	35		return node;
		skipped 130 lines
169	166		(left = Identifier() \| {throw new ParseException("The left side of a comparison must be a field identifier.");})
170	167
171	168		(
172		-	op = EqualityOperator() (
	169	+	op = EqualityOperator() (LOOKAHEAD(3)
	170	+	right = Date()
	171	+	{
	172	+	if(!Date.class.isAssignableFrom(((LogEntryField) left).getType())){
	173	+	throw new ParseException(String.format("Value of type Date cannot be compared against field \"%s\" of type \"%s\"", left, ((LogEntryField)left).getType()));
	174	+	}
	175	+	}
	176	+	\|
173	177		right = Value()
174	178		\|
175	179		{throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
		skipped 8 lines
184	188		\|
185	189		op = NumericOperator()
186	190		{
187		-	if(!Number.class.isAssignableFrom(((LogEntryField) left).getType())){
	191	+	if(!Number.class.isAssignableFrom(((LogEntryField) left).getType()) && !Date.class.isAssignableFrom(((LogEntryField) left).getType())){
188	192		throw new ParseException(String.format("Numeric operators cannot be used for field \"%s\" of type \"%s\"", left, ((LogEntryField) left).getType()));
189	193		}
190	194		}
		skipped 7 lines
198	202		}
199	203		}
200	204		\|
	205	+	right = Date()
	206	+	{
	207	+	if(!Date.class.isAssignableFrom(((LogEntryField) left).getType())){
	208	+	throw new ParseException(String.format("Value of type Date cannot be compared against field \"%s\" of type \"%s\"", left, ((LogEntryField)left).getType()));
	209	+	}
	210	+	}
	211	+	\|
201	212		{throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
202	213		)
203	214		\|
		skipped 127 lines
331	342
332	343
333	344		//TYPES
	345	+	Date Date() #void :
	346	+	{Token t;}
	347	+	{
	348	+	(
	349	+	<OPEN_SINGLE_QUOTE_STRING> t=<SINGLE_STRING_BODY> <CLOSE_SINGLE_QUOTE_STRING>
	350	+	\|
	351	+	<OPEN_DOUBLE_QUOTE_STRING> t=<DOUBLE_STRING_BODY> <CLOSE_DOUBLE_QUOTE_STRING>
	352	+	)
	353	+	{
	354	+	try{
	355	+	Date date = LogManager.sdf.parse(t.image);
	356	+	return date;
	357	+	}catch (Exception e){
	358	+	throw new ParseException("Invalid date format. Please use the format YYYY/MM/DD HH:MM:SS");
	359	+	}
	360	+	}
	361	+	}
334	362
335	363		BigDecimal Number() #void :
336	364		{Token t;}
		skipped 70 lines
407	435		[inverse=<INVERSE>]
408	436		t=<BOOLEAN>
409	437		{
410		-	return (inverse != null ^ Boolean.parseBoolean(t.image));
411		-	}
	438	+	return (inverse != null ^ java.lang.Boolean.parseBoolean(t.image));
	439	+	}
412	440		}
413	441
414	442		//END TYPES
		skipped 61 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/FilterEvaluationVisitor.java

		skipped 136 lines
137	137		return m.find() ^ op == Operator.NOT_EQUAL;
138	138		}else if (left instanceof Date) {
139	139		try {
140		-	Date rightDate = DateUtils.truncate(LogManager.sdf.parse(String.valueOf(right)), Calendar.SECOND);
	140	+	Date rightDate = DateUtils.truncate(right, Calendar.SECOND);
141	141		switch (op){
142	142		case EQUAL: return DateUtils.truncate((Date) left, Calendar.SECOND).compareTo(rightDate) == 0;
143	143		case NOT_EQUAL: return DateUtils.truncate((Date) left, Calendar.SECOND).compareTo(rightDate) != 0;
		skipped 38 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/FilterParser.java

		skipped 7 lines
8	8		import java.util.Arrays;
9	9		import java.util.LinkedHashSet;
10	10		import java.util.Set;
	11	+	import java.util.Date;
11	12		import java.util.ArrayList;
12	13		import java.util.regex.Pattern;
13	14		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
14		-	import com.nccgroup.loggerplusplus.logentry.FieldGroup;
	15	+	import com.nccgroup.loggerplusplus.logentry.FieldGroup;import com.nccgroup.loggerplusplus.logentry.LogManager;
15	16		import static com.nccgroup.loggerplusplus.logentry.LogEntryField.getFieldsInGroup;
16	17
17	18		public class FilterParser/@bgen(jjtree)/implements FilterParserTreeConstants, FilterParserConstants {/@bgen(jjtree)/
		skipped 1 lines
19	20		public static ASTExpression parseFilter(String string) throws ParseException {
20	21		FilterParser FilterParser = new FilterParser(new StringReader(string));
21	22		ASTExpression node;
22		-	try{
23		-	node = FilterParser.Filter();
24		-	}catch(Exception e){
25		-	throw new ParseException(e.getMessage());
26		-	}
	23	+	node = FilterParser.Filter();
27	24		// VisitorData result = new SanityCheckVisitor().visit(node);
28	25		// if(!result.isSuccess()) throw new ParseException(result.getErrorString());
29	26		return node;
		skipped 24 lines
54	51		if (jj_2_1(2)) {
55	52		op = ExpressionCompounding();
56	53		} else {
57		-	;
58	54		}
59	55		jjtree.closeNodeScope(jjtn000, true);
60	56		jjtc000 = false;
		skipped 30 lines
91	87		}
92	88		default:
93	89		jj_la1[0] = jj_gen;
94		-	;
95	90		}
96	91		jj_consume_token(LPAREN);
97	92		Expression(inverse);
		skipped 57 lines
155	150		label_1:
156	151		while (true) {
157	152		if (jj_2_2(2)) {
158		-	;
159	153		} else {
160	154		break label_1;
161	155		}
		skipped 44 lines
206	200		case EQ:
207	201		case NEQ:{
208	202		op = EqualityOperator();
209		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
210		-	case BOOLEAN:
211		-	case NUMBER:
212		-	case REGEXLITERAL_IN_FORWARD_SLASHES:
213		-	case REGEX_IN_FORWARD_SLASHES:
214		-	case INVERSE:
215		-	case IDENTIFIER:
216		-	case OPEN_SINGLE_QUOTE_STRING:
217		-	case OPEN_DOUBLE_QUOTE_STRING:{
218		-	right = Value();
219		-	break;
	203	+	if (jj_2_3(3)) {
	204	+	right = Date();
	205	+	if(!Date.class.isAssignableFrom(((LogEntryField) left).getType())){
	206	+	{if (true) throw new ParseException(String.format("Value of type Date cannot be compared against field \"%s\" of type \"%s\"", left, ((LogEntryField)left).getType()));}
	207	+	}
	208	+	} else {
	209	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	210	+	case BOOLEAN:
	211	+	case NUMBER:
	212	+	case REGEXLITERAL_IN_FORWARD_SLASHES:
	213	+	case REGEX_IN_FORWARD_SLASHES:
	214	+	case INVERSE:
	215	+	case IDENTIFIER:
	216	+	case OPEN_SINGLE_QUOTE_STRING:
	217	+	case OPEN_DOUBLE_QUOTE_STRING:{
	218	+	right = Value();
	219	+	break;
	220	+	}
	221	+	default:
	222	+	jj_la1[7] = jj_gen;
	223	+	{if (true) throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
220	224		}
221		-	default:
222		-	jj_la1[7] = jj_gen;
223		-	{if (true) throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
224	225		}
225	226		if(right instanceof Pattern && !String.class.isAssignableFrom(((LogEntryField) left).getType())){
226	227		{if (true) throw new ParseException(String.format("Regex patterns can only be used on fields which can be converted to a string. Field \"%s\" of type \"%s\" cannot be converted.", left, ((LogEntryField) left).getType()));}
		skipped 5 lines
232	233		case GEQ:
233	234		case LEQ:{
234	235		op = NumericOperator();
235		-	if(!Number.class.isAssignableFrom(((LogEntryField) left).getType())){
	236	+	if(!Number.class.isAssignableFrom(((LogEntryField) left).getType()) && !Date.class.isAssignableFrom(((LogEntryField) left).getType())){
236	237		{if (true) throw new ParseException(String.format("Numeric operators cannot be used for field \"%s\" of type \"%s\"", left, ((LogEntryField) left).getType()));}
237	238		}
238	239		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
		skipped 8 lines
247	248		}
248	249		break;
249	250		}
	251	+	case OPEN_SINGLE_QUOTE_STRING:
	252	+	case OPEN_DOUBLE_QUOTE_STRING:{
	253	+	right = Date();
	254	+	if(!Date.class.isAssignableFrom(((LogEntryField) left).getType())){
	255	+	{if (true) throw new ParseException(String.format("Value of type Date cannot be compared against field \"%s\" of type \"%s\"", left, ((LogEntryField)left).getType()));}
	256	+	}
	257	+	break;
	258	+	}
250	259		default:
251	260		jj_la1[8] = jj_gen;
252	261		{if (true) throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
		skipped 105 lines
358	367		}
359	368
360	369		final public Object Value() throws ParseException {Object v;
361		-	if (jj_2_3(2)) {
	370	+	if (jj_2_4(2)) {
362	371		v = Identifier();
363	372		} else {
364	373		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
		skipped 49 lines
414	423		while (true) {
415	424		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
416	425		case ARRAY_SEPARATOR:{
417		-	;
418		-	break;
	426	+	break;
419	427		}
420	428		default:
421	429		jj_la1[15] = jj_gen;
		skipped 57 lines
479	487
480	488
481	489		//TYPES
482		-	final public
483		-	BigDecimal Number() throws ParseException {Token t;
	490	+	final public Date Date() throws ParseException {Token t;
	491	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	492	+	case OPEN_SINGLE_QUOTE_STRING:{
	493	+	jj_consume_token(OPEN_SINGLE_QUOTE_STRING);
	494	+	t = jj_consume_token(SINGLE_STRING_BODY);
	495	+	jj_consume_token(CLOSE_SINGLE_QUOTE_STRING);
	496	+	break;
	497	+	}
	498	+	case OPEN_DOUBLE_QUOTE_STRING:{
	499	+	jj_consume_token(OPEN_DOUBLE_QUOTE_STRING);
	500	+	t = jj_consume_token(DOUBLE_STRING_BODY);
	501	+	jj_consume_token(CLOSE_DOUBLE_QUOTE_STRING);
	502	+	break;
	503	+	}
	504	+	default:
	505	+	jj_la1[17] = jj_gen;
	506	+	jj_consume_token(-1);
	507	+	throw new ParseException();
	508	+	}
	509	+	try{
	510	+	Date date = LogManager.sdf.parse(t.image);
	511	+	{if ("" != null) return date;}
	512	+	}catch (Exception e){
	513	+	{if (true) throw new ParseException("Invalid date format. Please use the format YYYY/MM/DD HH:MM:SS");}
	514	+	}
	515	+	throw new Error("Missing return statement in function");
	516	+	}
	517	+
	518	+	final public BigDecimal Number() throws ParseException {Token t;
484	519		t = jj_consume_token(NUMBER);
485	520		{if ("" != null) return new BigDecimal(t.image);}
486	521		throw new Error("Missing return statement in function");
		skipped 9 lines
496	531		break;
497	532		}
498	533		default:
499		-	jj_la1[17] = jj_gen;
500		-	;
	534	+	jj_la1[18] = jj_gen;
501	535		}
502	536		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
503	537		case CLOSE_SINGLE_QUOTE_STRING:{
		skipped 1 lines
505	539		break;
506	540		}
507	541		default:
508		-	jj_la1[18] = jj_gen;
	542	+	jj_la1[19] = jj_gen;
509	543		{if (true) throw new ParseException("Missing closing quote for string.");}
510	544		}
511	545		break;
		skipped 6 lines
518	552		break;
519	553		}
520	554		default:
521		-	jj_la1[19] = jj_gen;
522		-	;
	555	+	jj_la1[20] = jj_gen;
523	556		}
524	557		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
525	558		case CLOSE_DOUBLE_QUOTE_STRING:{
		skipped 1 lines
527	560		break;
528	561		}
529	562		default:
530		-	jj_la1[20] = jj_gen;
	563	+	jj_la1[21] = jj_gen;
531	564		{if (true) throw new ParseException("Missing closing quote for string.");}
532	565		}
533	566		break;
534	567		}
535	568		default:
536		-	jj_la1[21] = jj_gen;
	569	+	jj_la1[22] = jj_gen;
537	570		jj_consume_token(-1);
538	571		throw new ParseException();
539	572		}
		skipped 13 lines
553	586		break;
554	587		}
555	588		default:
556		-	jj_la1[22] = jj_gen;
	589	+	jj_la1[23] = jj_gen;
557	590		{if (true) throw new ParseException("Missing closing quote for regex string.");}
558	591		}
559	592		break;
		skipped 7 lines
567	600		break;
568	601		}
569	602		default:
570		-	jj_la1[23] = jj_gen;
	603	+	jj_la1[24] = jj_gen;
571	604		{if (true) throw new ParseException("Missing closing quote for regex string.");}
572	605		}
573	606		break;
574	607		}
575	608		default:
576		-	jj_la1[24] = jj_gen;
	609	+	jj_la1[25] = jj_gen;
577	610		jj_consume_token(-1);
578	611		throw new ParseException();
579	612		}
		skipped 12 lines
592	625		break;
593	626		}
594	627		default:
595		-	jj_la1[25] = jj_gen;
	628	+	jj_la1[26] = jj_gen;
596	629		jj_consume_token(-1);
597	630		throw new ParseException();
598	631		}
		skipped 8 lines
607	640		break;
608	641		}
609	642		default:
610		-	jj_la1[26] = jj_gen;
611		-	;
	643	+	jj_la1[27] = jj_gen;
612	644		}
613	645		t = jj_consume_token(BOOLEAN);
614	646		{if ("" != null) return (inverse != null ^ Boolean.parseBoolean(t.image));}
		skipped 18 lines
633	665		break;
634	666		}
635	667		default:
636		-	jj_la1[27] = jj_gen;
	668	+	jj_la1[28] = jj_gen;
637	669		jj_consume_token(-1);
638	670		throw new ParseException();
639	671		}
		skipped 23 lines
663	695		break;
664	696		}
665	697		default:
666		-	jj_la1[28] = jj_gen;
	698	+	jj_la1[29] = jj_gen;
667	699		jj_consume_token(-1);
668	700		throw new ParseException();
669	701		}
		skipped 66 lines
736	768		finally { jj_save(2, xla); }
737	769		}
738	770
739		-	private boolean jj_3R_13()
	771	+	private boolean jj_2_4(int xla)
740	772		{
741		-	if (jj_scan_token(OR)) return true;
742		-	return false;
	773	+	jj_la = xla; jj_lastpos = jj_scanpos = token;
	774	+	try { return (!jj_3_4()); }
	775	+	catch(LookaheadSuccess ls) { return true; }
	776	+	finally { jj_save(3, xla); }
743	777		}
744	778
745		-	private boolean jj_3R_12()
	779	+	private boolean jj_3R_38()
	780	+	{
	781	+	return jj_scan_token(CONTAINS);
	782	+	}
	783	+
	784	+	private boolean jj_3_4()
	785	+	{
	786	+	return jj_3R_9();
	787	+	}
	788	+
	789	+	private boolean jj_3R_46()
	790	+	{
	791	+	return jj_scan_token(LEQ);
	792	+	}
	793	+
	794	+	private boolean jj_3R_45()
	795	+	{
	796	+	return jj_scan_token(GEQ);
	797	+	}
	798	+
	799	+	private boolean jj_3R_44()
746	800		{
747		-	if (jj_scan_token(AND)) return true;
748		-	return false;
749		-	}
	801	+	return jj_scan_token(LT);
	802	+	}
750	803
751		-	private boolean jj_3R_27()
	804	+	private boolean jj_3R_30()
752	805		{
753		-	if (jj_3R_33()) return true;
754		-	return false;
755		-	}
	806	+	return jj_3R_36();
	807	+	}
756	808
757		-	private boolean jj_3R_11()
	809	+	private boolean jj_3R_43()
758	810		{
759		-	if (jj_3R_14()) return true;
	811	+	return jj_scan_token(GT);
	812	+	}
	813	+
	814	+	private boolean jj_3R_37()
	815	+	{
	816	+	Token xsp;
	817	+	xsp = jj_scanpos;
	818	+	if (jj_3R_43()) {
	819	+	jj_scanpos = xsp;
	820	+	if (jj_3R_44()) {
	821	+	jj_scanpos = xsp;
	822	+	if (jj_3R_45()) {
	823	+	jj_scanpos = xsp;
	824	+	return jj_3R_46();
	825	+	}
	826	+	}
	827	+	}
760	828		return false;
761	829		}
762	830
	831	+	private boolean jj_3R_12()
	832	+	{
	833	+	return jj_3R_15();
	834	+	}
	835	+
763	836		private boolean jj_3R_5()
764	837		{
765		-	if (jj_3R_13()) return true;
766		-	return false;
767		-	}
	838	+	return jj_3R_14();
	839	+	}
768	840
769		-	private boolean jj_3R_22()
	841	+	private boolean jj_3R_42()
770	842		{
771		-	if (jj_scan_token(INVERSE)) return true;
772		-	return false;
773		-	}
	843	+	return jj_scan_token(NEQ);
	844	+	}
774	845
775		-	private boolean jj_3R_25()
	846	+	private boolean jj_3R_41()
	847	+	{
	848	+	return jj_scan_token(EQ);
	849	+	}
	850	+
	851	+	private boolean jj_3R_36()
776	852		{
777		-	if (jj_3R_8()) return true;
	853	+	Token xsp;
	854	+	xsp = jj_scanpos;
	855	+	if (jj_3R_41()) {
	856	+	jj_scanpos = xsp;
	857	+	return jj_3R_42();
	858	+	}
778	859		return false;
779	860		}
780	861
781		-	private boolean jj_3R_24()
	862	+	private boolean jj_3R_28()
	863	+	{
	864	+	return jj_3R_9();
	865	+	}
	866	+
	867	+	private boolean jj_3R_27()
782	868		{
783	869		Token xsp;
784	870		xsp = jj_scanpos;
785		-	if (jj_3R_25()) {
	871	+	if (jj_3R_28()) {
786	872		jj_scanpos = xsp;
787		-	if (jj_3R_26()) return true;
	873	+	if (jj_3R_29()) return true;
788	874		}
789	875		xsp = jj_scanpos;
790		-	if (jj_3R_27()) {
	876	+	if (jj_3R_30()) {
791	877		jj_scanpos = xsp;
792		-	if (jj_3R_28()) {
	878	+	if (jj_3R_31()) {
793	879		jj_scanpos = xsp;
794		-	if (jj_3R_29()) {
	880	+	if (jj_3R_32()) {
795	881		jj_scanpos = xsp;
796		-	if (jj_3R_30()) {
	882	+	if (jj_3R_33()) {
797	883		jj_scanpos = xsp;
798		-	if (jj_3R_31()) {
	884	+	if (jj_3R_34()) {
799	885		jj_scanpos = xsp;
800		-	if (jj_3R_32()) return true;
	886	+	return jj_3R_35();
801	887		}
802	888		}
803	889		}
		skipped 2 lines
806	892		return false;
807	893		}
808	894
809		-	private boolean jj_3_3()
	895	+	private boolean jj_3R_19()
810	896		{
811		-	if (jj_3R_8()) return true;
812		-	return false;
813		-	}
	897	+	if (jj_scan_token(OPEN_DOUBLE_QUOTE_STRING)) return true;
	898	+	if (jj_scan_token(DOUBLE_STRING_BODY)) return true;
	899	+	return jj_scan_token(CLOSE_DOUBLE_QUOTE_STRING);
	900	+	}
814	901
815		-	private boolean jj_3R_36()
	902	+	private boolean jj_3R_26()
816	903		{
817		-	if (jj_scan_token(IN)) return true;
818		-	return false;
819		-	}
	904	+	return jj_scan_token(ALIAS_SYMBOL);
	905	+	}
820	906
821		-	private boolean jj_3R_16()
822		-	{
823		-	if (jj_3R_18()) return true;
824		-	return false;
825		-	}
826		-
827		-	private boolean jj_3R_10()
	907	+	private boolean jj_3R_18()
828	908		{
829		-	if (jj_3R_13()) return true;
830		-	return false;
831		-	}
	909	+	if (jj_scan_token(OPEN_SINGLE_QUOTE_STRING)) return true;
	910	+	if (jj_scan_token(SINGLE_STRING_BODY)) return true;
	911	+	return jj_scan_token(CLOSE_SINGLE_QUOTE_STRING);
	912	+	}
832	913
833		-	private boolean jj_3R_37()
	914	+	private boolean jj_3R_11()
834	915		{
835		-	if (jj_scan_token(MATCHES)) return true;
836		-	return false;
837		-	}
	916	+	return jj_3R_14();
	917	+	}
838	918
839		-	private boolean jj_3R_4()
	919	+	private boolean jj_3R_17()
840	920		{
841		-	if (jj_3R_12()) return true;
842		-	return false;
843		-	}
	921	+	return jj_3R_21();
	922	+	}
844	923
845		-	private boolean jj_3R_35()
	924	+	private boolean jj_3R_8()
846	925		{
847		-	if (jj_scan_token(CONTAINS)) return true;
	926	+	Token xsp;
	927	+	xsp = jj_scanpos;
	928	+	if (jj_3R_18()) {
	929	+	jj_scanpos = xsp;
	930	+	return jj_3R_19();
	931	+	}
848	932		return false;
849	933		}
850	934
851		-	private boolean jj_3R_23()
	935	+	private boolean jj_3R_4()
852	936		{
853		-	if (jj_scan_token(ALIAS_SYMBOL)) return true;
854		-	return false;
855		-	}
	937	+	return jj_3R_13();
	938	+	}
856	939
857	940		private boolean jj_3_2()
858	941		{
		skipped 6 lines
865	948		if (jj_3R_6()) return true;
866	949		}
867	950		}
868		-	if (jj_3R_7()) return true;
869		-	return false;
870		-	}
	951	+	return jj_3R_7();
	952	+	}
871	953
872		-	private boolean jj_3R_9()
	954	+	private boolean jj_3R_35()
873	955		{
874		-	if (jj_3R_12()) return true;
875	956		return false;
876	957		}
877	958
878		-	private boolean jj_3R_21()
	959	+	private boolean jj_3R_10()
879	960		{
880		-	if (jj_3R_24()) return true;
881		-	return false;
882		-	}
	961	+	return jj_3R_13();
	962	+	}
883	963
884		-	private boolean jj_3R_43()
	964	+	private boolean jj_3R_24()
885	965		{
886		-	if (jj_scan_token(LEQ)) return true;
887		-	return false;
888		-	}
	966	+	return jj_3R_27();
	967	+	}
889	968
890	969		private boolean jj_3R_3()
891	970		{
892	971		Token xsp;
893	972		xsp = jj_scanpos;
894		-	if (jj_3R_9()) {
895		-	jj_scanpos = xsp;
896	973		if (jj_3R_10()) {
897	974		jj_scanpos = xsp;
898		-	if (jj_3R_11()) return true;
	975	+	if (jj_3R_11()) {
	976	+	jj_scanpos = xsp;
	977	+	if (jj_3R_12()) return true;
899	978		}
900	979		}
901		-	if (jj_3R_7()) return true;
902		-	return false;
903		-	}
	980	+	return jj_3R_7();
	981	+	}
904	982
905		-	private boolean jj_3R_42()
	983	+	private boolean jj_3R_34()
906	984		{
907		-	if (jj_scan_token(GEQ)) return true;
908		-	return false;
909		-	}
	985	+	return jj_3R_40();
	986	+	}
910	987
911		-	private boolean jj_3R_41()
912		-	{
913		-	if (jj_scan_token(LT)) return true;
914		-	return false;
915		-	}
916		-
917		-	private boolean jj_3R_40()
918		-	{
919		-	if (jj_scan_token(GT)) return true;
920		-	return false;
921		-	}
922		-
923		-	private boolean jj_3R_34()
	988	+	private boolean jj_3R_21()
924	989		{
925	990		Token xsp;
926	991		xsp = jj_scanpos;
927		-	if (jj_3R_40()) {
928		-	jj_scanpos = xsp;
929		-	if (jj_3R_41()) {
930		-	jj_scanpos = xsp;
931		-	if (jj_3R_42()) {
	992	+	if (jj_3R_23()) {
932	993		jj_scanpos = xsp;
933		-	if (jj_3R_43()) return true;
934		-	}
935		-	}
	994	+	return jj_3R_24();
936	995		}
937	996		return false;
938	997		}
939	998
940		-	private boolean jj_3R_39()
	999	+	private boolean jj_3R_23()
941	1000		{
942		-	if (jj_scan_token(NEQ)) return true;
943		-	return false;
944		-	}
	1001	+	return jj_3R_26();
	1002	+	}
	1003	+
	1004	+	private boolean jj_3R_33()
	1005	+	{
	1006	+	return jj_3R_39();
	1007	+	}
945	1008
946		-	private boolean jj_3R_18()
	1009	+	private boolean jj_3R_7()
947	1010		{
948	1011		Token xsp;
949	1012		xsp = jj_scanpos;
950		-	if (jj_3R_20()) {
	1013	+	if (jj_3R_16()) {
951	1014		jj_scanpos = xsp;
952		-	if (jj_3R_21()) return true;
	1015	+	return jj_3R_17();
953	1016		}
954	1017		return false;
955	1018		}
956	1019
957		-	private boolean jj_3R_20()
	1020	+	private boolean jj_3R_16()
	1021	+	{
	1022	+	return jj_3R_20();
	1023	+	}
	1024	+
	1025	+	private boolean jj_3_1()
958	1026		{
959		-	if (jj_3R_23()) return true;
960		-	return false;
961		-	}
	1027	+	return jj_3R_3();
	1028	+	}
962	1029
963		-	private boolean jj_3R_38()
	1030	+	private boolean jj_3R_22()
964	1031		{
965		-	if (jj_scan_token(EQ)) return true;
966		-	return false;
967		-	}
	1032	+	return jj_3R_25();
	1033	+	}
968	1034
969		-	private boolean jj_3R_33()
	1035	+	private boolean jj_3R_20()
970	1036		{
971	1037		Token xsp;
972	1038		xsp = jj_scanpos;
973		-	if (jj_3R_38()) {
974		-	jj_scanpos = xsp;
975		-	if (jj_3R_39()) return true;
976		-	}
977		-	return false;
978		-	}
	1039	+	if (jj_3R_22()) jj_scanpos = xsp;
	1040	+	return jj_scan_token(LPAREN);
	1041	+	}
979	1042
980	1043		private boolean jj_3R_32()
981	1044		{
982		-	return false;
983		-	}
	1045	+	return jj_3R_38();
	1046	+	}
984	1047
985		-	private boolean jj_3R_15()
	1048	+	private boolean jj_3R_9()
986	1049		{
987		-	if (jj_3R_17()) return true;
988		-	return false;
989		-	}
	1050	+	if (jj_scan_token(IDENTIFIER)) return true;
	1051	+	return jj_scan_token(DOT);
	1052	+	}
990	1053
991		-	private boolean jj_3R_7()
	1054	+	private boolean jj_3R_15()
992	1055		{
993		-	Token xsp;
994		-	xsp = jj_scanpos;
995		-	if (jj_3R_15()) {
996		-	jj_scanpos = xsp;
997		-	if (jj_3R_16()) return true;
998		-	}
999		-	return false;
1000		-	}
	1056	+	return jj_scan_token(XOR);
	1057	+	}
1001	1058
1002		-	private boolean jj_3_1()
	1059	+	private boolean jj_3R_14()
1003	1060		{
1004		-	if (jj_3R_3()) return true;
1005		-	return false;
1006		-	}
	1061	+	return jj_scan_token(OR);
	1062	+	}
1007	1063
1008		-	private boolean jj_3R_19()
	1064	+	private boolean jj_3R_13()
1009	1065		{
1010		-	if (jj_3R_22()) return true;
1011		-	return false;
1012		-	}
	1066	+	return jj_scan_token(AND);
	1067	+	}
1013	1068
1014		-	private boolean jj_3R_17()
	1069	+	private boolean jj_3R_25()
1015	1070		{
1016		-	Token xsp;
1017		-	xsp = jj_scanpos;
1018		-	if (jj_3R_19()) jj_scanpos = xsp;
1019		-	if (jj_scan_token(LPAREN)) return true;
1020		-	return false;
1021		-	}
	1071	+	return jj_scan_token(INVERSE);
	1072	+	}
1022	1073
1023		-	private boolean jj_3R_31()
	1074	+	private boolean jj_3_3()
1024	1075		{
1025		-	if (jj_3R_37()) return true;
1026		-	return false;
1027		-	}
	1076	+	return jj_3R_8();
	1077	+	}
1028	1078
1029		-	private boolean jj_3R_30()
	1079	+	private boolean jj_3R_39()
1030	1080		{
1031		-	if (jj_3R_36()) return true;
1032		-	return false;
1033		-	}
	1081	+	return jj_scan_token(IN);
	1082	+	}
1034	1083
1035		-	private boolean jj_3R_29()
	1084	+	private boolean jj_3R_31()
1036	1085		{
1037		-	if (jj_3R_35()) return true;
1038		-	return false;
1039		-	}
	1086	+	return jj_3R_37();
	1087	+	}
1040	1088
1041		-	private boolean jj_3R_8()
	1089	+	private boolean jj_3R_29()
1042	1090		{
1043		-	if (jj_scan_token(IDENTIFIER)) return true;
1044		-	if (jj_scan_token(DOT)) return true;
1045	1091		return false;
1046	1092		}
1047	1093
1048		-	private boolean jj_3R_26()
	1094	+	private boolean jj_3R_40()
1049	1095		{
1050		-	return false;
1051		-	}
	1096	+	return jj_scan_token(MATCHES);
	1097	+	}
1052	1098
1053	1099		private boolean jj_3R_6()
1054	1100		{
1055		-	if (jj_3R_14()) return true;
1056		-	return false;
1057		-	}
1058		-
1059		-	private boolean jj_3R_28()
1060		-	{
1061		-	if (jj_3R_34()) return true;
1062		-	return false;
1063		-	}
1064		-
1065		-	private boolean jj_3R_14()
1066		-	{
1067		-	if (jj_scan_token(XOR)) return true;
1068		-	return false;
1069		-	}
	1101	+	return jj_3R_15();
	1102	+	}
1070	1103
1071	1104		/** Generated Token Manager. */
1072	1105		public FilterParserTokenManager token_source;
		skipped 6 lines
1079	1112		private Token jj_scanpos, jj_lastpos;
1080	1113		private int jj_la;
1081	1114		private int jj_gen;
1082		-	final private int[] jj_la1 = new int[29];
	1115	+	final private int[] jj_la1 = new int[30];
1083	1116		static private int[] jj_la1_0;
1084	1117		static private int[] jj_la1_1;
1085	1118		static {
		skipped 1 lines
1087	1120		jj_la1_init_1();
1088	1121		}
1089	1122		private static void jj_la1_init_0() {
1090		-	jj_la1_0 = new int[] {0x200000,0x100000,0x280000,0x8000000,0x700,0x700,0x800000,0x30a36000,0x804000,0x30804000,0x1000000,0x30030000,0x418fc,0x30236000,0x30004000,0x4000000,0x30004000,0x40000000,0x80000000,0x0,0x0,0x30000000,0x80000000,0x0,0x30000000,0x30000,0x200000,0xc,0xf0,};
	1123	+	jj_la1_0 = new int[] {0x200000,0x100000,0x280000,0x8000000,0x700,0x700,0x800000,0x30a36000,0x30804000,0x30804000,0x1000000,0x30030000,0x418fc,0x30236000,0x30004000,0x4000000,0x30004000,0x30000000,0x40000000,0x80000000,0x0,0x0,0x30000000,0x80000000,0x0,0x30000000,0x30000,0x200000,0xc,0xf0,};
1091	1124		}
1092	1125		private static void jj_la1_init_1() {
1093		-	jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,};
	1126	+	jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,};
1094	1127		}
1095		-	final private JJCalls[] jj_2_rtns = new JJCalls[3];
	1128	+	final private JJCalls[] jj_2_rtns = new JJCalls[4];
1096	1129		private boolean jj_rescan = false;
1097	1130		private int jj_gc = 0;
1098	1131
		skipped 8 lines
1107	1140		token = new Token();
1108	1141		jj_ntk = -1;
1109	1142		jj_gen = 0;
1110		-	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
	1143	+	for (int i = 0; i < 30; i++) jj_la1[i] = -1;
1111	1144		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1112	1145		}
1113	1146
		skipped 9 lines
1123	1156		jj_ntk = -1;
1124	1157		jjtree.reset();
1125	1158		jj_gen = 0;
1126		-	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
	1159	+	for (int i = 0; i < 30; i++) jj_la1[i] = -1;
1127	1160		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1128	1161		}
1129	1162
		skipped 4 lines
1134	1167		token = new Token();
1135	1168		jj_ntk = -1;
1136	1169		jj_gen = 0;
1137		-	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
	1170	+	for (int i = 0; i < 30; i++) jj_la1[i] = -1;
1138	1171		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1139	1172		}
1140	1173
		skipped 13 lines
1154	1187		jj_ntk = -1;
1155	1188		jjtree.reset();
1156	1189		jj_gen = 0;
1157		-	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
	1190	+	for (int i = 0; i < 30; i++) jj_la1[i] = -1;
1158	1191		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1159	1192		}
1160	1193
		skipped 3 lines
1164	1197		token = new Token();
1165	1198		jj_ntk = -1;
1166	1199		jj_gen = 0;
1167		-	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
	1200	+	for (int i = 0; i < 30; i++) jj_la1[i] = -1;
1168	1201		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1169	1202		}
1170	1203
		skipped 4 lines
1175	1208		jj_ntk = -1;
1176	1209		jjtree.reset();
1177	1210		jj_gen = 0;
1178		-	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
	1211	+	for (int i = 0; i < 30; i++) jj_la1[i] = -1;
1179	1212		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1180	1213		}
1181	1214
		skipped 124 lines
1306	1339		la1tokens[jj_kind] = true;
1307	1340		jj_kind = -1;
1308	1341		}
1309		-	for (int i = 0; i < 29; i++) {
	1342	+	for (int i = 0; i < 30; i++) {
1310	1343		if (jj_la1[i] == jj_gen) {
1311	1344		for (int j = 0; j < 32; j++) {
1312	1345		if ((jj_la1_0[i] & (1<<j)) != 0) {
		skipped 40 lines
1353	1386
1354	1387		private void jj_rescan_token() {
1355	1388		jj_rescan = true;
1356		-	for (int i = 0; i < 3; i++) {
	1389	+	for (int i = 0; i < 4; i++) {
1357	1390		try {
1358	1391		JJCalls p = jj_2_rtns[i];
1359	1392
		skipped 4 lines
1364	1397		case 0: jj_3_1(); break;
1365	1398		case 1: jj_3_2(); break;
1366	1399		case 2: jj_3_3(); break;
	1400	+	case 3: jj_3_4(); break;
1367	1401		}
1368	1402		}
1369	1403		p = p.next;
		skipped 28 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/FilterParserTokenManager.java

		skipped 8 lines
9	9		import java.util.Arrays;
10	10		import java.util.LinkedHashSet;
11	11		import java.util.Set;
	12	+	import java.util.Date;
12	13		import java.util.ArrayList;
13	14		import java.util.regex.Pattern;
14	15		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
15	16		import com.nccgroup.loggerplusplus.logentry.FieldGroup;
	17	+	import com.nccgroup.loggerplusplus.logentry.LogManager;
16	18		import static com.nccgroup.loggerplusplus.logentry.LogEntryField.getFieldsInGroup;
17	19
18	20		/** Token Manager. */
		skipped 1172 lines

Add date handling to filter definition and evaluation