1
2
3
4
5 package org.apache.maven.toolchain.v4;
6
7 import java.io.IOException;
8 import java.io.InputStream;
9 import java.io.OutputStream;
10 import java.io.Reader;
11 import java.io.Writer;
12 import java.text.DateFormat;
13 import java.util.ArrayList;
14 import java.util.Date;
15 import java.util.HashSet;
16 import java.util.List;
17 import java.util.Map;
18 import java.util.Objects;
19 import java.util.Properties;
20 import java.util.Set;
21 import javax.xml.stream.XMLOutputFactory;
22 import javax.xml.stream.XMLStreamException;
23 import javax.xml.stream.XMLStreamWriter;
24 import org.apache.maven.api.annotations.Generated;
25 import org.apache.maven.api.xml.XmlNode;
26 import org.apache.maven.internal.xml.XmlNodeBuilder;
27 import org.apache.maven.api.toolchain.TrackableBase;
28 import org.apache.maven.api.toolchain.PersistedToolchains;
29 import org.apache.maven.api.toolchain.ToolchainModel;
30 import org.codehaus.stax2.util.StreamWriterDelegate;
31
32 import static javax.xml.XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI;
33
34 @Generated
35 public class MavenToolchainsStaxWriter {
36
37
38
39
40
41
42
43
44 private static final String NAMESPACE = "http://maven.apache.org/TOOLCHAINS/1.1.0";
45
46
47
48
49 private static final String SCHEMA_LOCATION = "http://maven.apache.org/xsd/toolchains-1.1.0.xsd";
50
51
52
53
54 private String namespace = NAMESPACE;
55
56
57
58
59 private String schemaLocation = SCHEMA_LOCATION;
60
61
62
63
64 private String fileComment = null;
65
66
67
68
69
70
71
72
73
74
75 public void setNamespace(String namespace) {
76 this.namespace = Objects.requireNonNull(namespace);
77 }
78
79
80
81
82
83
84 public void setSchemaLocation(String schemaLocation) {
85 this.schemaLocation = Objects.requireNonNull(schemaLocation);
86 }
87
88
89
90
91
92
93 public void setFileComment(String fileComment) {
94 this.fileComment = fileComment;
95 }
96
97
98
99
100
101
102
103
104 public void write(Writer writer, PersistedToolchains persistedToolchains) throws IOException, XMLStreamException {
105 XMLOutputFactory factory = new com.ctc.wstx.stax.WstxOutputFactory();
106 factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
107 factory.setProperty(com.ctc.wstx.api.WstxOutputProperties.P_USE_DOUBLE_QUOTES_IN_XML_DECL, true);
108 factory.setProperty(com.ctc.wstx.api.WstxOutputProperties.P_ADD_SPACE_AFTER_EMPTY_ELEM, true);
109 XMLStreamWriter serializer = new IndentingXMLStreamWriter(factory.createXMLStreamWriter(writer));
110 serializer.writeStartDocument(persistedToolchains.getModelEncoding(), null);
111 writePersistedToolchains("toolchains", persistedToolchains, serializer);
112 serializer.writeEndDocument();
113 }
114
115
116
117
118
119
120
121
122 public void write(OutputStream stream, PersistedToolchains persistedToolchains) throws IOException, XMLStreamException {
123 XMLOutputFactory factory = new com.ctc.wstx.stax.WstxOutputFactory();
124 factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
125 factory.setProperty(com.ctc.wstx.api.WstxOutputProperties.P_USE_DOUBLE_QUOTES_IN_XML_DECL, true);
126 factory.setProperty(com.ctc.wstx.api.WstxOutputProperties.P_ADD_SPACE_AFTER_EMPTY_ELEM, true);
127 XMLStreamWriter serializer = new IndentingXMLStreamWriter(factory.createXMLStreamWriter(stream, persistedToolchains.getModelEncoding()));
128 serializer.writeStartDocument(persistedToolchains.getModelEncoding(), null);
129 writePersistedToolchains("toolchains", persistedToolchains, serializer);
130 serializer.writeEndDocument();
131 }
132
133 private void writeTrackableBase(String tagName, TrackableBase trackableBase, XMLStreamWriter serializer)
134 throws IOException, XMLStreamException {
135 if (trackableBase != null) {
136 serializer.writeStartElement(namespace, tagName);
137 serializer.writeEndElement();
138 }
139 }
140
141 private void writePersistedToolchains(String tagName, PersistedToolchains persistedToolchains, XMLStreamWriter serializer)
142 throws IOException, XMLStreamException {
143 if (persistedToolchains != null) {
144 if (this.fileComment != null) {
145 serializer.writeCharacters("\n");
146 serializer.writeComment(this.fileComment);
147 serializer.writeCharacters("\n");
148 }
149 serializer.writeStartElement("", tagName, namespace);
150 serializer.writeNamespace("", namespace);
151 serializer.writeNamespace("xsi", W3C_XML_SCHEMA_INSTANCE_NS_URI);
152 serializer.writeAttribute(W3C_XML_SCHEMA_INSTANCE_NS_URI, "schemaLocation", namespace + " " + schemaLocation);
153 writeList("toolchains", true, persistedToolchains.getToolchains(), serializer,
154 t -> writeToolchainModel("toolchain", t, serializer));
155 serializer.writeEndElement();
156 }
157 }
158
159 private void writeToolchainModel(String tagName, ToolchainModel toolchainModel, XMLStreamWriter serializer)
160 throws IOException, XMLStreamException {
161 if (toolchainModel != null) {
162 serializer.writeStartElement(namespace, tagName);
163 writeTag("type", null, toolchainModel.getType(), serializer);
164 writeProperties("provides", toolchainModel.getProvides(), serializer);
165 writeDom(toolchainModel.getConfiguration(), serializer);
166 serializer.writeEndElement();
167 }
168 }
169
170 @FunctionalInterface
171 private interface ElementWriter<T> {
172 public void write(T t) throws IOException, XMLStreamException;
173 }
174
175 private <T> void writeList(String tagName, List<T> list, XMLStreamWriter serializer, ElementWriter<T> writer) throws IOException, XMLStreamException {
176 writeList(tagName, false, list, serializer, writer);
177 }
178
179 private <T> void writeList(String tagName, boolean flat, List<T> list, XMLStreamWriter serializer, ElementWriter<T> writer) throws IOException, XMLStreamException {
180 if (list != null && !list.isEmpty()) {
181 if (!flat) {
182 serializer.writeStartElement(namespace, tagName);
183 }
184 int index = 0;
185 for (T t : list) {
186 writer.write(t);
187 }
188 if (!flat) {
189 serializer.writeEndElement();
190 }
191 }
192 }
193
194 private <T> void writeProperties(String tagName, Map<String, String> props, XMLStreamWriter serializer) throws IOException, XMLStreamException {
195 if (props != null && !props.isEmpty()) {
196 serializer.writeStartElement(namespace, tagName);
197 for (Map.Entry<String, String> entry : props.entrySet()) {
198 String key = entry.getKey();
199 writeTag(key, null, entry.getValue(), serializer);
200 }
201 serializer.writeEndElement();
202 }
203 }
204
205 private void writeDom(XmlNode dom, XMLStreamWriter serializer) throws IOException, XMLStreamException {
206 if (dom != null) {
207 serializer.writeStartElement(namespace, dom.getName());
208 for (Map.Entry<String, String> attr : dom.getAttributes().entrySet()) {
209 if (attr.getKey().startsWith("xml:")) {
210 serializer.writeAttribute("http://www.w3.org/XML/1998/namespace",
211 attr.getKey().substring(4), attr.getValue());
212 } else {
213 serializer.writeAttribute(attr.getKey(), attr.getValue());
214 }
215 }
216 for (XmlNode child : dom.getChildren()) {
217 writeDom(child, serializer);
218 }
219 String value = dom.getValue();
220 if (value != null) {
221 serializer.writeCharacters(value);
222 }
223 serializer.writeEndElement();
224 }
225 }
226
227 private void writeTag(String tagName, String defaultValue, String value, XMLStreamWriter serializer) throws IOException, XMLStreamException {
228 if (value != null && !Objects.equals(defaultValue, value)) {
229 serializer.writeStartElement(namespace, tagName);
230 serializer.writeCharacters(value);
231 serializer.writeEndElement();
232 }
233 }
234
235 private void writeAttr(String attrName, String value, XMLStreamWriter serializer) throws IOException, XMLStreamException {
236 if (value != null) {
237 serializer.writeAttribute(attrName, value);
238 }
239 }
240
241 static class IndentingXMLStreamWriter extends StreamWriterDelegate {
242
243 int depth = 0;
244 boolean hasChildren = false;
245
246 public IndentingXMLStreamWriter(XMLStreamWriter parent) {
247 super(parent);
248 }
249
250 @Override
251 public void writeEmptyElement(String localName) throws XMLStreamException {
252 indent();
253 super.writeEmptyElement(localName);
254 hasChildren = true;
255 }
256
257 @Override
258 public void writeEmptyElement(String namespaceURI, String localName) throws XMLStreamException {
259 indent();
260 super.writeEmptyElement(namespaceURI, localName);
261 hasChildren = true;
262 }
263
264 @Override
265 public void writeEmptyElement(String prefix, String localName, String namespaceURI) throws XMLStreamException {
266 indent();
267 super.writeEmptyElement(prefix, localName, namespaceURI);
268 hasChildren = true;
269 }
270
271 @Override
272 public void writeStartElement(String localName) throws XMLStreamException {
273 indent();
274 super.writeStartElement(localName);
275 depth++;
276 hasChildren = false;
277 }
278
279 @Override
280 public void writeStartElement(String namespaceURI, String localName) throws XMLStreamException {
281 indent();
282 super.writeStartElement(namespaceURI, localName);
283 depth++;
284 hasChildren = false;
285 }
286
287 @Override
288 public void writeStartElement(String prefix, String localName, String namespaceURI) throws XMLStreamException {
289 indent();
290 super.writeStartElement(prefix, localName, namespaceURI);
291 depth++;
292 hasChildren = false;
293 }
294
295 @Override
296 public void writeEndElement() throws XMLStreamException {
297 depth--;
298 if (hasChildren) {
299 indent();
300 }
301 super.writeEndElement();
302 hasChildren = true;
303 }
304
305 private void indent() throws XMLStreamException {
306 super.writeCharacters("\n");
307 for (int i = 0; i < depth; i++) {
308 super.writeCharacters(" ");
309 }
310 }
311 }
312 }