Developing gXML Applications : gXML Recipes

gXML Recipes
Parsing
Parsing a Character Stream and a Byte Stream
 
001 package org.gxml.book.parsing;
002
003 import java.io.InputStream;
004 import java.io.Reader;
005 import java.io.StringReader;
006 import java.net.URI;
007
008 import org.gxml.book.common.SampleApp;
009 import org.gxml.sa.GxModel;
010 import org.gxml.sa.GxNameBridge;
011 import org.gxml.sa.GxProcessingContext;
012 import org.gxml.xdm.NodeKind;
013 import org.gxml.xdm.Resolved;
014 import org.gxml.xdm.Resolver;
015
016 import com.tibco.gxml.sa.common.helpers.DocumentBuilderFactory;
017 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilder;
018 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilderFactory;
019
020 public abstract class BookIntroParsingSample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
021 {
022 public void testCharacterStreamParse() throws Exception
023 {
024 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
025
026 final GxDocumentBuilderFactory<N, S> factory = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
027
028 final GxDocumentBuilder<N> builder = factory.newDocumentBuilder();
029
030 final String xmlString = "<e>123</e>";
031 final URI systemId = new URI("e.xml");
032 final Reader characterStream = new StringReader(xmlString);
033 final N doc = builder.parse(characterStream, systemId);
034
035 final GxModel<N, A, S, T> model = pcx.getModel();
036
037 assertEquals(NodeKind.DOCUMENT, model.getNodeKind(doc));
038
039 final N e = model.getFirstChildElement(doc);
040 assertEquals(NodeKind.ELEMENT, model.getNodeKind(e));
041 assertEquals("e", model.getLocalNameAsString(e));
042 assertEquals("123", model.getStringValue(e));
043 }
044
045 public void testByteStreamParse() throws Exception
046 {
047 final Resolver resolver = getResolver();
048
049 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
050
051 final URI systemId = new URI("email.xml");
052 final Resolved<InputStream> source = resolver.resolveInputStream(systemId);
053
054 final GxDocumentBuilderFactory<N, S> factory = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
055
056 final GxDocumentBuilder<N> builder = factory.newDocumentBuilder();
057
058 final N document = builder.parse(source.getResource(), source.getSystemId());
059
060 final GxModel<N, A, S, T> model = pcx.getModel();
061
062 assertEquals(NodeKind.DOCUMENT, model.getNodeKind(document));
063
064 final N email = model.getFirstChildElement(document);
065 assertEquals(NodeKind.ELEMENT, model.getNodeKind(email));
066 assertEquals("email", model.getLocalNameAsString(email));
067 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
068 final S namespaceURI = nameBridge.symbolize("http://www.example.com");
069 final S localName = nameBridge.symbolize("from");
070 final N from = model.getFirstChildElementByName(email, namespaceURI, localName);
071 assertEquals("Julie", model.getStringValue(from));
072
073 for (final N node : model.getDescendantOrSelfAxis(document))
074 {
075 assertNodeSymbolSemantics(node, pcx);
076 }
077 }
078 }
 
Constructing a Data Model Tree Programmatically
This example demonstrates constructing a tree directly using the fragment builder.
 
