/**
* Serialize object to XML and output it to given OutputStream
*
* @param object objec to marshal
* @param outputStream stream to put the resulting XML to
*/
public void marshal(Object object, OutputStream outputStream) {
try {
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true);
ByteArrayOutputStream tempOutput = null;
XMLStreamWriter writer = null;
if (autoIndent) {
tempOutput = new ByteArrayOutputStream();
writer = outputFactory.createXMLStreamWriter(tempOutput);
} else {
writer = outputFactory.createXMLStreamWriter(outputStream);
}
// if (autoIndent) {
// writer = new IndentingXMLStreamWriterDecorator(writer);
// }
writerContext.writer = writer;
writer.writeStartDocument();
marshalObject(writer, object);
writer.writeEndDocument();
writer.close();
if (autoIndent) {
Transformer transformer = TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
transformer.setOutputProperty("doctype-public", "yes");
transformer.transform(
new StreamSource(new ByteArrayInputStream(tempOutput.toByteArray())),
new StreamResult(outputStream));
}
} catch (TransformerException ex) {
throw new XmlizerException("Error whule indenting XML", ex);
} catch (XMLStreamException ex) {
throw new XmlizerException("Error occured while writting", ex);
} catch (IllegalAccessException ex) {
throw new XmlizerException("Error while trying to read a property", ex);
} catch (IllegalArgumentException ex) {
throw new XmlizerException("Error while trying to read a property", ex);
} catch (InvocationTargetException ex) {
throw new XmlizerException("Error while trying to read a property", ex);
}
}
protected byte[] object2WbXml(
Object o,
WbXmlDefinition def,
WbXmlVersion version,
WbXmlEncoder.StrtblType encoderType,
boolean skipSpaces,
boolean event)
throws Exception {
XMLStreamWriter xmlStreamWriter = null;
XMLEventWriter xmlEventWriter = null;
ByteArrayOutputStream out = null;
try {
out = new ByteArrayOutputStream();
outFact.setProperty(WbXmlOutputFactory.ENCODING_TYPE_PROPERTY, encoderType);
outFact.setProperty(WbXmlOutputFactory.SKIP_SPACES_PROPERTY, skipSpaces);
outFact.setProperty(WbXmlOutputFactory.VERSION_PROPERTY, version);
outFact.setProperty(WbXmlOutputFactory.DEFINITION_PROPERTY, def);
if (event) {
xmlEventWriter = outFact.createXMLEventWriter(out);
} else {
xmlStreamWriter = outFact.createXMLStreamWriter(out);
}
JAXBContext jc = JAXBContext.newInstance(o.getClass());
Marshaller marshaller = jc.createMarshaller();
if (event) {
marshaller.marshal(o, xmlEventWriter);
} else {
marshaller.marshal(o, xmlStreamWriter);
}
return out.toByteArray();
} finally {
if (out != null) {
try {
out.close();
} catch (Exception e) {
}
}
if (xmlStreamWriter != null) {
try {
xmlStreamWriter.close();
} catch (Exception e) {
}
}
if (xmlEventWriter != null) {
try {
xmlEventWriter.close();
} catch (Exception e) {
}
}
}
}
protected byte[] doc2WbXml(
Document doc,
WbXmlDefinition def,
WbXmlVersion version,
WbXmlEncoder.StrtblType encoderType,
boolean skipSpaces,
boolean event)
throws Exception {
XMLStreamWriter xmlStreamWriter = null;
XMLEventWriter xmlEventWriter = null;
ByteArrayOutputStream out = null;
try {
out = new ByteArrayOutputStream();
outFact.setProperty(WbXmlOutputFactory.ENCODING_TYPE_PROPERTY, encoderType);
outFact.setProperty(WbXmlOutputFactory.SKIP_SPACES_PROPERTY, skipSpaces);
outFact.setProperty(WbXmlOutputFactory.VERSION_PROPERTY, version);
outFact.setProperty(WbXmlOutputFactory.DEFINITION_PROPERTY, def);
if (event) {
xmlEventWriter = outFact.createXMLEventWriter(out);
} else {
xmlStreamWriter = outFact.createXMLStreamWriter(out);
}
Transformer xformer = TransformerFactory.newInstance().newTransformer();
Source domSource = new DOMSource(doc);
StAXResult staxResult =
(event) ? new StAXResult(xmlEventWriter) : new StAXResult(xmlStreamWriter);
xformer.transform(domSource, staxResult);
return out.toByteArray();
} finally {
if (out != null) {
try {
out.close();
} catch (Exception e) {
}
}
if (xmlStreamWriter != null) {
try {
xmlStreamWriter.close();
} catch (Exception e) {
}
}
if (xmlEventWriter != null) {
try {
xmlEventWriter.close();
} catch (Exception e) {
}
}
}
}
public static void doXmlOutput(boolean useRepairing) throws XMLStreamException {
StringWriter buffer = new StringWriter();
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
if (useRepairing) {
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", Boolean.TRUE);
}
XMLStreamWriter out = outputFactory.createXMLStreamWriter(buffer);
out.writeStartDocument();
out.writeStartElement("env", "Envelope", SOAP12);
out.writeNamespace("env", SOAP12);
out.writeNamespace("test", "http://someTestUri");
out.writeStartElement("env", "Body", SOAP12);
out.writeStartElement("test");
out.writeAttribute("foo", "bar");
out.writeEndElement();
out.writeStartElement("test");
out.writeAttribute("foo", "bar");
out.writeCharacters("");
out.writeEndElement();
out.writeStartElement("test");
out.writeAttribute("foo", "bar");
out.writeCharacters(" ");
out.writeEndElement();
out.writeEndElement();
out.writeEndElement();
out.writeEndDocument();
out.close();
System.out.println("Created " + (useRepairing ? "" : "not") + " using repairing :-");
System.out.println(buffer);
}
/**
* @throws XMLStreamException
* @throws FactoryConfigurationError
* @throws IOException
* @throws UnknownCRSException
* @throws TransformationException
*/
@Test
public void testPoint2()
throws XMLStreamException, FactoryConfigurationError, IOException, TransformationException,
UnknownCRSException {
XMLStreamReaderWrapper xmlReader =
new XMLStreamReaderWrapper(this.getClass().getResource(BASE_DIR + POINT2_FILE));
xmlReader.nextTag();
Point point = new GML2GeometryReader().parsePoint(xmlReader, null);
Assert.assertEquals(5.0, point.get0(), DELTA);
Assert.assertEquals(30.0, point.get1(), DELTA);
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", new Boolean(true));
XMLMemoryStreamWriter memoryWriter = new XMLMemoryStreamWriter();
SchemaLocationXMLStreamWriter writer =
new SchemaLocationXMLStreamWriter(
memoryWriter.getXMLStreamWriter(), SCHEMA_LOCATION_ATTRIBUTE);
GML2GeometryWriter exporter = new GML2GeometryWriter(writer, null, null, new HashSet<String>());
writer.setPrefix("gml", "http://www.opengis.net/gml");
exporter.export(point);
writer.flush();
XMLAssert.assertValidity(memoryWriter.getReader(), SCHEMA_LOCATION);
}
public GenericDirectoryTester(String directory, WbXmlDefinition def) {
this.directory = directory;
this.def = def;
this.inFact = new WbXmlInputFactory();
inFact.setProperty(WbXmlInputFactory.DEFINITION_PROPERTY, def);
this.outFact = new WbXmlOutputFactory();
outFact.setProperty(WbXmlOutputFactory.DEFINITION_PROPERTY, def);
}
private static XMLOutputFactory getXMLOutputFactory() throws XMLStreamException {
if (_outputFactory == null) {
_outputFactory = XMLOutputFactory.newInstance();
_outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
}
return _outputFactory;
}
/**
* @throws XMLStreamException
* @throws FactoryConfigurationError
* @throws IOException
* @throws UnknownCRSException
* @throws TransformationException
*/
@Test
public void testPolygon()
throws XMLStreamException, FactoryConfigurationError, IOException, UnknownCRSException,
TransformationException {
XMLStreamReaderWrapper xmlReader =
new XMLStreamReaderWrapper(this.getClass().getResource(BASE_DIR + POLYGON_FILE));
xmlReader.nextTag();
Assert.assertEquals(XMLStreamConstants.START_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "Polygon"), xmlReader.getName());
Polygon polygon = new GML2GeometryReader().parsePolygon(xmlReader, null);
Assert.assertEquals(XMLStreamConstants.END_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "Polygon"), xmlReader.getName());
Points points = polygon.getExteriorRing().getControlPoints();
comparePoint(0.0, 0.0, points.get(0));
comparePoint(100.0, 0.0, points.get(1));
comparePoint(100.0, 100.0, points.get(2));
comparePoint(0.0, 100.0, points.get(3));
comparePoint(0.0, 0.0, points.get(4));
List<Points> innerPoints = polygon.getInteriorRingsCoordinates();
Points points1 = innerPoints.get(0);
comparePoint(10.0, 10.0, points1.get(0));
comparePoint(10.0, 40.0, points1.get(1));
comparePoint(40.0, 40.0, points1.get(2));
comparePoint(40.0, 10.0, points1.get(3));
comparePoint(10.0, 10.0, points1.get(4));
Points points2 = innerPoints.get(1);
comparePoint(60.0, 60.0, points2.get(0));
comparePoint(60.0, 90.0, points2.get(1));
comparePoint(90.0, 90.0, points2.get(2));
comparePoint(90.0, 60.0, points2.get(3));
comparePoint(60.0, 60.0, points2.get(4));
Assert.assertEquals(
CRSRegistry.lookup("http://www.opengis.net/gml/srs/epsg.xml#4326"),
polygon.getCoordinateSystem().getWrappedCRS());
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", new Boolean(true));
XMLMemoryStreamWriter memoryWriter = new XMLMemoryStreamWriter();
SchemaLocationXMLStreamWriter writer =
new SchemaLocationXMLStreamWriter(
memoryWriter.getXMLStreamWriter(), SCHEMA_LOCATION_ATTRIBUTE);
GML2GeometryWriter exporter = new GML2GeometryWriter(writer, null, null, new HashSet<String>());
writer.setPrefix("gml", "http://www.opengis.net/gml");
writer.setPrefix("xlink", "http://www.w3.org/1999/xlink");
exporter.export(polygon);
writer.flush();
XMLAssert.assertValidity(memoryWriter.getReader(), SCHEMA_LOCATION);
}
public static XMLStreamWriter create(OutputStream os) throws XmlSerializerException {
try {
XMLOutputFactory xof = XMLOutputFactory.newInstance();
xof.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true);
return xof.createXMLStreamWriter(os);
} catch (XMLStreamException e) {
throw new XmlSerializerException("Problem Creating a pull parser", e);
}
}
/**
* Copies the current node and its children to the <code>sink</code>.
*
* @param sink the output sink
*/
public void copyNode(OutputStream sink) throws XMLStreamException {
Assertion.notNull(sink);
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", isNsRepairing);
final XMLStreamWriter writer = outputFactory.createXMLStreamWriter(sink);
final DcsStreamSupport dcsStream = new DcsStreamSupport();
dcsStream.copyNode(in, writer);
writer.flush();
writer.close();
}
private void serializeValue(final HttpServletResponse pResponse, Object value)
throws TransformerException, IOException, FactoryConfigurationError {
if (value instanceof Source) {
setContentType(pResponse, "application/binary"); // Unknown content type
Sources.writeToStream((Source) value, pResponse.getOutputStream());
} else if (value instanceof Node) {
pResponse.setContentType("text/xml");
Sources.writeToStream(new DOMSource((Node) value), pResponse.getOutputStream());
} else if (value instanceof XmlSerializable) {
pResponse.setContentType("text/xml");
XMLOutputFactory factory = XMLOutputFactory.newInstance();
factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
try {
XmlWriter out =
XmlStreaming.newWriter(
pResponse.getOutputStream(), pResponse.getCharacterEncoding(), true);
try {
out.startDocument(null, null, null);
((XmlSerializable) value).serialize(out);
out.endDocument();
} finally {
out.close();
}
} catch (XmlException e) {
throw new TransformerException(e);
}
} else if (value instanceof Collection) {
final XmlElementWrapper annotation = getElementWrapper();
if (annotation != null) {
setContentType(pResponse, "text/xml");
try (OutputStream outStream = pResponse.getOutputStream()) {
writeCollection(
outStream, getGenericReturnType(), (Collection<?>) value, getQName(annotation));
}
}
} else if (value instanceof CharSequence) {
setContentType(pResponse, "text/plain");
pResponse.getWriter().append((CharSequence) value);
} else {
if (value != null) {
try {
final JAXBContext jaxbContext = JAXBContext.newInstance(getReturnType());
setContentType(pResponse, "text/xml");
final JAXBSource jaxbSource = new JAXBSource(jaxbContext, value);
Sources.writeToStream(jaxbSource, pResponse.getOutputStream());
} catch (final JAXBException e) {
throw new MessagingException(e);
}
}
}
}
/**
* @throws XMLStreamException
* @throws FactoryConfigurationError
* @throws IOException
* @throws UnknownCRSException
* @throws TransformationException
*/
@Test
public void testMultiGeometry()
throws XMLStreamException, FactoryConfigurationError, IOException, TransformationException,
UnknownCRSException {
XMLStreamReaderWrapper xmlReader =
new XMLStreamReaderWrapper(this.getClass().getResource(BASE_DIR + MULTIGEOMETRY_FILE));
xmlReader.nextTag();
Assert.assertEquals(XMLStreamConstants.START_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "MultiGeometry"), xmlReader.getName());
MultiGeometry<?> multiGeometry = new GML2GeometryReader().parseMultiGeometry(xmlReader, null);
assertEquals("c731", multiGeometry.getId());
Point firstMember = (Point) multiGeometry.get(0);
assertEquals("P6776", firstMember.getId());
comparePoint(50.0, 50.0, firstMember);
LineString secondMember = (LineString) multiGeometry.get(1);
assertEquals("L21216", secondMember.getId());
Points controlPoints = secondMember.getControlPoints();
comparePoint(0.0, 0.0, controlPoints.get(0));
comparePoint(0.0, 50.0, controlPoints.get(1));
comparePoint(100.0, 50.0, controlPoints.get(2));
Polygon thirdMember = (Polygon) multiGeometry.get(2);
assertEquals("_877789", thirdMember.getId());
Points points = thirdMember.getExteriorRing().getControlPoints();
comparePoint(0.0, 0.0, points.get(0));
comparePoint(100.0, 0.0, points.get(1));
comparePoint(50.0, 100.0, points.get(2));
comparePoint(0.0, 0.0, points.get(3));
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", new Boolean(true));
XMLMemoryStreamWriter memoryWriter = new XMLMemoryStreamWriter();
SchemaLocationXMLStreamWriter writer =
new SchemaLocationXMLStreamWriter(
memoryWriter.getXMLStreamWriter(), SCHEMA_LOCATION_ATTRIBUTE);
GML2GeometryWriter exporter = new GML2GeometryWriter(writer, null, null, new HashSet<String>());
writer.setPrefix("gml", "http://www.opengis.net/gml");
writer.setPrefix("xlink", "http://www.w3.org/1999/xlink");
exporter.export(multiGeometry);
writer.flush();
XMLAssert.assertValidity(memoryWriter.getReader(), SCHEMA_LOCATION);
}
protected static boolean setNamespaceAware(XMLOutputFactory f, boolean state)
throws XMLStreamException {
/* Let's not assert, but see if it sticks. Some implementations
* might choose to silently ignore setting, at least for 'false'?
*/
try {
f.setProperty(XMLStreamProperties.XSP_NAMESPACE_AWARE, state ? Boolean.TRUE : Boolean.FALSE);
return (isNamespaceAware(f) == state);
} catch (IllegalArgumentException e) {
/* Let's assume, then, that the property (or specific value for it)
* is NOT supported...
*/
return false;
}
}
/**
* @throws XMLStreamException
* @throws FactoryConfigurationError
* @throws IOException
* @throws UnknownCRSException
* @throws TransformationException
*/
@Test
public void testMultiLineString()
throws XMLStreamException, FactoryConfigurationError, IOException, TransformationException,
UnknownCRSException {
XMLStreamReaderWrapper xmlReader =
new XMLStreamReaderWrapper(this.getClass().getResource(BASE_DIR + MULTILINESTRING_FILE));
xmlReader.nextTag();
Assert.assertEquals(XMLStreamConstants.START_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "MultiLineString"), xmlReader.getName());
MultiLineString multiLineString =
new GML2GeometryReader().parseMultiLineString(xmlReader, null);
LineString firstMember = multiLineString.get(0);
Points controlPoints = firstMember.getControlPoints();
comparePoint(56.1, 0.45, controlPoints.get(0));
comparePoint(67.23, 0.98, controlPoints.get(1));
LineString secondMember = multiLineString.get(1);
controlPoints = secondMember.getControlPoints();
comparePoint(46.71, 9.25, controlPoints.get(0));
comparePoint(56.88, 10.44, controlPoints.get(1));
LineString thirdMember = multiLineString.get(2);
controlPoints = thirdMember.getControlPoints();
comparePoint(324.1, 219.7, controlPoints.get(0));
comparePoint(0.45, 4.56, controlPoints.get(1));
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", new Boolean(true));
XMLMemoryStreamWriter memoryWriter = new XMLMemoryStreamWriter();
SchemaLocationXMLStreamWriter writer =
new SchemaLocationXMLStreamWriter(
memoryWriter.getXMLStreamWriter(), SCHEMA_LOCATION_ATTRIBUTE);
GML2GeometryWriter exporter = new GML2GeometryWriter(writer, null, null, new HashSet<String>());
writer.setPrefix("gml", "http://www.opengis.net/gml");
writer.setPrefix("xlink", "http://www.w3.org/1999/xlink");
exporter.export(multiLineString);
writer.flush();
XMLAssert.assertValidity(memoryWriter.getReader(), SCHEMA_LOCATION);
}
public void testObjectToXMLStreamWriterRecord() throws Exception {
if (XML_OUTPUT_FACTORY != null) {
StringWriter writer = new StringWriter();
XMLOutputFactory factory = XMLOutputFactory.newInstance();
factory.setProperty(factory.IS_REPAIRING_NAMESPACES, new Boolean(false));
XMLStreamWriter streamWriter = factory.createXMLStreamWriter(writer);
Object objectToWrite = getWriteControlObject();
XMLDescriptor desc = null;
if (objectToWrite instanceof XMLRoot) {
desc =
(XMLDescriptor)
xmlContext
.getSession(0)
.getProject()
.getDescriptor(((XMLRoot) objectToWrite).getObject().getClass());
} else {
desc =
(XMLDescriptor)
xmlContext.getSession(0).getProject().getDescriptor(objectToWrite.getClass());
}
jaxbMarshaller.setProperty(MarshallerProperties.MEDIA_TYPE, "application/xml");
int sizeBefore = getNamespaceResolverSize(desc);
XMLStreamWriterRecord record = new XMLStreamWriterRecord(streamWriter);
try {
((org.eclipse.persistence.jaxb.JAXBMarshaller) jaxbMarshaller)
.marshal(objectToWrite, record);
} catch (Exception e) {
assertMarshalException(e);
return;
}
if (expectsMarshalException) {
fail("An exception should have occurred but didn't.");
return;
}
streamWriter.flush();
int sizeAfter = getNamespaceResolverSize(desc);
assertEquals(sizeBefore, sizeAfter);
Document testDocument = getTestDocument(writer.toString());
writer.close();
objectToXMLDocumentTest(testDocument);
}
}
/**
* @throws XMLStreamException
* @throws FactoryConfigurationError
* @throws IOException
* @throws UnknownCRSException
* @throws TransformationException
*/
@Test
public void testBox()
throws XMLStreamException, FactoryConfigurationError, IOException, UnknownCRSException,
TransformationException {
XMLStreamReaderWrapper xmlReader =
new XMLStreamReaderWrapper(this.getClass().getResource(BASE_DIR + BOX_FILE));
xmlReader.nextTag();
Assert.assertEquals(XMLStreamConstants.START_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "Box"), xmlReader.getName());
Envelope envelope = new GML2GeometryReader().parseEnvelope(xmlReader, null);
Assert.assertEquals(XMLStreamConstants.END_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "Box"), xmlReader.getName());
Assert.assertEquals(0.0, envelope.getMin().get0(), DELTA);
Assert.assertEquals(0.0, envelope.getMin().get1(), DELTA);
Assert.assertEquals(100.0, envelope.getMax().get0(), DELTA);
Assert.assertEquals(100.0, envelope.getMax().get1(), DELTA);
Assert.assertEquals(
CRSRegistry.lookup("http://www.opengis.net/gml/srs/epsg.xml#4326"),
envelope.getCoordinateSystem().getWrappedCRS());
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", new Boolean(true));
XMLMemoryStreamWriter memoryWriter = new XMLMemoryStreamWriter();
SchemaLocationXMLStreamWriter writer =
new SchemaLocationXMLStreamWriter(
memoryWriter.getXMLStreamWriter(), SCHEMA_LOCATION_ATTRIBUTE);
GML2GeometryWriter exporter = new GML2GeometryWriter(writer, null, null, new HashSet<String>());
// writer.setPrefix( "app", "http://www.deegree.org" );
// writer.setPrefix( "app", "http://www.deegree.org/app" );
writer.setPrefix("gml", "http://www.opengis.net/gml");
// writer.setPrefix( "ogc", "http://www.opengis.net/ogc" );
// writer.setPrefix( "wfs", "http://www.opengis.net/wfs" );
// writer.setPrefix( "xlink", "http://www.w3.org/1999/xlink" );
// writer.setPrefix( "xsi", "http://www.w3.org/2001/XMLSchema-instance" );
exporter.export(envelope);
writer.flush();
XMLAssert.assertValidity(memoryWriter.getReader(), SCHEMA_LOCATION);
}
public void write(OutputStream out) throws IOException {
try {
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
XMLStreamWriter xsw = outputFactory.createXMLStreamWriter(out);
xsw.writeStartDocument();
xsw.writeStartElement("membership");
xsw.writeDefaultNamespace(XMLContants.EXO_NAMESPACE_URL);
xsw.writeNamespace(XMLContants.XLINK_PREFIX, XMLContants.XLINK_NAMESPACE_URL);
xsw.writeAttribute(
XMLContants.XLINK_NAMESPACE_URL,
XMLContants.XLINK_HREF,
baseURI_
+ "/organization/membership/"
+ membership_.getId()
+ "/?output=xml&command=view");
xsw.writeStartElement("id");
xsw.writeCharacters(membership_.getId());
xsw.writeEndElement();
xsw.writeStartElement("group-id");
xsw.writeCharacters(membership_.getGroupId());
xsw.writeEndElement();
xsw.writeStartElement("user-name");
xsw.writeCharacters(membership_.getUserName());
xsw.writeEndElement();
xsw.writeStartElement("membership-type");
xsw.writeCharacters(membership_.getMembershipType());
xsw.writeEndElement();
xsw.writeEndDocument();
xsw.flush();
xsw.close();
} catch (Exception e) {
e.printStackTrace();
throw new IOException(e.getMessage());
}
}
/**
* @throws XMLStreamException
* @throws FactoryConfigurationError
* @throws IOException
* @throws UnknownCRSException
* @throws TransformationException
*/
@Test
public void testPoint()
throws XMLStreamException, FactoryConfigurationError, IOException, UnknownCRSException,
TransformationException {
XMLStreamReaderWrapper xmlReader =
new XMLStreamReaderWrapper(this.getClass().getResource(BASE_DIR + POINT_FILE));
xmlReader.nextTag();
Assert.assertEquals(XMLStreamConstants.START_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "Point"), xmlReader.getName());
Point point = new GML2GeometryReader().parsePoint(xmlReader, null);
Assert.assertEquals(XMLStreamConstants.END_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "Point"), xmlReader.getName());
Assert.assertEquals(5.0, point.get0(), DELTA);
Assert.assertEquals(40.0, point.get1(), DELTA);
Assert.assertEquals(
CRSRegistry.lookup("http://www.opengis.net/gml/srs/epsg.xml#4326"),
point.getCoordinateSystem().getWrappedCRS());
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", new Boolean(true));
XMLMemoryStreamWriter memoryWriter = new XMLMemoryStreamWriter();
SchemaLocationXMLStreamWriter writer =
new SchemaLocationXMLStreamWriter(
memoryWriter.getXMLStreamWriter(), SCHEMA_LOCATION_ATTRIBUTE);
GML2GeometryWriter exporter = new GML2GeometryWriter(writer, null, null, new HashSet<String>());
writer.setPrefix("gml", "http://www.opengis.net/gml");
exporter.export(point);
writer.flush();
XMLAssert.assertValidity(memoryWriter.getReader(), SCHEMA_LOCATION);
}
/**
* @throws XMLStreamException
* @throws FactoryConfigurationError
* @throws IOException
* @throws UnknownCRSException
* @throws TransformationException
*/
@Test
public void testMultiPoint()
throws XMLStreamException, FactoryConfigurationError, IOException, TransformationException,
UnknownCRSException {
XMLStreamReaderWrapper xmlReader =
new XMLStreamReaderWrapper(this.getClass().getResource(BASE_DIR + MULTIPOINT_FILE));
xmlReader.nextTag();
Assert.assertEquals(XMLStreamConstants.START_ELEMENT, xmlReader.getEventType());
Assert.assertEquals(new QName(GML21NS, "MultiPoint"), xmlReader.getName());
MultiPoint multiPoint = new GML2GeometryReader().parseMultiPoint(xmlReader, null);
Point firstMember = multiPoint.get(0);
comparePoint(5.0, 40.0, firstMember);
Point secondMember = multiPoint.get(1);
comparePoint(0.0, 0.0, secondMember);
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", new Boolean(true));
XMLMemoryStreamWriter memoryWriter = new XMLMemoryStreamWriter();
SchemaLocationXMLStreamWriter writer =
new SchemaLocationXMLStreamWriter(
memoryWriter.getXMLStreamWriter(), SCHEMA_LOCATION_ATTRIBUTE);
GML2GeometryWriter exporter = new GML2GeometryWriter(writer, null, null, new HashSet<String>());
writer.setPrefix("gml", "http://www.opengis.net/gml");
writer.setPrefix("xlink", "http://www.w3.org/1999/xlink");
exporter.export(multiPoint);
writer.flush();
XMLAssert.assertValidity(memoryWriter.getReader(), SCHEMA_LOCATION);
}
public void setDefinition(WbXmlDefinition def) {
this.def = def;
inFact.setProperty(WbXmlInputFactory.DEFINITION_PROPERTY, def);
outFact.setProperty(WbXmlOutputFactory.DEFINITION_PROPERTY, def);
}
public boolean execute() {
attributeModel = workspace.getLookup().lookup(AttributeModel.class);
graphModel = workspace.getLookup().lookup(GraphModel.class);
HierarchicalGraph graph = null;
if (exportVisible) {
graph = graphModel.getHierarchicalGraphVisible();
} else {
graph = graphModel.getHierarchicalGraph();
}
Progress.start(progress);
graph.readLock();
// Options
if (normalize) {
calculateMinMax(graph);
}
// Calculate progress units count
int max = 0;
if (exportHierarchy) {
for (Node n : graph.getNodesTree()) {
max++;
}
for (Edge e : graph.getEdgesTree()) {
max++;
}
} else {
max = graph.getNodeCount();
for (Edge e : graph.getEdgesAndMetaEdges()) {
max++;
}
}
Progress.switchToDeterminate(progress, max);
try {
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", Boolean.FALSE);
XMLStreamWriter xmlWriter = outputFactory.createXMLStreamWriter(writer);
xmlWriter = new IndentingXMLStreamWriter(xmlWriter);
xmlWriter.writeStartDocument("UTF-8", "1.0");
xmlWriter.setPrefix("", GEXF_NAMESPACE);
xmlWriter.writeStartElement(GEXF_NAMESPACE, GEXF);
xmlWriter.writeNamespace("", GEXF_NAMESPACE);
xmlWriter.writeAttribute(GEXF_VERSION, "1.1");
if (exportColors || exportPosition || exportSize) {
xmlWriter.writeNamespace(VIZ, VIZ_NAMESPACE);
}
xmlWriter.writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
xmlWriter.writeAttribute("xsi:schemaLocation", GEXF_NAMESPACE_LOCATION);
if (exportDynamic) {
DynamicController dynamicController = Lookup.getDefault().lookup(DynamicController.class);
dynamicModel = dynamicController != null ? dynamicController.getModel(workspace) : null;
visibleInterval =
dynamicModel == null
? null
: exportVisible
? dynamicModel.getVisibleInterval()
: new TimeInterval(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
}
writeMeta(xmlWriter);
writeGraph(xmlWriter, graph);
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.close();
} catch (Exception e) {
graph.readUnlockAll();
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
}
throw new RuntimeException(e);
}
graph.readUnlock();
Progress.finish(progress);
return !cancel;
}
private XmlStreamWriterBuilder() {
System.setProperty(
"javax.xml.stream.XMLOutputFactory", "com.sun.xml.internal.stream.XMLOutputFactoryImpl");
factory = XMLOutputFactory.newFactory();
factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
}
public void createExternalBindingsFile(
String sourceDir, String targetFile, String nameSpace, String referencedXSD)
throws XMLStreamException, IOException {
if (sourceDir == null) {
System.out.println("No source directory given.");
return;
}
if (targetFile == null) {
System.out.println("No target file given.");
return;
}
File source = new File(sourceDir);
if (!source.exists()) {
System.out.println(
"Given source directory does not exist: "
+ source.getAbsolutePath()
+ "Please supply an existing source directory!");
return;
}
File target = new File(targetFile);
String name = source.getAbsolutePath();
int index = name.indexOf("src");
if (index == -1) {
System.out.println("Found no src directory in your path, this is strange!");
return;
}
String prefix = name.substring(0, index + 4);
// src + 1
String packageName = pathToPackage(name.substring(index + 4));
List<StringPair> classes = findClasses(source, prefix);
System.out.println("Found following classes: ");
for (StringPair s : classes) {
System.out.println(s);
}
// Get the reference file if any
String targetSchemaFile = referencedXSD;
if (referencedXSD == null) {
targetSchemaFile = "../" + target.getName();
}
String ns = nameSpace;
if (ns == null || "".equals(ns.trim())) {
index = packageName.lastIndexOf('.');
String nsName = null;
if (index == -1) {
nsName = packageName;
} else {
nsName = packageName.substring(index + 1);
}
ns = "http://www.deegree.org/" + nsName;
}
XMLOutputFactory factory = XMLOutputFactory.newInstance();
factory.setProperty("javax.xml.stream.isRepairingNamespaces", Boolean.TRUE);
FileOutputStream fos = new FileOutputStream(targetFile);
XMLStreamWriter writer =
new IndentingXMLStreamWriter(
factory.createXMLStreamWriter(new OutputStreamWriter(fos, "UTF-8")));
writeBindings(classes, writer, targetSchemaFile, ns, packageName);
writer.flush();
System.out.println(
"Successfully wrote external-bindings file: " + target.getAbsoluteFile().toString());
}
protected static void setRepairing(XMLOutputFactory f, boolean state) {
f.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.valueOf(state));
}