Parsers

Parsers work by parsing input directly into POJOs instead of having to create intermediate Document Object Models. This allows them to parse input with minimal object creation.

Like the serializers, you can often parse objects in one line of code by using one of the default parsers:

// Use one of the predefined parsers. Parser parser = JsonParser. DEFAULT; // Parse a JSON object as a bean. String json = "{name:'John Smith',age:21}"; Person p = parser.parse(json, Person. class); // Or parse it into a generic Map. Map m1 = parser.parse(json, Map. class); // Parse a JSON string. json = "'foobar'"; String s2 = parser.parse(json, String. class); // Parse a JSON number as a Long or Float. json = "123"; Long l3 = parser.parse(json, Long. class); Float f3 = parser.parse(json, Float. class); // Parse a JSON object as a HashMap<String,Person>. json = "{a:{name:'John Smith',age:21},b:{name:'Joe Smith',age:42}}"; Map<String,Person> m4 = parser.parse(json, HashMap. class, String. class, Person. class) // Parse a JSON object as a HashMap<String,LinkedList<Person>>. json = "{a:[{name:'John Smith',age:21},{name:'Joe Smith',age:42}]}"; Map<String,List<Person>> m5 = parser.parse(json, HashMap. class, String. class, LinkedList. class, Person. class) // Parse a JSON array of integers as a Collection of Integers or int[] array. json = "[1,2,3]"; List<Integer> l6 = parser.parse(json, LinkedList. class, Integer. class); int[] i7 = parser.parse(json, int[].class);

The parsers can also be used to populating existing bean and collection objects:

// Use one of the predefined parsers. Parser parser = JsonParser. DEFAULT; // Populate the properties on an existing bean from a JSON object. String json = "{name:'John Smith',age:21}"; Person p = new Person(); parser.parseIntoBean(json, p); // Populate an existing list from a JSON array of numbers. json = "[1,2,3]"; List<Integer> l2 = new LinkedList<Integer>(); parser.parseIntoCollection(json, l2, Integer. class); // Populate an existing map from a JSON object containing beans. json = "{a:{name:'John Smith',age:21},b:{name:'Joe Smith',age:42}}"; Map<String,Person> m3 = new TreeMap<String,Person>(); parser.parseIntoMap(json, m3, String. class, Person. class);

- In the example above, we're parsing "lax" JSON (single quotes, unquoted attributes). The JSON parser can handle any valid JSON syntax (such as quoted or unquoted attributes, single or double quotes).
  It can also handle JSON fragments and embedded Javascript comments. Many of the JSON examples provided will use lax syntax which is easier to read since we don't have to deal with escapes.

The class hierarchy for the parsers (excluding specialized subclasses) are:

- {@link oaj.parser.Parser}
  - {@link oaj.parser.ReaderParser}
    - {@link oaj.json.JsonParser}
    - {@link oaj.plaintext.PlainTextParser}
    - {@link oaj.jena.RdfParser}
      - {@link oaj.jena.RdfXmlParser}
      - {@link oaj.jena.N3Parser}
      - {@link oaj.jena.NTripleParser}
      - {@link oaj.jena.TurtleParser}
    - {@link oaj.uon.UonParser}
      - {@link oaj.oapi.OpenApiParser}
      - {@link oaj.urlencoding.UrlEncodingParser}
    - {@link oaj.xml.XmlParser}
      - {@link oaj.html.HtmlParser}
  - {@link oaj.parser.InputStreamParser}
    - {@link oaj.jso.JsoParser}
    - {@link oaj.msgpack.MsgPackParser}