001 package org.gxml.book.snoopy;
002
003 import java.io.IOException;
004 import java.io.InputStream;
005 import java.io.StringReader;
006 import java.io.StringWriter;
007 import java.net.URI;
008 import java.net.URISyntaxException;
009
010 import javax.xml.namespace.QName;
011 import javax.xml.parsers.ParserConfigurationException;
012
013 import org.gxml.book.common.SampleApp;
014 import org.gxml.sa.GxException;
015 import org.gxml.sa.GxFragmentBuilder;
016 import org.gxml.sa.GxMetaBridge;
017 import org.gxml.sa.GxModel;
018 import org.gxml.sa.GxNameBridge;
019 import org.gxml.sa.GxProcessingContext;
020 import org.gxml.sa.GxSequenceHandler;
021 import org.gxml.sa.GxVariantBridge;
022 import org.gxml.xdm.NodeKind;
023 import org.gxml.xdm.Resolved;
024 import org.gxml.xdm.Resolver;
025 import org.gxml.xs.SmName;
026
027 import com.tibco.gxml.sa.api.common.lang.ExprException;
028 import com.tibco.gxml.sa.api.common.lang.ExprResult;
029 import com.tibco.gxml.sa.api.common.lang.GxExpr;
030 import com.tibco.gxml.sa.api.common.lang.GxExprContextDynamicArgs;
031 import com.tibco.gxml.sa.api.common.lang.GxExprContextStaticArgs;
032 import com.tibco.gxml.sa.api.common.lang.GxLanguageToolKit;
033 import com.tibco.gxml.sa.common.helpers.DocumentBuilderFactory;
034 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilder;
035 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilderFactory;
036 import com.tibco.gxml.sa.processor.serialization.api.GxSerializerFactory;
037 import com.tibco.gxml.sa.processor.serialization.impl.SerializerFactory;
038 import com.tibco.gxml.sa.processor.xquery.LanguageToolKit;
039 import com.tibco.gxml.sa.processor.xslt.GxTransform;
040 import com.tibco.gxml.sa.processor.xslt.GxTransformBuilder;
041 import com.tibco.gxml.sa.processor.xslt.GxTransformer;
042 import com.tibco.gxml.sa.processor.xslt.XSLTransformBuilder;
043 import com.tibco.gxmlsa.processor.org.exslt.strings.ExsltStringsFunctionGroup;
044
045 public abstract class SnoopySample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
046 {
047 public void testDocumentFromString()
048 {
049 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
050
051 final N document = documentFromString(pcx);
052
053 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
054
055 sf.setIndent(true);
056
057 final StringWriter sw = new StringWriter();
058
059 final GxSequenceHandler<A, S, T> serializer = sf.newSerializer(sw);
060
061 final GxModel<N, A, S, T> model = pcx.getModel();
062
063 model.stream(document, true, true, serializer);
064
065 // System.out.println(sw.toString());
066 }
067
068 public void testFragmentBuilder()
069 {
070 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
071
072 final N document = documentFromEvents(pcx);
073
074 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
075
076 sf.setIndent(true);
077
078 final StringWriter sw = new StringWriter();
079
080 final GxSequenceHandler<A, S, T> serializer = sf.newSerializer(sw);
081
082 final GxModel<N, A, S, T> model = pcx.getModel();
083
084 model.stream(document, true, true, serializer);
085
086 // System.out.println(sw.toString());
087 }
088
089 private N documentFromString(final GxProcessingContext<I, U, N, A, S, T, X> pcx)
090 {
091 final String strval = "" + "<?xml version='1.0' encoding='UTF-8'?>" + "<book isbn='0836217462'>" + " <title>Being a Dog Is a Full-Time Job</title>" + " <author>Charles M. Schultz</author>" + " <character>" + " <name>Snoopy</name>" + " <since>1950-10-04</since>" + " </character>" + "</book>";
092
093 final GxDocumentBuilderFactory<N, S> factory = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
094
095 final GxDocumentBuilder<N> builder = factory.newDocumentBuilder();
096
097 try
098 {
099 return builder.parse(new StringReader(strval), null);
100 }
101 catch (final IOException e)
102 {
103 throw new AssertionError();
104 }
105 }
106
107 private N documentFromEvents(final GxProcessingContext<I, U, N, A, S, T, X> pcx)
108 {
109 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
110
111 final S NULL_NS_URI = nameBridge.empty();
112 final S BOOK = nameBridge.symbolize("book");
113 final S ISBN = nameBridge.symbolize("isbn");
114 final S TITLE = nameBridge.symbolize("title");
115 final S AUTHOR = nameBridge.symbolize("author");
116 final S CHARACTER = nameBridge.symbolize("character");
117 final S NAME = nameBridge.symbolize("name");
118 final S SINCE = nameBridge.symbolize("since");
119
120 final GxFragmentBuilder<N, A, S, T> builder = pcx.newFragmentBuilder();
121
122 // Note: Using try...finally not only ensures that elements get closed when errors
123 // occur, it also helps to remind you to end elements and makes the levels in
124 // the XML more obvious.
125 builder.startDocument(null);
126 try
127 {
128 builder.startElement(NULL_NS_URI, BOOK, "", null);
129 try
130 {
131 builder.attribute(NULL_NS_URI, ISBN, "", "0836217462");
132 builder.startElement(NULL_NS_URI, TITLE, "", null);
133 try
134 {
135 builder.text("Being a Dog Is a Full-Time Job");
136 }
137 finally
138 {
139 builder.endElement();
140 }
141 builder.startElement(NULL_NS_URI, AUTHOR, "", null);
142 try
143 {
144 builder.text("Charles M. Schultz");
145 }
146 finally
147 {
148 builder.endElement();
149 }
150 builder.startElement(NULL_NS_URI, CHARACTER, "", null);
151 try
152 {
153 builder.startElement(NULL_NS_URI, NAME, "", null);
154 try
155 {
156 builder.text("Snoopy");
157 }
158 finally
159 {
160 builder.endElement();
161 }
162 builder.startElement(NULL_NS_URI, SINCE, "", null);
163 try
164 {
165 builder.text("1950-10-04");
166 }
167 finally
168 {
169 builder.endElement();
170 }
171 }
172 finally
173 {
174 builder.endElement();
175 }
176 }
177 finally
178 {
179 builder.endElement();
180 }
181 }
182 finally
183 {
184 builder.endDocument();
185 }
186
187 return builder.getNodes().get(0);
188 }
189
190 public void testExample() throws ParserConfigurationException, IOException, GxException, ExprException, URISyntaxException
191 {
192 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
193
194 final Resolver resolver = getResolver();
195
196 final URI xmlSystemId = new URI("hotel.xml");
197 final Resolved<InputStream> xmlInput = resolver.resolveInputStream(xmlSystemId);
198
199 final GxDocumentBuilderFactory<N, S> f = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
200
201 final GxDocumentBuilder<N> builder = f.newDocumentBuilder();
202
203 final N document = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
204
205 final URI xslSystemId = new URI("hotel.xsl");
206 final Resolved<InputStream> xslInput = resolver.resolveInputStream(xslSystemId);
207
208 final GxTransformBuilder<I, U, N, A, S, T, X> compiler = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
209
210 // poem.xsl uses version="2.0", but we want to use XPath 1.0 compatibility mode
211 // so that arguments to functions are converted etc.
212 compiler.setCompatibleMode(true);
213
214 final GxTransform<I, U, N, A, S, T, X> compiled = compiler.prepareTransform(xslInput.getResource(), xslInput.getSystemId());
215
216 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
217
218 // TODO: Extract the configuration?
219 // compiled.configure(sf);
220
221 sf.setIndent(true);
222
223 final StringWriter w = new StringWriter();
224
225 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(w);
226
227 final GxTransformer<I, U, N, A, S, T, X> transformer = compiled.newTransformer();
228
229 transformer.transform(document, pcx, handler);
230 }
231
232 public void testVariableBinding() throws ParserConfigurationException, IOException, GxException, ExprException, URISyntaxException
233 {
234 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
235
236 final Resolver resolver = getResolver();
237
238 final URI xslSystemId = new URI("email.xsl");
239 final Resolved<InputStream> xslInput = resolver.resolveInputStream(xslSystemId);
240
241 final GxTransformBuilder<I, U, N, A, S, T, X> compiler = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
242
243 final GxTransform<I, U, N, A, S, T, X> compiled = compiler.prepareTransform(xslInput.getResource(), xslInput.getSystemId());
244
245 final GxTransformer<I, U, N, A, S, T, X> transformer = compiled.newTransformer();
246
247 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
248 final SmName<S> varName = nameBridge.name(new QName("to"));
249 final GxVariantBridge<I, N, A, X> valueBridge = pcx.getVariantBridge();
250 final X value = valueBridge.stringValue("David");
251
252 transformer.bindVariableValue(varName, value);
253 transformer.bindVariableValue(nameBridge.name(new QName("http://www.example.com", "from")), valueBridge.stringValue("Julie"));
254
255 final N documentNode = transformer.transform(null, pcx);
256
257 final GxModel<N, A, S, T> model = pcx.getModel();
258
259 assertEquals(NodeKind.DOCUMENT, model.getNodeKind(documentNode));
260 final N email = model.getFirstChildElement(documentNode);
261 final N to = model.getFirstChildElementByName(email, nameBridge.symbolize("http://www.example.com"), nameBridge.symbolize("to"));
262 assertEquals("David", model.getStringValue(to));
263 final N from = model.getFirstChildElementByName(email, null, nameBridge.symbolize("from"));
264 assertEquals("Julie", model.getStringValue(from));
265 final N again = model.getFirstChildElementByName(email, nameBridge.symbolize("http://www.example.com"), null);
266 assertEquals("David", model.getStringValue(again));
267 }
268
269 public void testExternalFunctions() throws ParserConfigurationException, IOException, GxException, ExprException, URISyntaxException
270 {
271 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
272
273 final Resolver resolver = getResolver();
274
275 final URI xmlSystemId = new URI("exslt.xml");
276 final Resolved<InputStream> xmlInput = resolver.resolveInputStream(xmlSystemId);
277
278 final GxDocumentBuilderFactory<N, S> f = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
279
280 final GxDocumentBuilder<N> builder = f.newDocumentBuilder();
281
282 final N document = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
283
284 final URI xslSystemId = new URI("exslt.xsl");
285 final Resolved<InputStream> xslInput = resolver.resolveInputStream(xslSystemId);
286
287 final GxTransformBuilder<I, U, N, A, S, T, X> compiler = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
288
289 final String namespaceURI = "http://exslt.org/strings";
290 final ExsltStringsFunctionGroup<I, U, N, A, S, T, X> functions = new ExsltStringsFunctionGroup<I, U, N, A, S, T, X>(namespaceURI, pcx);
291 compiler.setFunctionSigns(namespaceURI, functions);
292 compiler.setFunctionImpls(namespaceURI, functions);
293
294 final GxTransform<I, U, N, A, S, T, X> compiled = compiler.prepareTransform(xslInput.getResource(), xslInput.getSystemId());
295
296 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
297
298 // TODO: Extract the configuration.
299 // compiled.configure(sf);
300
301 sf.setIndent(true);
302
303 final StringWriter w = new StringWriter();
304
305 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(w);
306
307 final GxTransformer<I, U, N, A, S, T, X> transformer = compiled.newTransformer();
308
309 transformer.transform(document, pcx, handler);
310
311 // System.out.println(w.toString());
312 }
313
314 public void testHotel() throws ParserConfigurationException, IOException, GxException, ExprException, URISyntaxException
315 {
316 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
317
318 final Resolver resolver = getResolver();
319
320 final URI xmlSystemId = new URI("hotel.xml");
321 final Resolved<InputStream> xmlInput = resolver.resolveInputStream(xmlSystemId);
322
323 final GxDocumentBuilderFactory<N, S> f = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
324
325 final GxDocumentBuilder<N> builder = f.newDocumentBuilder();
326
327 final N document = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
328
329 final URI xslSystemId = new URI("hotel.xsl");
330 final Resolved<InputStream> xslInput = resolver.resolveInputStream(xslSystemId);
331
332 final GxTransformBuilder<I, U, N, A, S, T, X> compiler = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
333
334 final GxTransform<I, U, N, A, S, T, X> compiled = compiler.prepareTransform(xslInput.getResource(), xslInput.getSystemId());
335
336 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
337
338 // TODO: Extract the configuration.
339 // compiled.configure(sf);
340
341 sf.setIndent(true);
342
343 final StringWriter w = new StringWriter();
344
345 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(w);
346
347 final GxTransformer<I, U, N, A, S, T, X> transformer = compiled.newTransformer();
348 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
349 final SmName<S> varName = nameBridge.name(new QName("MessageData"));
350 final GxVariantBridge<I, N, A, X> valueBridge = pcx.getVariantBridge();
351 final X value = valueBridge.node(document);
352
353 transformer.bindVariableValue(varName, value);
354
355 transformer.transform(null, pcx, handler);
356
357 // System.out.println(w.toString());
358 }
359
360 public void testHelloWorld() throws Exception
361 {
362 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
363 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
364
365 final GxLanguageToolKit<I, U, N, A, S, T, X> xtk = new LanguageToolKit<I, U, N, A, S, T, X>(pcx);
366
367 final GxExprContextStaticArgs<I, U, N, A, S, T, X> senv = xtk.newStaticContextArgs();
368 final String NAMESPACE = "http://www.peanuts.com";
369
370 senv.getInScopeNamespaces().declarePrefix("nuts", nameBridge.symbolize(NAMESPACE));
371
372 final SnoopyFunctionGroup<I, U, N, A, S, T, X> peanutsFunctionGroup = new SnoopyFunctionGroup<I, U, N, A, S, T, X>(NAMESPACE, pcx);
373 senv.setFunctionSigns(NAMESPACE, peanutsFunctionGroup);
374 senv.setFunctionImpls(NAMESPACE, peanutsFunctionGroup);
375
376 final GxMetaBridge<A, S, T> metaBridge = pcx.getMetaBridge();
377
378 final ExprResult<I, U, N, A, S, T, X> prepared = xtk.prepare("nuts:GetVariableProperty('foo','bar')", metaBridge.emptyType(), senv);
379
380 final GxExpr<I, U, N, A, S, T, X> expr = prepared.getExpr();
381
382 final GxExprContextDynamicArgs<I, U, N, A, S, T, X> darg = xtk.newDynamicContextArgs();
383
384 final String strval = expr.stringFunction(xtk.emptyFocus(), darg, pcx);
385
386 assertEquals("Bingo!", strval);
387 }
388 }
 
