private void compareStartElement(XMLStreamReader orig, XMLStreamReader actual) throws Exception { Assert.assertEquals("Start element is not matched", orig.getName(), actual.getName()); int origAttrCount = orig.getAttributeCount(); int actualAttrCount = actual.getAttributeCount(); for (int i = 0; i < origAttrCount; i++) { QName origAttrName = orig.getAttributeName(i); if ((origAttrName.getLocalPart().equals("location")) || (origAttrName.getLocalPart().equals("schemaLocation"))) { // skip this atribute origAttrCount--; } else { Assert.assertEquals( "Attribute " + origAttrName + " not found or value not matching", orig.getAttributeValue(origAttrName.getNamespaceURI(), origAttrName.getLocalPart()), actual.getAttributeValue(origAttrName.getNamespaceURI(), origAttrName.getLocalPart())); } } for (int i = 0; i < actualAttrCount; i++) { QName actualAttrName = actual.getAttributeName(i); if ((actualAttrName.getLocalPart().equals("location")) || (actualAttrName.getLocalPart().equals("schemaLocation"))) { // skip this atribute actualAttrCount--; } } Assert.assertEquals( "Attribute count is not matched for element " + orig.getName(), origAttrCount, actualAttrCount); }
/** * Returns the attributes of the element that the given {@link XMLStreamReader} points to. * * @param reader xml stream, must not be <code>null</code> and point to a {@link * XMLStreamConstants#START_ELEMENT} * @return attributes of the element, can be empty, but never <code>null</code> */ public static Map<QName, String> getAttributes(XMLStreamReader reader) { HashMap<QName, String> attrs = new HashMap<QName, String>(); for (int i = 0; i < reader.getAttributeCount(); i++) { attrs.put(reader.getAttributeName(i), reader.getAttributeValue(i)); } return attrs; }
public QName getAttributeName(int index) { if (state == STATE_START_DOCUMENT || state == STATE_END_DOCUMENT) { throw new IllegalStateException(); } else { return parent.getAttributeName(index); } }
private static void parsePath( final XMLStreamReader reader, final boolean include, final MultiplePathFilterBuilder builder) throws XMLStreamException { String path = null; final Set<Attribute> required = EnumSet.of(Attribute.PATH); final int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); required.remove(attribute); switch (attribute) { case PATH: path = reader.getAttributeValue(i); break; default: throw unexpectedContent(reader); } } if (!required.isEmpty()) { throw missingAttributes(reader.getLocation(), required); } builder.addFilter(PathFilters.match(path), include); // consume remainder of element parseNoContent(reader); }
public void parseAttributes(XMLStreamReader parser) { for (int i = 0; i < parser.getAttributeCount(); i++) { QName attr = parser.getAttributeName(i); if (attr.getLocalPart().equals("id")) { id = parser.getAttributeValue(i); } else if (attr.getLocalPart().equals("name")) { name = parser.getAttributeValue(i); } } }
public static String getAttributeByLocalName(XMLStreamReader reader, String localName) { String result = ""; for (int i = 0; i < reader.getAttributeCount(); i++) { QName attribute = reader.getAttributeName(i); if (attribute != null && attribute.getLocalPart().equals(localName)) { result = reader.getAttributeValue(i); } } return result; }
private void doParsing(XMLStreamReader parser) throws XMLStreamException { for (int i = 0; i < parser.getAttributeCount(); i++) { QName attr = parser.getAttributeName(i); if (attr.getLocalPart().equals("source")) { source = XMLIDREFUtils.parse(parser.getAttributeValue(i)); } else { JAGTLog.exception( "Unsupported ", this.getClass().getSimpleName(), " Attr tag: ", attr.getLocalPart()); } } for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) { switch (event) { case XMLStreamConstants.START_ELEMENT: { String localName = parser.getLocalName(); if (localName.equals("source")) { XMLSource src = new XMLSource(); src.parse(parser); sources.add(src); } else if (localName.equals("bind_shape_matrix")) { if (bindShapeMatrix != null) { JAGTLog.exception( this.getClass().getSimpleName(), " too many bind_shape_matrix tags."); } bindShapeMatrix = XMLMatrixUtils.readColumnMajor(StAXHelper.parseText(parser)); // bindShapeMatrix = XMLMatrixUtils.readRowMajor( StAXHelper.parseText( parser ) ); } else if (localName.equals("joints")) { jointsInputs = getJointInputs(parser); } else if (localName.equals("vertex_weights")) { vertexWeights = new XMLVertexWeights(); vertexWeights.parse(parser); } else { JAGTLog.exception( "Unsupported ", this.getClass().getSimpleName(), " Start tag: ", parser.getLocalName()); } break; } case XMLStreamConstants.END_ELEMENT: { if (parser.getLocalName().equals("skin")) { return; } break; } } } }
/** * Method to get a HashMap of XML attributes and values * * @param reader an XMLStreamReader object * @return a HashMap of attributes */ private HashMap<QName, String> getAttributes(XMLStreamReader reader) { HashMap<QName, String> rawAttributesMap = new HashMap<QName, String>(); int attributeCount = reader.getAttributeCount(); for (int i = 0; i < attributeCount; i++) { QName attributeQName = reader.getAttributeName(i); String attributeValue = reader.getAttributeValue(i); if (log.isTraceEnabled()) log.trace("attributeQName: " + attributeQName + " attributeValue: " + attributeValue); rawAttributesMap.put(attributeQName, attributeValue); } return rawAttributesMap; }
public void parse(XMLStreamReader parser) throws XMLStreamException { for (int i = 0; i < parser.getAttributeCount(); i++) { QName attr = parser.getAttributeName(i); if (attr.getLocalPart().equals("id")) { id = parser.getAttributeValue(i); } else if (attr.getLocalPart().equals("name")) { name = parser.getAttributeValue(i); } else { JAGTLog.exception( "Unsupported ", this.getClass().getSimpleName(), " Attr tag: ", parser.getLocalName()); } } for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) { switch (event) { case XMLStreamConstants.START_ELEMENT: { String localName = parser.getLocalName(); if (localName.equals("geometry")) { parseAttributes(parser); } else if (localName.equals("asset")) { asset = new XMLAsset(); asset.parse(parser); } else if (localName.equals("mesh")) { mesh = new XMLMesh(); mesh.parse(parser); } else { JAGTLog.exception( "Unsupported ", this.getClass().getSimpleName(), " Start tag: ", parser.getLocalName()); } break; } case XMLStreamConstants.END_ELEMENT: { if (parser.getLocalName().equals("geometry")) return; break; } } } }
private static void printAttributes(XMLStreamReader xmlr) { if (xmlr.getAttributeCount() > 0) { int count = xmlr.getAttributeCount(); for (int i = 0; i < count; i++) { QName name = xmlr.getAttributeName(i); String namespace = xmlr.getAttributeNamespace(i); String type = xmlr.getAttributeType(i); String prefix = xmlr.getAttributePrefix(i); String value = xmlr.getAttributeValue(i); System.out.println( "\tAttribute: {" + namespace + "}:" + name.toString() + "(" + type + ")=" + value); } } }
private String parseName(final XMLStreamReader reader) throws XMLStreamException { final int count = reader.getAttributeCount(); String name = null; final Set<Attribute> required = EnumSet.of(Attribute.NAME); for (int i = 0; i < count; i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); required.remove(attribute); switch (attribute) { case NAME: name = reader.getAttributeValue(i); break; default: throw ParsingUtils.unexpectedContent(reader); } } if (!required.isEmpty()) { throw ParsingUtils.missingAttributes(reader.getLocation(), required); } ParsingUtils.parseNoContent(reader); return propertyReplacer.replaceProperties(name); }
private Artifact parseArtifact(final XMLStreamReader reader) throws XMLStreamException { final int count = reader.getAttributeCount(); String groupId = null; String artifactId = null; String version = null; String classifier = null; String extension = null; final Set<Attribute> required = EnumSet.of(Attribute.GROUP_ID, Attribute.ARTIFACT_ID, Attribute.VERSION); for (int i = 0; i < count; i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); required.remove(attribute); switch (attribute) { case GROUP_ID: groupId = propertyReplacer.replaceProperties(reader.getAttributeValue(i)); break; case ARTIFACT_ID: artifactId = propertyReplacer.replaceProperties(reader.getAttributeValue(i)); break; case VERSION: version = propertyReplacer.replaceProperties(reader.getAttributeValue(i)); break; case CLASSIFIER: classifier = propertyReplacer.replaceProperties(reader.getAttributeValue(i)); break; case EXTENSION: extension = propertyReplacer.replaceProperties(reader.getAttributeValue(i)); break; default: throw ParsingUtils.unexpectedContent(reader); } } if (!required.isEmpty()) { throw ParsingUtils.missingAttributes(reader.getLocation(), required); } ParsingUtils.parseNoContent(reader); return new Artifact(groupId, artifactId, classifier, extension, version); }
private static void parseMainClass( final XMLStreamReader reader, final ModuleSpec.Builder specBuilder) throws XMLStreamException { String name = null; final Set<Attribute> required = EnumSet.of(Attribute.NAME); final int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); required.remove(attribute); switch (attribute) { case NAME: name = reader.getAttributeValue(i); break; default: throw unexpectedContent(reader); } } if (!required.isEmpty()) { throw missingAttributes(reader.getLocation(), required); } specBuilder.setMainClass(name); // consume remainder of element parseNoContent(reader); }
private Element(XMLStreamReader stream, Element parent) throws XMLStreamException { // We assume that the stream points to the start of the modelled element if (stream.getEventType() != XMLStreamConstants.START_ELEMENT) { throw new AssertionError(); } // QName name = stream.getName(); Location location = stream.getLocation(); // Map<String, String> attributes = Collections.emptyMap(); Map<QName, String> qualifiedAttributes = Collections.emptyMap(); int attributeCount = stream.getAttributeCount(); for (int i = 0; i < attributeCount; i++) { String attributeValue = stream.getAttributeValue(i); QName attributeName = stream.getAttributeName(i); if (XMLConstants.NULL_NS_URI.equals(attributeName.getNamespaceURI())) { if (attributes.isEmpty()) { attributes = new HashMap<String, String>(); } attributes.put(attributeName.getLocalPart(), attributeValue); } else { if (qualifiedAttributes.isEmpty()) { qualifiedAttributes = new HashMap<QName, String>(); } qualifiedAttributes.put(attributeName, attributeValue); } } // Map<String, String> namespaces; int namespaceCount = stream.getNamespaceCount(); if (namespaceCount > 0) { namespaces = new HashMap<String, String>(); for (int i = 0; i < namespaceCount; i++) { String namespacePrefix = stream.getNamespacePrefix(i); if (namespacePrefix == null) { namespacePrefix = ""; } String namespaceURI = stream.getNamespaceURI(i); namespaces.put(namespacePrefix, namespaceURI); } } else { namespaces = Collections.emptyMap(); } // When we leave we assume that we are positionned on the next element start or the document // end StringBuilder sb = null; String chunk = null; Object content = null; while (true) { stream.next(); int type = stream.getEventType(); if (type == XMLStreamConstants.END_DOCUMENT || type == XMLStreamConstants.START_ELEMENT) { break; } else if (type == XMLStreamConstants.CHARACTERS) { if (chunk == null) { chunk = stream.getText(); } else { if (sb == null) { sb = new StringBuilder(chunk); } sb.append(stream.getText()); } } else if (type == XMLStreamConstants.END_ELEMENT) { if (sb != null) { content = sb; } else { content = chunk; } break; } } // int depth = 1 + (parent != null ? parent.getDepth() : 0); // this.parent = parent; this.name = name; this.depth = depth; this.content = content; this.attributes = attributes; this.qualifiedAttributes = qualifiedAttributes; this.namespaces = namespaces; this.location = location; }
public QName getAttributeName(final int index) { return streamReader.getAttributeName(index); }
private static void parseModuleContents( final File root, final XMLStreamReader reader, final ModuleSpec.Builder specBuilder) throws XMLStreamException { final int count = reader.getAttributeCount(); String name = null; String slot = null; final Set<Attribute> required = EnumSet.of(Attribute.NAME); for (int i = 0; i < count; i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); required.remove(attribute); switch (attribute) { case NAME: name = reader.getAttributeValue(i); break; case SLOT: slot = reader.getAttributeValue(i); break; default: throw unexpectedContent(reader); } } if (!required.isEmpty()) { throw missingAttributes(reader.getLocation(), required); } if (!specBuilder.getIdentifier().equals(ModuleIdentifier.create(name, slot))) { throw invalidModuleName(reader.getLocation(), specBuilder.getIdentifier()); } // xsd:all Set<Element> visited = EnumSet.noneOf(Element.class); while (reader.hasNext()) { switch (reader.nextTag()) { case XMLStreamConstants.END_ELEMENT: { specBuilder.addDependency(DependencySpec.createLocalDependencySpec()); return; } case XMLStreamConstants.START_ELEMENT: { final Element element = Element.of(reader.getName()); if (visited.contains(element)) { throw unexpectedContent(reader); } visited.add(element); switch (element) { case DEPENDENCIES: parseDependencies(reader, specBuilder); break; case MAIN_CLASS: parseMainClass(reader, specBuilder); break; case RESOURCES: parseResources(root, reader, specBuilder); break; default: throw unexpectedContent(reader); } break; } default: { throw unexpectedContent(reader); } } } throw endOfDocument(reader.getLocation()); }
private static void parseModuleDependency( final XMLStreamReader reader, final ModuleSpec.Builder specBuilder) throws XMLStreamException { String name = null; String slot = null; boolean export = false; boolean optional = false; final Set<Attribute> required = EnumSet.of(Attribute.NAME); final int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); required.remove(attribute); switch (attribute) { case NAME: name = reader.getAttributeValue(i); break; case SLOT: slot = reader.getAttributeValue(i); break; case EXPORT: export = Boolean.parseBoolean(reader.getAttributeValue(i)); break; case OPTIONAL: optional = Boolean.parseBoolean(reader.getAttributeValue(i)); break; default: throw unexpectedContent(reader); } } if (!required.isEmpty()) { throw missingAttributes(reader.getLocation(), required); } final MultiplePathFilterBuilder importBuilder = PathFilters.multiplePathFilterBuilder(true); final MultiplePathFilterBuilder exportBuilder = PathFilters.multiplePathFilterBuilder(true); while (reader.hasNext()) { switch (reader.nextTag()) { case XMLStreamConstants.END_ELEMENT: { final PathFilter exportFilter = export ? exportBuilder.create() : PathFilters.rejectAll(); final PathFilter importFilter = importBuilder.create(); specBuilder.addDependency( DependencySpec.createModuleDependencySpec( importFilter, exportFilter, null, ModuleIdentifier.create(name, slot), optional)); return; } case XMLStreamConstants.START_ELEMENT: { switch (Element.of(reader.getName())) { case EXPORTS: parseFilterList(reader, exportBuilder); break; case IMPORTS: parseFilterList(reader, importBuilder); break; default: throw unexpectedContent(reader); } break; } default: { throw unexpectedContent(reader); } } } }
public QName getAttributeName(int index) { return reader.getAttributeName(index); }
private static void parseResourceRoot( final File root, final XMLStreamReader reader, final ModuleSpec.Builder specBuilder) throws XMLStreamException { final ModuleIdentifier identifier = specBuilder.getIdentifier(); String name = null; String path = null; final Set<Attribute> required = EnumSet.of(Attribute.PATH); final int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); required.remove(attribute); switch (attribute) { case NAME: name = reader.getAttributeValue(i); break; case PATH: path = reader.getAttributeValue(i); break; default: throw unexpectedContent(reader); } } if (!required.isEmpty()) { throw missingAttributes(reader.getLocation(), required); } if (name == null) name = path; // todo add to spec final File file = new File(root, path); final ResourceLoader resourceLoader; final MultiplePathFilterBuilder builder = PathFilters.multiplePathFilterBuilder(true); while (reader.hasNext()) { switch (reader.nextTag()) { case XMLStreamConstants.END_ELEMENT: { final PathFilter exportFilter = builder.create(); if (file.isDirectory()) { resourceLoader = new FileResourceLoader(identifier, file, name, exportFilter); } else { try { resourceLoader = new JarFileResourceLoader(identifier, new JarFile(file), name, exportFilter); } catch (IOException e) { throw new XMLStreamException("Invalid JAR file specified", reader.getLocation(), e); } } specBuilder.addResourceRoot(resourceLoader); return; } case XMLStreamConstants.START_ELEMENT: { switch (Element.of(reader.getName())) { case EXPORTS: parseFilterList(reader, builder); break; default: throw unexpectedContent(reader); } break; } default: { throw unexpectedContent(reader); } } } }