@Override public List<T> parse(ParserState input) throws ParseException { List<T> results = new ArrayList<>(); do { T val = Parsers.gingerly(valueParser).parse(input); if (!Parsers.nullOrUnexpected(val)) { results.add(val); } else { break; } } while (Parsers.gingerly(separator).parse(input) != null); return results; }
/** * Runs the whitespace parser followed by `parser`, returning result of the latter. * * @param <T> the type the target parser returns * @param parser the target parser to run * @return the specified parser */ public static <T> Parser<T> whitespace(Parser<T> parser) { return prefix(whitespace(), parser); }
@Override public MapType parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect("map").parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } Parser<KeyValue<ConjureType, ConjureType>> kv = Parsers.liberalBetween( "<", new KeyValueParser<>( Parsers.whitespace(TypeParser.INSTANCE), Parsers.whitespace(Parsers.expect(",")), Parsers.whitespace(TypeParser.INSTANCE)), ">"); KeyValue<ConjureType, ConjureType> types = kv.parse(input); ConjureMetrics.incrementCounter(MapType.class); return MapType.of(types.getKey(), types.getValue()); } }
public static <T> BetweenParser<T> liberalBetween(String start, Parser<T> parser, String end) { return new BetweenParser<T>(whitespace(expect(start)), whitespace(parser), whitespace(expect(end))); }
@Override public SetType parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect("set").parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } ConjureType itemType = Parsers.liberalBetween("<", TypeParser.INSTANCE, ">").parse(input); ConjureMetrics.incrementCounter(SetType.class); return SetType.of(itemType); } }
@Override public T parse(ParserState input) throws ParseException { T lastResult = null; while (input.curr() != -1) { String directive = Parsers.gingerly(inputStringParser).parse(input); if (Parsers.nullOrEmpty(directive)) { break; } else if (parserLookup.containsKey(directive)) { lastResult = parserLookup.get(directive).parse(input); } else { throw new ParseException("Unknown directive '" + directive + "'.", input); } } return lastResult; }
public ConjureType parse(String input) throws ParseException { ParserState inputParserState = new StringParserState(input); ConjureType resultType = Parsers.eof(typeParser()).parse(inputParserState); if (resultType == null) { throw new ParseException(input, inputParserState); } return parse(new StringParserState(input)); }
@Override public T parse(ParserState input) throws ParseException { T result = gingerly(firstOption).parse(input); if (result != null) { return result; } for (Parser<? extends T> nextOption : otherOptions) { result = gingerly(nextOption).parse(input); if (result != null) { return result; } } return result; } };
@Test public void testDispatchingParser() throws ParseException { Map<String, Parser<String>> map = new HashMap<String, Parser<String>>(); map.put("dir1", new RawStringParser()); map.put("dir2", new QuotedStringParser()); assertEquals("def", new DispatchingParser<String>(map, Parsers.whitespace()) .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))); assertEquals("def", new DispatchingParser<String>(map, Parsers.whitespace()) .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))); }
@Override public T parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect(type).parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } ConjureMetrics.incrementCounter(metric); return instance; }
private Parser<ConjureType> typeParser() { return Parsers.or( MapTypeParser.INSTANCE, ListTypeParser.INSTANCE, SetTypeParser.INSTANCE, OptionalTypeParser.INSTANCE, TypeFromString.of("any", AnyType.of(), AnyType.class), TypeFromString.of("binary", BinaryType.of(), BinaryType.class), TypeFromString.of("datetime", DateTimeType.of(), DateTimeType.class), ForeignReferenceTypeParser.INSTANCE, TypeReferenceParser.INSTANCE); }
public DefaultingDispatchingParser(Map<String, Parser<T>> parsers, Parser<String> directiveParser, Parser<?> whitespaceParser) { this.map = new HashMap<String, Parser<T>>(parsers); if (whitespaceParser == null) { inputStringParser = directiveParser; this.map.putAll(parsers); } else { inputStringParser = Parsers.prefix(whitespaceParser, directiveParser); for (Entry<String, Parser<T>> entry : parsers.entrySet()) { this.map.put(entry.getKey(), Parsers.prefix(whitespaceParser, entry.getValue())); } } }
@Override public T parse(ParserState input) throws ParseException { // First, consume the thing you expect to find at the beginning. // This is likely to be a string constant like "{". if (Parsers.nullOrUnexpected(start.parse(input))) { // TODO(melliot): improve this exception throw new ParseException("Expected startToken", input); } // Then, consume the thing you expect to find in the middle. // This is likely to be done with a more complicated parser // such as DispatchingParser. T item = parser.parse(input); // Finally, consume the thing you expect to find at the end. // This is likely to be a string constant like "}". if (Parsers.nullOrUnexpected(end.parse(input))) { // TODO(melliot): improve this exception throw new ParseException("Expected endToken", input); } // The thing we care about was in the middle. // Parser<?>, and return the T.) return item; }
@Override public Boolean parse(ParserState input) throws ParseException { String val = new RawStringParser().parse(input); return !Parsers.nullOrEmpty(val) && (val.equalsIgnoreCase("true") || val.equalsIgnoreCase("yes") || val.equalsIgnoreCase("1")); }
@Override public OptionalType parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect("optional").parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } ConjureType itemType = Parsers.liberalBetween("<", TypeParser.INSTANCE, ">").parse(input); ConjureMetrics.incrementCounter(OptionalType.class); return OptionalType.of(itemType); } }
String directive = Parsers.gingerly(inputStringParser).parse(input); if (Parsers.nullOrEmpty(directive)) {
@Test public void testEofParserFails() throws ParseException { assertNull(Parsers.eof(new ExpectantParser("abc")) .parse(new StringParserState("abcdef"))); }
@Test public void testGingerlyBooleanFalse() throws ParseException { StringParserState state = new StringParserState("false 123"); assertEquals(Boolean.FALSE, Parsers.gingerly(bp).parse(state)); assertEquals("123", rsp.parse(state)); }
@Test public void testListParser() throws ParseException { List<String> list = new ArrayList<>(); list.add("abc"); list.add("def"); assertEquals(list, new ListParser<>(new QuotedStringParser(), Parsers.whitespace()) .parse(new StringParserState("\"abc\" \"def\""))); }