Validating
 
001 package org.gxml.book.parsing;
002
003 import java.io.InputStream;
004 import java.net.URI;
005
006 import javax.xml.namespace.QName;
007
008 import org.gxml.book.common.SampleApp;
009 import org.gxml.sa.GxApplication;
010 import org.gxml.sa.GxAtomBridge;
011 import org.gxml.sa.GxModel;
012 import org.gxml.sa.GxNameBridge;
013 import org.gxml.sa.GxProcessingContext;
014 import org.gxml.xdm.Resolved;
015 import org.gxml.xdm.Resolver;
016 import org.gxml.xs.SmComponentBag;
017 import org.gxml.xs.SmExceptionCatcher;
018 import org.gxml.xs.SmMetaLoadArgs;
019 import org.gxml.xs.SmName;
020
021 import com.tibco.gxml.sa.common.helpers.DocumentBuilderFactory;
022 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilder;
023 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilderFactory;
024 import com.tibco.gxml.sa.common.helpers.SmAtomBridgeOnGxAtomBridgeAdapter;
025 import com.tibco.gxml.xs.W3cXmlSchemaParser;
026
027 public abstract class BookValidatingParsingSample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
028 {
029 public void testValidatingParse() throws Exception
030 {
031 final GxApplication<I, U, N, A, S, T, X> app = this;
032
033 final Resolver resolver = app.getResolver();
034
035 final SmMetaLoadArgs args = new SmMetaLoadArgs();
036
037 final SmExceptionCatcher errors = new SmExceptionCatcher();
038
039 final GxProcessingContext<I, U, N, A, S, T, X> pcx = app.newProcessingContext();
040
041 final Resolved<InputStream> resource = getResolver().resolveInputStream(new URI("email.xsd"));
042
043 final W3cXmlSchemaParser<A, S> parser = new W3cXmlSchemaParser<A, S>(new SmAtomBridgeOnGxAtomBridgeAdapter<A, S>(pcx.getAtomBridge()));
044
045 final SmComponentBag<A, S> components = parser.parse(resource.getLocation(), resource.getResource(), resource.getSystemId(), errors, args, pcx);
046
047 pcx.register(components);
048
049 pcx.lock();
050
051 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
052
053 assertEquals(0, errors.size());
054
055 final URI xmlURI = new URI("email.xml");
056 final Resolved<InputStream> xmlInput = resolver.resolveInputStream(xmlURI);
057
058 final GxDocumentBuilderFactory<N, S> factory = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
059
060 // Enable validation of the XML input.
061 factory.setValidating(true, nameBridge.name(new QName("http://www.example.com", "email")));
062
063 final GxDocumentBuilder<N> builder = factory.newDocumentBuilder();
064
065 // TODO: Need to catch errors...
066 // builder.setExceptionHandler(errors);
067
068 final N doc = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
069
070 assertEquals(0, errors.size());
071
072 // System.out.println(serialize(doc, pcx));
073
074 final GxModel<N, A, S, T> model = pcx.getModel();
075 final GxAtomBridge<A, S> atomBridge = pcx.getAtomBridge();
076
077 final N email = model.getFirstChildElement(doc);
078 final S namespaceURI = nameBridge.symbolize("http://www.example.com");
079 final N sent = model.getFirstChildElementByName(email, namespaceURI, nameBridge.symbolize("sent"));
080 assertNotNull("model.getFirstChildElementByName", sent);
081 final SmName<S> typeName = model.getTypeName(sent);
082 assertNotNull("model.getTypeName", typeName);
083 assertEquals("dateTime", typeName.toQName().getLocalPart());
084 final A dateTime = model.getTypedValue(sent).get(0);
085
086 // assertTrue(metaBridge.sameAs(metaBridge.handle(pcx.getTypeDefinition(type)),
087 // metaBridge.getType(SmNativeType.DATETIME)));
088
089 assertEquals("2008-03-23T14:49:30-05:00", atomBridge.getC14NForm(dateTime));
090 }
091 }
 
Navigation
001 package org.gxml.book.parsing;
002
003 import java.io.InputStream;
004 import java.net.URI;
005
006 import org.gxml.book.common.SampleApp;
007 import org.gxml.sa.GxModel;
008 import org.gxml.sa.GxNameBridge;
009 import org.gxml.sa.GxProcessingContext;
010 import org.gxml.xdm.Resolved;
011 import org.gxml.xdm.Resolver;
012
013 import com.tibco.gxml.sa.common.helpers.DocumentBuilderFactory;
014 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilder;
015 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilderFactory;
016
017 public abstract class BookNavigationParsingSample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
018 {
019 public void testBooksByNealStephenson() throws Exception
020 {
021 final Resolver resolver = getResolver();
022
023 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
024
025 final URI systemId = new URI("books.xml");
026 final Resolved<InputStream> source = resolver.resolveInputStream(systemId);
027
028 final GxDocumentBuilderFactory<N, S> factory = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
029
030 final GxDocumentBuilder<N> builder = factory.newDocumentBuilder();
031
032 final N doc = builder.parse(source.getResource(), source.getSystemId());
033
034 final GxModel<N, A, S, T> model = pcx.getModel();
035
036 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
037
038 final S namespaceURI = nameBridge.symbolize("http://www.example.com/books");
039
040 final N inventory = model.getFirstChildElementByName(doc, namespaceURI, nameBridge.symbolize("inventory"));
041
042 for (final N book : model.getChildElementsByName(inventory, namespaceURI, nameBridge.symbolize("book")))
043 {
044 boolean found = false;
045
046 for (final N author : model.getChildElementsByName(book, namespaceURI, nameBridge.symbolize("author")))
047 {
048 if (model.getStringValue(author).equals("Neal Stephenson"))
049 {
050 found = true;
051 break;
052 }
053 }
054
055 if (found)
056 {
057 final N title = model.getFirstChildElementByName(book, namespaceURI, nameBridge.symbolize("title"));
058
059 System.out.println(model.getStringValue(title));
060 }
061 }
062 }
063
064 public void testPurchaseOrder() throws Exception
065 {
066 final Resolver resolver = getResolver();
067
068 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
069 final GxModel<N, A, S, T> model = pcx.getModel();
070 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
071
072 final URI systemId = new URI("PurchaseOrder.xml");
073 final Resolved<InputStream> source = resolver.resolveInputStream(systemId);
074
075 final GxDocumentBuilderFactory<N, S> factory = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
076
077 final GxDocumentBuilder<N> builder = factory.newDocumentBuilder();
078
079 final N po = builder.parse(source.getResource(), source.getSystemId());
080
081 final N root = model.getFirstChildElement(po);
082
083 final N items = model.getFirstChildElementByName(root, null, nameBridge.symbolize("items"));
084
085 double total = 0;
086 for (final N item : model.getChildElementsByName(items, null, nameBridge.symbolize("item")))
087 {
088 System.out.println("partNum:" + model.getAttributeStringValue(item, nameBridge.empty(), nameBridge.symbolize("partNum")));
089
090 final N price = model.getFirstChildElementByName(item, null, nameBridge.symbolize("USPrice"));
091 total += Double.valueOf(model.getStringValue(price)).doubleValue();
092 }
093 System.out.println("Grand total = " + total);
094 }
095 }
 
