/** * Creates a new {@code AtomEntry} instance. * * @return A new {@code AtomEntry} instance. */ static AtomEntry create() { return new AtomEntry(); }
/** * Creates a new {@code AtomEntry} instance based on a given XML reader. * * @param reader The XML reader. * @return An {@code AtomEntry} instance representing the parsed XML. */ static AtomEntry parse(XMLStreamReader reader) { AtomEntry entry = AtomEntry.create(); entry.load(reader, "entry"); return entry; }
/** * Parses a {@code <list>} element and returns a {@code List} object * containing the parsed values. * * @param reader The XML reader. * @return A {@code List} object containing the parsed values. */ private List parseList(XMLStreamReader reader) { assert isStartElement(reader, "list"); List result = new ArrayList(); scan(reader); while (isStartElement(reader, "item")) { Object value = parseValue(reader); result.add(value); } if (!isEndElement(reader, "list")) syntaxError(reader); scan(reader); // Consume </list> return result; }
/** * Parses the {@code <content>} element of an Atom entry. * * @param reader The XML reader. * @return A {@code Record} object containing the parsed values. */ private Record parseContent(XMLStreamReader reader) { assert isStartElement(reader, "content"); scan(reader); // The content element should contain a single <dict> element if (!isStartElement(reader, "dict")) syntaxError(reader); content = parseDict(reader); if (!isEndElement(reader, "content")) syntaxError(reader); scan(reader); // Consume </content> return content; }
private Object parseStructure(XMLStreamReader reader) { String name = reader.getLocalName(); if (name.equals("dict")) return parseDict(reader); if (name.equals("list")) return parseList(reader); syntaxError(reader); return null; // Unreached }
scan(reader); case XMLStreamConstants.CHARACTERS: value = reader.getText(); scan(reader); // Advance cursor break; value = parseStructure(reader); break; syntaxError(reader); if (!isEndElement(reader, name)) syntaxError(reader); scan(reader); // Consume end element
/** * Creates a new {@code AtomEntry} instance based on a given stream. * A few endpoints, such as {@code search/jobs/{sid}}, * return an Atom {@code <entry>} element as the root of the response. * * @param input The input stream. * @return An {@code AtomEntry} instance representing the parsed stream. */ public static AtomEntry parseStream(InputStream input) { XMLStreamReader reader = createReader(input); AtomEntry result = AtomEntry.parse(reader); try { reader.close(); } catch (XMLStreamException e) { throw new RuntimeException(e.getMessage(), e); } return result; }
/** * Initializes the current instance using the given XML reader. * * @param reader The XML reader. */ @Override void init(XMLStreamReader reader) { assert reader.isStartElement(); String name = reader.getLocalName(); if (name.equals("published")) { this.published = parseText(reader); } else if (name.equals("content")) { this.content = parseContent(reader); } else { super.init(reader); } }
AtomEntry entry = AtomEntry.parse(reader); this.entries.add(entry);
/** * Parses a {@code <dict>} content element and returns a {@code Record} * object containing the parsed values. * * @param reader The {@code <dict>} element to parse. * @return A {@code Record} object containing the parsed values. */ private Record parseDict(XMLStreamReader reader) { assert isStartElement(reader, "dict"); Record result = new Record(); scan(reader); while (isStartElement(reader, "key")) { String key = reader.getAttributeValue(null, "name"); Object value = parseValue(reader); // Null values, the result of empty elements, are parsed as though // they don't exist, making it easier for the client framework to // supply more meaningful default values. if (value != null) result.put(key, value); } if (!isEndElement(reader, "dict")) syntaxError(reader); scan(reader); // Consume </dict> return result; }