Mutation
001 package org.gxml.book.mutable;
002
003 import java.math.BigDecimal;
004
005 import javax.xml.XMLConstants;
006
007 import org.gxml.book.common.MutableApp;
008 import org.gxml.sa.GxAtomBridge;
009 import org.gxml.sa.GxNameBridge;
010 import org.gxml.sa.mutable.GxModelMutable;
011 import org.gxml.sa.mutable.GxProcessingContextMutable;
012 import org.gxml.xdm.NodeKind;
013
014 /**
015 * This sample illustrates the use of the optional mutability API.
016 *
017 * @author dholmes
018 *
019 * @param <I>
020 * @param <U>
021 * @param <N>
022 * @param <A>
023 * @param <S>
024 * @param <T>
025 * @param <X>
026 */
027 public abstract class MutableSample<I, U, N extends I, A extends I, S, T, X> extends MutableApp<I, U, N, A, S, T, X>
028 {
029 /**
030 * This is a test of basic mutability through the optional mutability API.
031 * Line 2
032 * Line 3
033 * Line 4 // OK
034 */
035 public void testIntroduction() throws Exception
036 {
037 final GxProcessingContextMutable<I, U, N, A, S, T, X> pcx = newProcessingContext();
038 final GxAtomBridge<A, S> atomBridge = pcx.getAtomBridge();
039 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
040
041 /* // Create a new document. */
042 final N documentNode = pcx.newDocument();
043
044 final GxModelMutable<N, A, S, T> model = pcx.getModel();
045
046 assertEquals(NodeKind.DOCUMENT, model.getNodeKind(documentNode));
047
048 // Every node in the tree has an owner which is a document node. /* OK */
049 final N owner = model.getOwner(documentNode);
050
051 assertTrue(model.isSameNode(documentNode, owner));
052
053 final S namespaceURI = nameBridge.symbolize("http://www.example.com");
054 final S localName = nameBridge.symbolize("foo");
055 final String prefix = "x";
056 final N documentElement = model.createElement(owner, namespaceURI, localName, prefix);
057
058 // Append the document element to the documentNode.
059 model.appendChild(documentNode, documentElement);
060
061 model.setNamespace(documentElement, prefix, namespaceURI);
062
063 model.setAttribute(documentElement, nameBridge.empty(), nameBridge.symbolize("version"), XMLConstants.DEFAULT_NS_PREFIX, atomBridge.wrapAtom(atomBridge.createDecimal(BigDecimal.valueOf(2.7))));
064
065 // Append four text nodes to the document element.
066 model.appendChild(documentElement, model.createText(owner, "Hello"));
067 model.appendChild(documentElement, model.createText(owner, " "));
068 model.appendChild(documentElement, model.createText(owner, "World"));
069 model.appendChild(documentElement, model.createText(owner, "!"));
070
071 // Compress the four contiguous text nodes into a single text node.
072 model.normalize(documentNode);
073
074 @SuppressWarnings("unused")
075 final String strval = serialize(documentNode, pcx);
076 //System.out.println(strval);
077 }
078 }
 
Serialization
001 package org.gxml.book.serialization;
002
003 import java.io.StringWriter;
004
005 import javax.xml.namespace.QName;
006
007 import org.gxml.book.common.SampleApp;
008 import org.gxml.sa.GxModel;
009 import org.gxml.sa.GxProcessingContext;
010 import org.gxml.sa.GxSequenceHandler;
011 import org.gxml.xdm.Emulation;
012
013 import com.tibco.gxml.sa.processor.serialization.api.GxDocumentSerializer;
014 import com.tibco.gxml.sa.processor.serialization.api.GxDocumentSerializerFactory;
015 import com.tibco.gxml.sa.processor.serialization.api.GxSerializerFactory;
016 import com.tibco.gxml.sa.processor.serialization.impl.DocumentSerializerFactory;
017 import com.tibco.gxml.sa.processor.serialization.impl.SerializerFactory;
018
019 public abstract class IntroSerializationSample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
020 {
021 public void exampleUsingDocumentSerializer(final N node, final GxProcessingContext<I, U, N, A, S, T, X> pcx)
022 {
023 final GxDocumentSerializerFactory<N, S> sf = new DocumentSerializerFactory<I, U, N, A, S, T, X>(pcx);
024
025 // Configure for "pretty" printing.
026 sf.setIndent(Boolean.TRUE);
027 sf.setMethod(new QName("xml"));
028 sf.setOmitXmlDeclaration(false);
029
030 final StringWriter sw = new StringWriter();
031
032 final GxDocumentSerializer<N> serializer = sf.newDocumentSerializer(sw);
033
034 serializer.serialize(node);
035
036 System.out.print(sw.toString());
037 }
038
039 public void exampleUsingSequenceHandler(final N node, final GxProcessingContext<I, U, N, A, S, T, X> pcx)
040 {
041 final GxSerializerFactory<I,U,N,A, S, T,X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
042
043 // Configure for "pretty" printing.
044 sf.setIndent(Boolean.TRUE);
045 sf.setMethod(new QName("xml"));
046 sf.setOmitXmlDeclaration(false);
047 sf.setEmulation(Emulation.C14N);
048
049 final StringWriter sw = new StringWriter();
050
051 final GxSequenceHandler<A, S, T> serializer = sf.newSerializer(sw);
052
053 final GxModel<N, A, S, T> model = pcx.getModel();
054
055 model.stream(node, true, true, serializer);
056
057 System.out.print(sw.toString());
058 }
059 }
XPath
 
001 package org.gxml.book.xpath;
002
003 import org.gxml.book.common.SampleApp;
004 import org.gxml.sa.GxMetaBridge;
005 import org.gxml.sa.GxNameBridge;
006 import org.gxml.sa.GxProcessingContext;
007 import org.gxml.sa.GxVariantBridge;
008 import org.gxml.xdm.Emulation;
009 import org.gxml.xs.SmName;
010 import org.gxml.xs.SmNativeType;
011
012 import com.tibco.gxml.sa.api.common.lang.ExprResult;
013 import com.tibco.gxml.sa.api.common.lang.GxExpr;
014 import com.tibco.gxml.sa.api.common.lang.GxExprContextDynamicArgs;
015 import com.tibco.gxml.sa.api.common.lang.GxExprContextStaticArgs;
016 import com.tibco.gxml.sa.api.common.lang.GxFocus;
017 import com.tibco.gxml.sa.api.common.lang.GxLanguageToolKit;
018 import com.tibco.gxml.sa.processor.xquery.LanguageToolKit;
019 import com.tibco.gxmlsa.processor.org.exslt.math.ExsltMathFunctionGroup;
020
021 public abstract class XPathSample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
022 {
023 public void testGettingStarted() throws Exception
024 {
025 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
026
027 // For demonstration purposes, register the language toolkit with the processing context.
028 pcx.register("xyz", new LanguageToolKit<I, U, N, A, S, T, X>(pcx));
029
030 @SuppressWarnings("unchecked")
031 // Immediately get back the registered processor.
032 GxLanguageToolKit<I, U, N, A, S, T, X> xtk = pcx.getProcessor("xyz", GxLanguageToolKit.class);
033
034 final GxExprContextStaticArgs<I, U, N, A, S, T, X> sarg = xtk.newStaticContextArgs();
035
036 final GxMetaBridge<A, S, T> metaBridge = pcx.getMetaBridge();
037
038 final ExprResult<I, U, N, A, S, T, X> prepared = xtk.prepare("concat('Hello', ', ', 'World', '!')", metaBridge.emptyType(), sarg);
039 final GxExpr<I, U, N, A, S, T, X> expr = prepared.getExpr();
040
041 final GxExprContextDynamicArgs<I, U, N, A, S, T, X> darg = xtk.newDynamicContextArgs();
042
043 final String strval = expr.stringFunction(xtk.emptyFocus(), darg, pcx);
044
045 assertEquals("Hello, World!", strval);
046 }
047
048 public void testBindingVariables() throws Exception
049 {
050 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
051
052 final GxLanguageToolKit<I, U, N, A, S, T, X> xtk = new LanguageToolKit<I, U, N, A, S, T, X>(pcx);
053
054 final GxExprContextStaticArgs<I, U, N, A, S, T, X> statArgs = xtk.newStaticContextArgs();
055 statArgs.setEmulation(Emulation.MODERN);
056
057 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
058 final SmName<S> varName = new SmName<S>(nameBridge.symbolize("x"), nameBridge);
059
060 final GxMetaBridge<A, S, T> metaBridge = pcx.getMetaBridge();
061 statArgs.bindVariableType(varName, metaBridge.getType(SmNativeType.STRING));
062
063 final String es = "concat('Hello', ', ', $x, '!')";
064 final T sfocus = metaBridge.emptyType();
065
066 final ExprResult<I, U, N, A, S, T, X> prepared = xtk.prepare(es, sfocus, statArgs);
067
068 final GxExprContextDynamicArgs<I, U, N, A, S, T, X> dynArgs = xtk.newDynamicContextArgs();
069 dynArgs.setEmulation(Emulation.MODERN);
070
071 final GxVariantBridge<I, N, A, X> valueBridge = pcx.getVariantBridge();
072 final X value = valueBridge.stringValue("World");
073 dynArgs.bindVariableValue(varName, value);
074
075 final GxExpr<I, U, N, A, S, T, X> expr = prepared.getExpr();
076 final GxFocus<I> dfocus = xtk.emptyFocus();
077 final String strval = expr.stringFunction(dfocus, dynArgs, pcx);
078
079 assertEquals("Hello, World!", strval);
080 }
081
082 public void testEXSLT() throws Exception
083 {
084 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
085 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
086
087 final GxLanguageToolKit<I, U, N, A, S, T, X> xtk = new LanguageToolKit<I, U, N, A, S, T, X>(pcx);
088
089 final GxExprContextStaticArgs<I, U, N, A, S, T, X> sarg = xtk.newStaticContextArgs();
090 sarg.getInScopeNamespaces().declarePrefix("math", nameBridge.symbolize("http://exslt.org/math"));
091 final ExsltMathFunctionGroup<I, U, N, A, S, T, X> exsltMathFunctionGroup = new ExsltMathFunctionGroup<I, U, N, A, S, T, X>("http://exslt.org/math", pcx);
092 sarg.setFunctionSigns("http://exslt.org/math", exsltMathFunctionGroup);
093 // The function implementations can be provided now or just prior to execution.
094 sarg.setFunctionImpls("http://exslt.org/math", exsltMathFunctionGroup);
095
096 final GxMetaBridge<A, S, T> metaBridge = pcx.getMetaBridge();
097
098 final ExprResult<I, U, N, A, S, T, X> prepared = xtk.prepare("math:exp(1)", metaBridge.emptyType(), sarg);
099
100 final GxExpr<I, U, N, A, S, T, X> expr = prepared.getExpr();
101
102 final GxExprContextDynamicArgs<I, U, N, A, S, T, X> darg = xtk.newDynamicContextArgs();
103 // Here we also (redundantly) provide the function implementations just prior to execution.
104 darg.setFunctionImpls("http://exslt.org/math", exsltMathFunctionGroup);
105
106 final String strval = expr.stringFunction(xtk.emptyFocus(), darg, pcx);
107
108 assertEquals("2.7182818284590455", strval);
109 }
110
111 public void testExpressionType() throws Exception
112 {
113 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
114
115 final GxLanguageToolKit<I, U, N, A, S, T, X> xtk = new LanguageToolKit<I, U, N, A, S, T, X>(pcx);
116
117 final GxExprContextStaticArgs<I, U, N, A, S, T, X> sarg = xtk.newStaticContextArgs();
118
119 final GxMetaBridge<A, S, T> metaBridge = pcx.getMetaBridge();
120
121 final ExprResult<I, U, N, A, S, T, X> prepared = xtk.prepare("'Hello'", metaBridge.emptyType(), sarg);
122 /* final GxExpr<I, U, N, A, S, T, X> expr = */prepared.getExpr();
123 /* final GxExprInfo<T> info = */prepared.getInfo();
124 }
125 }
XSLT
 
001 package org.gxml.book.xslt;
002
003 import java.io.IOException;
004 import java.io.InputStream;
005 import java.io.StringReader;
006 import java.io.StringWriter;
007 import java.net.URI;
008 import java.net.URISyntaxException;
009
010 import javax.xml.namespace.QName;
011 import javax.xml.parsers.ParserConfigurationException;
012
013 import org.gxml.book.common.SampleApp;
014 import org.gxml.sa.GxException;
015 import org.gxml.sa.GxMetaBridge;
016 import org.gxml.sa.GxModel;
017 import org.gxml.sa.GxNameBridge;
018 import org.gxml.sa.GxProcessingContext;
019 import org.gxml.sa.GxSequenceHandler;
020 import org.gxml.sa.GxVariantBridge;
021 import org.gxml.xdm.NodeKind;
022 import org.gxml.xdm.Resolved;
023 import org.gxml.xdm.Resolver;
024 import org.gxml.xs.SmName;
025 import org.gxml.xs.SmNativeType;
026
027 import com.tibco.gxml.sa.api.common.lang.ExprException;
028 import com.tibco.gxml.sa.common.helpers.DocumentBuilderFactory;
029 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilder;
030 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilderFactory;
031 import com.tibco.gxml.sa.processor.serialization.api.GxSerializerFactory;
032 import com.tibco.gxml.sa.processor.serialization.impl.SerializerFactory;
033 import com.tibco.gxml.sa.processor.xslt.GxTransform;
034 import com.tibco.gxml.sa.processor.xslt.GxTransformBuilder;
035 import com.tibco.gxml.sa.processor.xslt.GxTransformer;
036 import com.tibco.gxml.sa.processor.xslt.XSLTransformBuilder;
037 import com.tibco.gxmlsa.processor.org.exslt.strings.ExsltStringsFunctionGroup;
038
039 public abstract class XSLTSample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
040 {
041 public void testExample() throws ParserConfigurationException, IOException, GxException, ExprException, URISyntaxException
042 {
043 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
044 final GxMetaBridge<A, S, T> metaBridge = pcx.getMetaBridge();
045 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
046
047 final Resolver resolver = getResolver();
048
049 final URI xmlSystemId = new URI("hotel.xml");
050 final Resolved<InputStream> xmlInput = resolver.resolveInputStream(xmlSystemId);
051
052 final GxDocumentBuilderFactory<N, S> f = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
053 f.setIgnoreComments(false);
054
055 final GxDocumentBuilder<N> builder = f.newDocumentBuilder();
056
057 final N document = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
058
059 final URI xslSystemId = new URI("hotel.xsl");
060 final Resolved<InputStream> xslInput = resolver.resolveInputStream(xslSystemId);
061
062 final GxTransformBuilder<I, U, N, A, S, T, X> compiler = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
063
064 compiler.setCompatibleMode(true);
065 // compiler.setRestrictedMode(true); // XSLT 2.0 subset for mapper.
066
067 // Specify the static type for the context item:
068 // document-node(element(*,xs:untyped))
069 final T documentType = metaBridge.documentType(metaBridge.elementType(new SmName<S>(null, null, nameBridge), metaBridge.getType(SmNativeType.UNTYPED), false));
070 compiler.setFocus(documentType);
071
072 final GxTransform<I, U, N, A, S, T, X> compiled = compiler.prepareTransform(xslInput.getResource(), xslInput.getSystemId());
073
074 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
075
076 // TODO: Extract output configuration.
077 // compiled.configure(sf);
078
079 sf.setIndent(true);
080
081 final StringWriter w = new StringWriter();
082
083 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(w);
084
085 final GxTransformer<I, U, N, A, S, T, X> transformer = compiled.newTransformer();
086
087 transformer.transform(document, pcx, handler);
088
089 @SuppressWarnings("unused")
090 final String s = w.toString();
091 // System.out.println(s);
092 }
093
094 @SuppressWarnings("unused")
095 private void bar(final GxProcessingContext<I, U, N, A, S, T, X> pcx)
096 {
097 try
098 {
099 final GxTransformBuilder<I, U, N, A, S, T, X> builder = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
100
101 final GxTransform<I, U, N, A, S, T, X> transform = builder.prepareTransform(new StringReader("<x xsl:version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'></x>"), new URI(""));
102
103 final GxTransformer<I, U, N, A, S, T, X> transformer = transform.newTransformer();
104
105 final N document = transformer.transform(null, pcx);
106
107 final GxModel<N, A, S, T> model = pcx.getModel();
108
109 final N element = model.getFirstChild(document);
110
111 final String name = model.getLocalNameAsString(element);
112
113 // System.out.println("XSLT: " + name);
114 }
115 catch (final Throwable e)
116 {
117 e.printStackTrace();
118 }
119 }
120
121 public void skipVariableBinding() throws ParserConfigurationException, IOException, GxException, ExprException, URISyntaxException
122 {
123 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
124
125 final Resolver resolver = getResolver();
126
127 final URI xslSystemId = new URI("email.xsl");
128 final Resolved<InputStream> xslInput = resolver.resolveInputStream(xslSystemId);
129
130 final GxTransformBuilder<I, U, N, A, S, T, X> compiler = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
131
132 final GxTransform<I, U, N, A, S, T, X> compiled = compiler.prepareTransform(xslInput.getResource(), xslInput.getSystemId());
133
134 final GxTransformer<I, U, N, A, S, T, X> transformer = compiled.newTransformer();
135
136 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
137 final SmName<S> varName = nameBridge.name(new QName("to"));
138 final GxVariantBridge<I, N, A, X> valueBridge = pcx.getVariantBridge();
139 final X value = valueBridge.stringValue("David");
140
141 transformer.bindVariableValue(varName, value);
142 transformer.bindVariableValue(nameBridge.name(new QName("http://www.example.com", "from")), valueBridge.stringValue("Julie"));
143
144 final N documentNode = transformer.transform(null, pcx);
145
146 final GxModel<N, A, S, T> model = pcx.getModel();
147
148 assertEquals(NodeKind.DOCUMENT, model.getNodeKind(documentNode));
149 final N email = model.getFirstChildElement(documentNode);
150 final N to = model.getFirstChildElementByName(email, nameBridge.symbolize("http://www.example.com"), nameBridge.symbolize("to"));
151 assertEquals("David", model.getStringValue(to));
152 final N from = model.getFirstChildElementByName(email, null, nameBridge.symbolize("from"));
153 assertEquals("Julie", model.getStringValue(from));
154 final N again = model.getFirstChildElementByName(email, nameBridge.symbolize("http://www.example.com"), null);
155 assertEquals("David", model.getStringValue(again));
156 }
157
158 public void skipExternalFunctions() throws ParserConfigurationException, IOException, GxException, ExprException, URISyntaxException
159 {
160 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
161
162 final Resolver resolver = getResolver();
163
164 final Resolved<InputStream> xmlInput = resolver.resolveInputStream(new URI("exslt.xml"));
165
166 final GxDocumentBuilderFactory<N, S> f = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
167
168 final GxDocumentBuilder<N> builder = f.newDocumentBuilder();
169
170 final N document = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
171
172 final Resolved<InputStream> xslInput = resolver.resolveInputStream(new URI("exslt.xsl"));
173
174 final GxTransformBuilder<I, U, N, A, S, T, X> compiler = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
175
176 final String namespaceURI = "http://exslt.org/strings";
177 final ExsltStringsFunctionGroup<I, U, N, A, S, T, X> functions = new ExsltStringsFunctionGroup<I, U, N, A, S, T, X>(namespaceURI, pcx);
178 compiler.setFunctionSigns(namespaceURI, functions);
179 compiler.setFunctionImpls(namespaceURI, functions);
180
181 final GxTransform<I, U, N, A, S, T, X> compiled = compiler.prepareTransform(xslInput.getResource(), xslInput.getSystemId());
182
183 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
184
185 // TODO: Extract configuration.
186 // compiled.configure(sf);
187
188 sf.setIndent(true);
189
190 final StringWriter w = new StringWriter();
191
192 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(w);
193
194 final GxTransformer<I, U, N, A, S, T, X> transformer = compiled.newTransformer();
195
196 transformer.transform(document, pcx, handler);
197
198 // System.out.println(w.toString());
199 }
200
201 public void skipHotel() throws ParserConfigurationException, IOException, GxException, ExprException, URISyntaxException
202 {
203 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
204
205 final Resolver resolver = getResolver();
206
207 final Resolved<InputStream> xmlInput = resolver.resolveInputStream(new URI("hotel.xml"));
208
209 final GxDocumentBuilderFactory<N, S> f = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
210
211 final GxDocumentBuilder<N> builder = f.newDocumentBuilder();
212
213 final N document = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
214
215 final Resolved<InputStream> xslInput = resolver.resolveInputStream(new URI("hotel.xsl"));
216
217 final GxTransformBuilder<I, U, N, A, S, T, X> compiler = new XSLTransformBuilder<I, U, N, A, S, T, X>(pcx);
218
219 final GxTransform<I, U, N, A, S, T, X> compiled = compiler.prepareTransform(xslInput.getResource(), xslInput.getSystemId());
220
221 final GxTransformer<I, U, N, A, S, T, X> transformer = compiled.newTransformer();
222 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
223 final SmName<S> varName = nameBridge.name(new QName("MessageData"));
224 final GxVariantBridge<I, N, A, X> valueBridge = pcx.getVariantBridge();
225 final X value = valueBridge.node(document);
226
227 transformer.bindVariableValue(varName, value);
228
229 final N documentNode = transformer.transform(null, pcx);
230
231 final GxModel<N, A, S, T> model = pcx.getModel();
232
233 assertEquals(NodeKind.DOCUMENT, model.getNodeKind(documentNode));
234 final N searchHotelRequest = model.getFirstChildElement(documentNode);
235 final N parameters = model.getFirstChildElementByName(searchHotelRequest, nameBridge.symbolize("http://xmlns.example.com/1189038295781"), nameBridge.symbolize("parameters"));
236 final N searchHotel = model.getFirstChildElementByName(parameters, nameBridge.symbolize("http://www.xyzcorp/procureservice/QueryGDS_Europe/"), nameBridge.symbolize("searchHotel"));
237 final N country = model.getFirstChildElementByName(searchHotel, nameBridge.symbolize("http://www.xyzcorp/procureservice/QueryGDS_Europe/"), nameBridge.symbolize("country"));
238 assertEquals("USA", model.getStringValue(country));
239 }
240 }
 
XQuery
 
001 package org.gxml.book.xquery;
002
003 import java.io.StringWriter;
004 import java.math.BigInteger;
005 import java.net.URI;
006
007 import javax.xml.namespace.QName;
008
009 import org.gxml.book.common.SampleApp;
010 import org.gxml.sa.GxAtomBridge;
011 import org.gxml.sa.GxNameBridge;
012 import org.gxml.sa.GxProcessingContext;
013 import org.gxml.sa.GxSequenceHandler;
014 import org.gxml.sa.GxVariantBridge;
015 import org.gxml.xs.SmName;
016
017 import com.tibco.gxml.sa.api.common.lang.GxXQConnection;
018 import com.tibco.gxml.sa.api.common.lang.GxXQDataSource;
019 import com.tibco.gxml.sa.api.common.lang.GxXQExpression;
020 import com.tibco.gxml.sa.api.common.lang.GxXQPreparedExpression;
021 import com.tibco.gxml.sa.processor.serialization.api.GxSerializerFactory;
022 import com.tibco.gxml.sa.processor.serialization.impl.SerializerFactory;
023 import com.tibco.gxml.sa.processor.xquery.XQEngine;
024 import com.tibco.gxml.sa.processor.xquery.XQErrorCatcher;
025
026 /**
027 * Introduction to XQuery.
028 */
029 public abstract class XQuerySample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
030 {
031 public void testExample() throws Exception
032 {
033 // Obtain a new processing context from the application.
034 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
035
036 final GxXQDataSource<I, U, N, A, S, T, X> ds = new XQEngine<I, U, N, A, S, T, X>(pcx);
037
038 final GxXQConnection<I, U, N, A, S, T, X> conn = ds.getConnection();
039
040 final String expression = "<x>{text{for $i in (1,2,3,4) return $i * 2}}</x>";
041
042 final GxXQPreparedExpression<I, U, N, A, S, T, X> expr = conn.prepareExpression(expression);
043
044 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
045 sf.setMethod(new QName("xml"));
046 sf.setOmitXmlDeclaration(true);
047 final StringWriter sw = new StringWriter();
048 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(sw);
049
050 expr.executeQuery(handler);
051
052 final String actual = sw.toString();
053 assertEquals(expression, "<x>2 4 6 8</x>", actual);
054 }
055
056 public void testGettingStarted() throws Exception
057 {
058 // Obtain a new processing context from the application.
059 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
060
061 final GxXQDataSource<I, U, N, A, S, T, X> ds = new XQEngine<I, U, N, A, S, T, X>(pcx);
062
063 final GxXQConnection<I, U, N, A, S, T, X> conn = ds.getConnection();
064
065 final GxXQExpression<I, U, N, A, S, T, X> expr = conn.createExpression();
066
067 final String es = "for $n in fn:doc('catalog.xml')//item return fn:data($n/name)";
068
069 final URI systemId = new URI("catalog.xml");
070
071 expr.setBaseURI(systemId);
072
073 @SuppressWarnings("unused")
074 final X value = expr.executeQuery(es);
075 }
076
077 public void testHelloWorld() throws Exception
078 {
079 final GxProcessingContext<I, U, N, A, S, T, X> pcx = this.newProcessingContext();
080
081 final GxXQDataSource<I, U, N, A, S, T, X> ds = new XQEngine<I, U, N, A, S, T, X>(pcx);
082
083 final GxXQConnection<I, U, N, A, S, T, X> conn = ds.getConnection();
084
085 conn.setScriptingMode(true);
086
087 final String expression = "declare variable $x external; concat('Hello, ',$x, '!')";
088
089 final GxXQPreparedExpression<I, U, N, A, S, T, X> expr = conn.prepareExpression(expression);
090
091 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
092 sf.setOmitXmlDeclaration(true);
093 sf.setIndent(false);
094 sf.setMethod(new QName("xml"));
095 final StringWriter sw = new StringWriter();
096 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(sw);
097
098 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
099 final GxVariantBridge<I, N, A, X> valueBridge = pcx.getVariantBridge();
100
101 final SmName<S> varName = new SmName<S>(nameBridge.symbolize("x"), nameBridge);
102 final X value = valueBridge.stringValue("World");
103
104 expr.bindVariableValue(varName, value);
105
106 expr.executeQuery(handler);
107
108 String actual = sw.toString();
109 assertEquals(expression, "Hello, World!", actual);
110 }
111
112 public void testMergeTextNodes() throws Exception
113 {
114 // Obtain a new processing context from the application.
115 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
116
117 final GxXQDataSource<I, U, N, A, S, T, X> ds = new XQEngine<I, U, N, A, S, T, X>(pcx);
118
119 final GxXQConnection<I, U, N, A, S, T, X> conn = ds.getConnection();
120
121 // final String expression = "";
122 final String expression = "count((element elem {1, 'string', 1,2e3})/text())";
123
124 final GxXQPreparedExpression<I, U, N, A, S, T, X> expr = conn.prepareExpression(expression);
125
126 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
127 sf.setMethod(new QName("xml"));
128 sf.setOmitXmlDeclaration(true);
129 final StringWriter sw = new StringWriter();
130 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(sw);
131
132 expr.executeQuery(handler);
133
134 final String actual = sw.toString();
135 assertEquals(expression, "1", actual);
136 }
137
138 public void testProblem() throws Exception
139 {
140 final GxProcessingContext<I, U, N, A, S, T, X> pcx = this.newProcessingContext();
141
142 final GxXQDataSource<I, U, N, A, S, T, X> ds = new XQEngine<I, U, N, A, S, T, X>(pcx);
143
144 final GxXQConnection<I, U, N, A, S, T, X> conn = ds.getConnection();
145
146 final XQErrorCatcher messages = new XQErrorCatcher();
147
148 conn.setErrorHandler(messages);
149 conn.setCompatibleMode(false);
150 conn.setScriptingMode(true);
151
152 final String expression = "(xs:untypedAtomic('1'),xs:untypedAtomic('2')) = (xs:untypedAtomic('2.0'),2.0)";
153
154 final GxXQPreparedExpression<I, U, N, A, S, T, X> expr = conn.prepareExpression(expression);
155
156 final X value = expr.executeQuery();
157
158 final GxVariantBridge<I, N, A, X> variantBridge = pcx.getVariantBridge();
159 switch (variantBridge.getNature(value))
160 {
161 case ITEMS:
162 {
163 @SuppressWarnings("unused")
164 final Iterable<I> items = variantBridge.getItemSet(value);
165 // System.out.println(items);
166 }
167 break;
168 case ATOM:
169 {
170 @SuppressWarnings("unused")
171 final A atom = variantBridge.getAtom(value);
172 @SuppressWarnings("unused")
173 final GxAtomBridge<A, S> atomBridge = pcx.getAtomBridge();
174 // System.out.println(atomBridge.getC14NForm(atom));
175 }
176 break;
177 case STRING:
178 {
179 @SuppressWarnings("unused")
180 final String strval = variantBridge.getString(value);
181 // System.out.println(strval);
182 }
183 break;
184 case INTEGER:
185 {
186 @SuppressWarnings("unused")
187 final BigInteger integer = variantBridge.getInteger(value);
188 // System.out.println(integer);
189 }
190 break;
191 default:
192 {
193 throw new AssertionError(variantBridge.getNature(value));
194 }
195 }
196 }
197
198 public void testTyping() throws Exception
199 {
200 final GxProcessingContext<I, U, N, A, S, T, X> pcx = this.newProcessingContext();
201
202 final GxXQDataSource<I, U, N, A, S, T, X> ds = new XQEngine<I, U, N, A, S, T, X>(pcx);
203
204 final GxXQConnection<I, U, N, A, S, T, X> conn = ds.getConnection();
205
206 conn.setScriptingMode(true);
207
208 final XQErrorCatcher messages = new XQErrorCatcher();
209
210 conn.setErrorHandler(messages);
211
212 final String expression = "declare variable $x external; contains(string(number($x)),'NaN')";
213
214 final GxXQPreparedExpression<I, U, N, A, S, T, X> expr = conn.prepareExpression(expression);
215
216 final GxSerializerFactory<I, U, N, A, S, T, X> sf = new SerializerFactory<I, U, N, A, S, T, X>(pcx);
217 sf.setOmitXmlDeclaration(true);
218 sf.setIndent(false);
219 sf.setMethod(new QName("xml"));
220 final StringWriter sw = new StringWriter();
221 final GxSequenceHandler<A, S, T> handler = sf.newSerializer(sw);
222
223 final GxNameBridge<S> nameBridge = pcx.getNameBridge();
224 final GxVariantBridge<I, N, A, X> valueBridge = pcx.getVariantBridge();
225
226 final SmName<S> varName = new SmName<S>(nameBridge.symbolize("x"), nameBridge);
227 final X value = valueBridge.doubleValue(5.0);
228
229 expr.bindVariableValue(varName, value);
230
231 expr.executeQuery(handler);
232
233 String actual = sw.toString();
234 assertEquals(expression, "false", actual);
235 }
236 }
Validation
 
001 package org.gxml.book.validation;
002
003 import java.io.InputStream;
004 import java.net.URI;
005 import java.util.LinkedList;
006 import java.util.List;
007
008 import org.gxml.book.common.SampleApp;
009 import org.gxml.sa.GxFragmentBuilder;
010 import org.gxml.sa.GxModel;
011 import org.gxml.sa.GxProcessingContext;
012 import org.gxml.xdm.Resolved;
013 import org.gxml.xdm.Resolver;
014 import org.gxml.xs.SmException;
015 import org.gxml.xs.SmExceptionCatcher;
016 import org.gxml.xs.SmExceptionHandler;
017 import org.gxml.xs.SmMetaLoadArgs;
018
019 import com.tibco.gxml.sa.common.helpers.DocumentBuilderFactory;
020 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilder;
021 import com.tibco.gxml.sa.common.helpers.GxDocumentBuilderFactory;
022 import com.tibco.gxml.sa.common.helpers.SmAtomBridgeOnGxAtomBridgeAdapter;
023 import com.tibco.gxml.sa.processor.validation.GxContentValidator;
024 import com.tibco.gxml.sa.processor.validation.GxValidatorCache;
025 import com.tibco.gxml.sa.processor.validation.GxValidatorCacheFactory;
026 import com.tibco.gxml.sa.processor.validation.ValidatorCacheFactory;
027 import com.tibco.gxml.xs.W3cXmlSchemaParser;
028
029 public abstract class ValidationSample<I, U, N extends I, A extends I, S, T, X> extends SampleApp<I, U, N, A, S, T, X>
030 {
031 public void testByteStreamValidation() throws Exception
032 {
033 // Load a top-level schema into the processing context.
034 final List<Resolved<InputStream>> resources = new LinkedList<Resolved<InputStream>>();
035 resources.add(getResolver().resolveInputStream(new URI("PurchaseOrder.xsd")));
036
037 final SmExceptionCatcher errors = new SmExceptionCatcher();
038 final SmMetaLoadArgs args = new SmMetaLoadArgs();
039
040 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
041
042 final W3cXmlSchemaParser<A, S> parser = new W3cXmlSchemaParser<A, S>(new SmAtomBridgeOnGxAtomBridgeAdapter<A, S>(pcx.getAtomBridge()));
043
044 for (final Resolved<InputStream> resource : resources)
045 {
046 pcx.register(parser.parse(resource.getLocation(), resource.getResource(), resource.getSystemId(), errors, args, pcx));
047 }
048
049 pcx.lock();
050
051 // Create a validator...
052 final GxValidatorCacheFactory<A, S, T> vcf = new ValidatorCacheFactory<I, U, N, A, S, T, X>(pcx);
053 final GxValidatorCache<A, S, T> vc = vcf.newValidatorCache();
054 final GxContentValidator<A, S, T> validator = vc.newContentValidator();
055
056 // Set the downstream event handler which contains annotations and typed content.
057 // validator.setGxContentHandler(/* ...*/null);
058 validator.setExceptionHandler(errors);
059
060 // The document node that we wish to validate.
061 final Resolved<InputStream> xmlInput = getResolver().resolveInputStream(new URI("PurchaseOrder.xml"));
062
063 final GxDocumentBuilderFactory<N, S> factory = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
064
065 final GxDocumentBuilder<N> builder = factory.newDocumentBuilder();
066
067 final N document = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
068
069 // Stream the document into the validator.
070 final GxModel<N, A, S, T> model = pcx.getModel();
071
072 model.stream(document, true, true, validator);
073
074 if (errors.size() > 0)
075 {
076 // You've got errors.'
077 }
078 }
079
080 public void testTreeValidation() throws Exception
081 {
082 final Resolver resolver = getResolver();
083
084 // Load a top-level schema into the processing context.
085 final List<Resolved<InputStream>> resources = new LinkedList<Resolved<InputStream>>();
086 resources.add(getResolver().resolveInputStream(new URI("PurchaseOrder.xsd")));
087
088 final SmExceptionCatcher errors = new SmExceptionCatcher();
089 final SmMetaLoadArgs args = new SmMetaLoadArgs();
090
091 final GxProcessingContext<I, U, N, A, S, T, X> pcx = newProcessingContext();
092 final W3cXmlSchemaParser<A, S> parser = new W3cXmlSchemaParser<A, S>(new SmAtomBridgeOnGxAtomBridgeAdapter<A, S>(pcx.getAtomBridge()));
093 for (final Resolved<InputStream> resource : resources)
094 {
095 pcx.register(parser.parse(resource.getLocation(), resource.getResource(), resource.getSystemId(), errors, args, pcx));
096 }
097 pcx.lock();
098 // The document node that we wish to validate.
099 @SuppressWarnings("unused")
100 final URI xmlLocation = new URI("PurchaseOrder.xml");
101 final URI xmlSystemId = new URI("PurchaseOrder.xml");
102 final Resolved<InputStream> xmlInput = resolver.resolveInputStream(xmlSystemId);
103
104 final GxDocumentBuilderFactory<N, S> factory = new DocumentBuilderFactory<I, U, N, A, S, T, X>(pcx);
105
106 final GxDocumentBuilder<N> builder = factory.newDocumentBuilder();
107
108 final N documentIn = builder.parse(xmlInput.getResource(), xmlInput.getSystemId());
109
110 @SuppressWarnings("unused")
111 final N documentOut = validate(documentIn, errors, pcx);
112
113 if (errors.size() > 0)
114 {
115 // You've got errors.'
116 for (@SuppressWarnings("unused")
117 final SmException error : errors)
118 {
119 // System.out.println(error.getLocalizedMessage());
120 }
121 }
122 }
123
124 /**
125 * This static function illustrates a helper function for validating a document tree. <br/>
126 * Note that we assume that the processing context is already loaded with meta-data.
127 *
128 * @param node
129 * The input document.
130 * @param errors
131 * The error handler.
132 * @param pcx
133 * The processing context.
134 */
135 public static <I, U, N extends I, A extends I, S, T, X> N validate(final N node, final SmExceptionHandler errors, final GxProcessingContext<I, U, N, A, S, T, X> pcx)
136 {
137 final GxValidatorCacheFactory<A, S, T> vcf = new ValidatorCacheFactory<I, U, N, A, S, T, X>(pcx);
138
139 // We already have a tree as input so we'll use the content validator'
140 // and stream the document in as a bunch of events (a bit like SAX, but not lexical).
141 final GxValidatorCache<A, S, T> vc = vcf.newValidatorCache();
142
143 final GxContentValidator<A, S, T> validator = vc.newContentValidator();
144
145 validator.setExceptionHandler(errors);
146
147 final GxModel<N, A, S, T> model = pcx.getModel();
148
149 // We want to produce a node so we'll need a fragment builder at the output.'
150 final GxFragmentBuilder<N, A, S, T> builder = pcx.newFragmentBuilder();
151
152 // Connect the pieces together so that the validation output builds a tree.
153 validator.setGxContentHandler(builder);
154
155 // Make it so!
156 model.stream(node, true, true, validator);
157
158 // Practice safe coding: We don't know what might happen if there are errors.'
159 final List<? extends N> nodes = builder.getNodes();
160 if (nodes.size() > 0)
161 {
162 return nodes.get(0);
163 }
164 else
165 {
166 return null;
167 }
168 }
169 }