← Back to branch summary

~paul-lucas/zorba/bug-932374

« back to all changes in this revision

Viewing changes to swig/xqj/XQConnection.java

  • Committer: Paul J. Lucas
  • Date: 2012-09-21 20:26:47 UTC
  • mfrom: (10819.2.235 zorba)
  • Revision ID: paul@lucasmail.org-20120921202647-fy9n4jduhrnljrnb
Merge from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
swig/xqj/XQConnection.java
1
 
/*
2
 
 * Copyright 2006-2012 The FLWOR Foundation.
3
 
 *
4
 
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 
 * you may not use this file except in compliance with the License.
6
 
 * You may obtain a copy of the License at
7
 
 * 
8
 
 * http://www.apache.org/licenses/LICENSE-2.0
9
 
 *
10
 
 * Unless required by applicable law or agreed to in writing, software
11
 
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 
 * See the License for the specific language governing permissions and
14
 
 * limitations under the License.
15
 
 */
16
 
package org.zorbaxquery.api.xqj;
17
 
 
18
 
import java.io.IOException;
19
 
import java.io.InputStream;
20
 
import java.io.Reader;
21
 
import java.io.StringWriter;
22
 
import java.io.Writer;
23
 
import java.math.BigDecimal;
24
 
import java.math.BigInteger;
25
 
import java.net.URI;
26
 
import java.util.Iterator;
27
 
import java.nio.CharBuffer;
28
 
import java.util.ArrayList;
29
 
import java.util.Collection;
30
 
import java.util.Properties;
31
 
import javax.xml.datatype.DatatypeConstants;
32
 
import javax.xml.datatype.Duration;
33
 
import javax.xml.datatype.XMLGregorianCalendar;
34
 
import javax.xml.namespace.QName;
35
 
import javax.xml.stream.XMLOutputFactory;
36
 
import javax.xml.stream.XMLStreamReader;
37
 
import javax.xml.stream.XMLStreamWriter;
38
 
import javax.xml.transform.OutputKeys;
39
 
import javax.xml.transform.Source;
40
 
import javax.xml.transform.Transformer;
41
 
import javax.xml.transform.TransformerException;
42
 
import javax.xml.transform.TransformerFactory;
43
 
import javax.xml.transform.dom.DOMSource;
44
 
import javax.xml.transform.sax.SAXSource;
45
 
import javax.xml.transform.stax.StAXResult;
46
 
import javax.xml.transform.stax.StAXSource;
47
 
import javax.xml.transform.stream.StreamResult;
48
 
import javax.xml.transform.stream.StreamSource;
49
 
import javax.xml.xquery.XQException;
50
 
import javax.xml.xquery.XQExpression;
51
 
import javax.xml.xquery.XQItem;
52
 
import javax.xml.xquery.XQItemType;
53
 
import javax.xml.xquery.XQMetaData;
54
 
import javax.xml.xquery.XQPreparedExpression;
55
 
import javax.xml.xquery.XQSequence;
56
 
import javax.xml.xquery.XQSequenceType;
57
 
import javax.xml.xquery.XQStaticContext;
58
 
import org.w3c.dom.Attr;
59
 
import org.w3c.dom.Comment;
60
 
import org.w3c.dom.Document;
61
 
import org.w3c.dom.DocumentFragment;
62
 
import org.w3c.dom.Element;
63
 
import org.w3c.dom.Node;
64
 
import org.w3c.dom.ProcessingInstruction;
65
 
import org.w3c.dom.Text;
66
 
import org.zorbaxquery.api.InMemoryStore;
67
 
import org.zorbaxquery.api.Item;
68
 
import org.zorbaxquery.api.ItemFactory;
69
 
import org.zorbaxquery.api.StringVector;
70
 
import org.zorbaxquery.api.XmlDataManager;
71
 
import org.zorbaxquery.api.Zorba;
72
 
 
73
 
public class XQConnection implements javax.xml.xquery.XQConnection {
74
 
    private InMemoryStore store;
75
 
    private Zorba zorba;
76
 
    private boolean autocommit;
77
 
    private boolean closed;
78
 
    private Collection<XQExpression> cExpression;
79
 
    private Collection<XQPreparedExpression> cPreparedExpression;
80
 
    private Collection<XQMetaData> cMetadata;
81
 
    private XQStaticContext lStaticContext;
82
 
    private XQXmlDataManager lXmlDataManager;
83
 
    private Properties properties;
84
 
    private StringVector uriPaths;
85
 
    private StringVector libPaths;
86
 
    private StringVector modulePaths;
87
 
    
88
 
    protected Zorba getZorbaInstance() throws XQException {
89
 
        if (zorba!=null) {
90
 
            return zorba;
91
 
        } else {
92
 
            throw new XQException("Error returning Zorba Instance");
93
 
        }
94
 
    }
95
 
    public XQConnection() {
96
 
        cExpression = new ArrayList<XQExpression>();
97
 
        cPreparedExpression = new ArrayList<XQPreparedExpression>();
98
 
        store = InMemoryStore.getInstance();
99
 
        zorba = Zorba.getInstance ( store );
100
 
        autocommit = true;
101
 
        closed = false;
102
 
    }
103
 
    public XQConnection(Properties aProperties) {
104
 
        cExpression = new ArrayList<XQExpression>();
105
 
        cPreparedExpression = new ArrayList<XQPreparedExpression>();
106
 
        store = InMemoryStore.getInstance();
107
 
        zorba = Zorba.getInstance ( store );
108
 
        autocommit = true;
109
 
        closed = false;
110
 
        properties = aProperties;
111
 
        for (String prop :properties.stringPropertyNames()) {
112
 
            if (prop.equalsIgnoreCase(XQDataSource.ZORBA_PROPERTIES_URI_PATHS)) {
113
 
                String[] paths = properties.getProperty(prop).split("[;,]");
114
 
                uriPaths = new StringVector();
115
 
                for (String path: paths) {
116
 
                    uriPaths.add(path);
117
 
                }
118
 
            }
119
 
            if (prop.equalsIgnoreCase(XQDataSource.ZORBA_PROPERTIES_LIB_PATHS)) {
120
 
                String[] paths = properties.getProperty(prop).split("[;,]");
121
 
                libPaths = new StringVector();
122
 
                for (String path: paths) {
123
 
                    libPaths.add(path);
124
 
                }
125
 
            }
126
 
            if (prop.equalsIgnoreCase(XQDataSource.ZORBA_PROPERTIES_MODULE_PATHS)) {
127
 
                String[] paths = properties.getProperty(prop).split("[;,]");
128
 
                modulePaths = new StringVector();
129
 
                for (String path: paths) {
130
 
                    modulePaths.add(path);
131
 
                }
132
 
            }
133
 
        }
134
 
        lStaticContext = new org.zorbaxquery.api.xqj.XQStaticContext(zorba);
135
 
        if (uriPaths!=null) {
136
 
            ((org.zorbaxquery.api.xqj.XQStaticContext)lStaticContext).setURIPaths(uriPaths);
137
 
        }
138
 
        if (libPaths!=null) {
139
 
            ((org.zorbaxquery.api.xqj.XQStaticContext)lStaticContext).setLIBPaths(libPaths);
140
 
        }
141
 
        if (modulePaths!=null) {
142
 
            ((org.zorbaxquery.api.xqj.XQStaticContext)lStaticContext).setMODPaths(modulePaths);
143
 
        }
144
 
        
145
 
    }
146
 
    
147
 
    
148
 
    @Override
149
 
    public void close() throws XQException {
150
 
        if (closed) return; // already closed
151
 
        try {
152
 
            for (XQExpression exp : cExpression ){
153
 
                exp.close();  // Notify the dependents objects to close
154
 
            }
155
 
            for (XQPreparedExpression exp : cPreparedExpression ){
156
 
                exp.close();  // Notify the dependents objects to close
157
 
            }
158
 
        } catch (XQException e) {
159
 
            throw new XQException("Error closing connection: " + e.getLocalizedMessage());
160
 
        }
161
 
 
162
 
        if (lStaticContext != null ) {
163
 
            ((org.zorbaxquery.api.xqj.XQStaticContext)lStaticContext).getZorbaStaticContext().destroy();
164
 
        }
165
 
        if (lXmlDataManager != null) {
166
 
            lXmlDataManager.close();
167
 
        }
168
 
        zorba.shutdown();
169
 
        InMemoryStore.shutdown ( store );
170
 
        closed = true;
171
 
    }
172
 
    
173
 
    public XQXmlDataManager getXmlDataManager() {
174
 
        if (lXmlDataManager==null) {
175
 
            lXmlDataManager = new XQXmlDataManager(zorba);
176
 
        }
177
 
        return lXmlDataManager;
178
 
    }
179
 
 
180
 
    @Override
181
 
    public void setAutoCommit(boolean bln) throws XQException {
182
 
        isClosedXQException();
183
 
        autocommit = bln;
184
 
    }
185
 
 
186
 
    @Override
187
 
    public boolean getAutoCommit() throws XQException {
188
 
        isClosedXQException();
189
 
        return autocommit;
190
 
    }
191
 
 
192
 
    @Override
193
 
    public void commit() throws XQException {
194
 
        isClosedXQException();
195
 
        throw new UnsupportedOperationException("Zorba does not support transactions... yet...");
196
 
    }
197
 
 
198
 
    @Override
199
 
    public XQExpression createExpression() throws XQException {
200
 
        isClosedXQException();
201
 
        XQExpression expression;
202
 
        if (lStaticContext == null) {
203
 
            expression = new org.zorbaxquery.api.xqj.XQExpression(this);
204
 
        } else {
205
 
            expression = new org.zorbaxquery.api.xqj.XQExpression(this, lStaticContext);
206
 
        }
207
 
        cExpression.add(expression);
208
 
        return expression;
209
 
    }
210
 
 
211
 
    @Override
212
 
    public XQExpression createExpression(XQStaticContext value) throws XQException {
213
 
        isClosedXQException();
214
 
        isNullXQException(value);
215
 
        XQExpression expression = new org.zorbaxquery.api.xqj.XQExpression(this, value);
216
 
        cExpression.add(expression);
217
 
        return expression;
218
 
    }
219
 
 
220
 
    @Override
221
 
    public XQMetaData getMetaData() throws XQException {
222
 
        isClosedXQException();
223
 
        return new org.zorbaxquery.api.xqj.XQMetaData(this);
224
 
    }
225
 
 
226
 
    @Override
227
 
    public boolean isClosed() {
228
 
        return closed;
229
 
    }
230
 
 
231
 
    @Override
232
 
    public XQPreparedExpression prepareExpression(String value) throws XQException {
233
 
        isClosedXQException();
234
 
        isNullXQException(value);
235
 
        XQPreparedExpression expression;
236
 
        try {
237
 
            if (lStaticContext == null) {
238
 
                expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, value);
239
 
            } else {
240
 
                expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, value, lStaticContext);
241
 
            }
242
 
            cPreparedExpression.add(expression);
243
 
        } catch (Exception e) {
244
 
          throw new XQException("Error preparing expression: "+e.getLocalizedMessage());
245
 
        }
246
 
        return expression;
247
 
    }
248
 
 
249
 
    @Override
250
 
    public XQPreparedExpression prepareExpression(String string, XQStaticContext xqsc) throws XQException {
251
 
        isClosedXQException();
252
 
        isNullXQException(string);
253
 
        isNullXQException(xqsc);
254
 
        XQPreparedExpression expression = null;
255
 
        try {
256
 
            expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, string, xqsc);
257
 
            cPreparedExpression.add(expression);
258
 
        } catch (Exception e) {
259
 
          throw new XQException("Error preparing expression");
260
 
        }
261
 
        return expression;
262
 
    }
263
 
 
264
 
    @Override
265
 
    public XQPreparedExpression prepareExpression(Reader reader) throws XQException {
266
 
        isClosedXQException();
267
 
        isNullXQException(reader);
268
 
        
269
 
        StringBuffer string = new StringBuffer();
270
 
        CharBuffer buffer = CharBuffer.allocate(1024);
271
 
        Writer writer = new StringWriter();
272
 
        
273
 
        try {
274
 
            while( reader.read(buffer) >= 0 ) {
275
 
                buffer.flip();
276
 
                writer.append(buffer);
277
 
                buffer.clear();
278
 
            }
279
 
            reader.close();
280
 
        } catch (Exception ex) {
281
 
            throw new XQException("Error preparing expression" + ex.getLocalizedMessage());
282
 
        }
283
 
        
284
 
        XQPreparedExpression expression;
285
 
        if (lStaticContext == null) {
286
 
            expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, writer.toString());
287
 
        } else {
288
 
            expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, writer.toString(), lStaticContext);
289
 
        }
290
 
        cPreparedExpression.add(expression);
291
 
        return expression;
292
 
    }
293
 
 
294
 
    @Override
295
 
    public XQPreparedExpression prepareExpression(Reader reader, XQStaticContext xqsc) throws XQException {
296
 
        isClosedXQException();
297
 
        isNullXQException(reader);
298
 
        isNullXQException(xqsc);
299
 
        StringBuffer string = new StringBuffer();
300
 
        CharBuffer buffer = CharBuffer.allocate(1024);
301
 
        Writer writer = new StringWriter();
302
 
        try {
303
 
            while( reader.read(buffer) >= 0 ) {
304
 
                buffer.flip();
305
 
                writer.append(buffer);
306
 
                buffer.clear();
307
 
            }
308
 
            reader.close();
309
 
        } catch (Exception ex) {
310
 
            throw new XQException("Error preparing expression" + ex.getLocalizedMessage());
311
 
        }
312
 
        
313
 
        XQPreparedExpression expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, writer.toString(), xqsc);
314
 
        
315
 
        cPreparedExpression.add(expression);
316
 
        return expression;
317
 
    }
318
 
 
319
 
    @Override
320
 
    public XQPreparedExpression prepareExpression(InputStream in) throws XQException {
321
 
        isClosedXQException();
322
 
        isNullXQException(in);
323
 
        StringBuffer  out = new StringBuffer ();
324
 
        try {
325
 
            byte[] b = new byte[4096];
326
 
            for (int n; (n = in.read(b)) != -1;) {
327
 
                out.append(new String(b, 0, n));
328
 
            }
329
 
        } catch (Exception ex) {
330
 
            throw new XQException("Error preparing expression" + ex.getLocalizedMessage());
331
 
        }
332
 
        
333
 
        XQPreparedExpression expression;
334
 
        if (lStaticContext == null) {
335
 
            expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, out.toString());
336
 
        } else {
337
 
            expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, out.toString(), lStaticContext);
338
 
        }
339
 
        try {
340
 
            cPreparedExpression.add(expression);
341
 
        } catch (Exception ex) {
342
 
            throw new XQException("Error preparing expression" + ex.getLocalizedMessage());
343
 
        }
344
 
            
345
 
        return expression;
346
 
    }
347
 
 
348
 
    @Override
349
 
    public XQPreparedExpression prepareExpression(InputStream in, XQStaticContext xqsc) throws XQException {
350
 
        isClosedXQException();
351
 
        isNullXQException(in);
352
 
        isNullXQException(xqsc);
353
 
        StringBuffer  out = new StringBuffer ();
354
 
        try {
355
 
            byte[] b = new byte[4096];
356
 
            for (int n; (n = in.read(b)) != -1;) {
357
 
                out.append(new String(b, 0, n));
358
 
            }
359
 
        } catch (IOException ex) {
360
 
            throw new XQException("Error preparing expression" + ex.getLocalizedMessage());
361
 
        }
362
 
        
363
 
        XQPreparedExpression expression = null;
364
 
        try {
365
 
            expression = new org.zorbaxquery.api.xqj.XQPreparedExpression(this, out.toString(), xqsc);
366
 
            cPreparedExpression.add(expression);
367
 
        } catch (Exception ex) {
368
 
            throw new XQException("Error preparing expression" + ex.getLocalizedMessage());
369
 
        }
370
 
        return expression;
371
 
    }
372
 
 
373
 
    @Override
374
 
    public void rollback() throws XQException {
375
 
        throw new UnsupportedOperationException("Zorba does not support transactions... yet...");
376
 
    }
377
 
 
378
 
    @Override
379
 
    public XQStaticContext getStaticContext() throws XQException {
380
 
        isClosedXQException();
381
 
        lStaticContext = new org.zorbaxquery.api.xqj.XQStaticContext(zorba);
382
 
        if (uriPaths!=null) {
383
 
            ((org.zorbaxquery.api.xqj.XQStaticContext)lStaticContext).setURIPaths(uriPaths);
384
 
        }
385
 
        if (libPaths!=null) {
386
 
            ((org.zorbaxquery.api.xqj.XQStaticContext)lStaticContext).setLIBPaths(libPaths);
387
 
        }
388
 
        if (modulePaths!=null) {
389
 
            ((org.zorbaxquery.api.xqj.XQStaticContext)lStaticContext).setMODPaths(modulePaths);
390
 
        }
391
 
        return lStaticContext;
392
 
    }
393
 
 
394
 
    @Override
395
 
    public void setStaticContext(XQStaticContext xqsc) throws XQException {
396
 
        isClosedXQException();
397
 
        isNullXQException(xqsc);
398
 
        if ((lStaticContext!=null) && (lStaticContext!=xqsc)) {  // delete previous static context
399
 
            ((org.zorbaxquery.api.xqj.XQStaticContext)lStaticContext).getZorbaStaticContext().delete();
400
 
        }
401
 
        lStaticContext = xqsc;
402
 
    }
403
 
 
404
 
    @Override
405
 
    public XQItem createItemFromAtomicValue(String value, XQItemType type) throws XQException {
406
 
        isClosedXQException();
407
 
        isNullXQException(value);
408
 
        isNullXQException(type);
409
 
        if (type.getItemKind()!=XQItemType.XQITEMKIND_ATOMIC) {
410
 
            throw new XQException("ItemType is not Atomic");
411
 
        }
412
 
        XQItem item = null;
413
 
        try {
414
 
            item = this.createItemFromString(value, type);
415
 
        } catch (Exception e) {
416
 
            throw new XQException("Error creating item of this type " + e.getLocalizedMessage());
417
 
        }
418
 
        return item;
419
 
    }
420
 
 
421
 
    @Override
422
 
    public XQItem createItemFromString(String value, XQItemType type) throws XQException {
423
 
        isClosedXQException();
424
 
        isNullXQException(value);
425
 
        if (type==null) {
426
 
            type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_STRING);
427
 
        }
428
 
        ItemFactory itemFactory = zorba.getItemFactory();
429
 
        XQItem item = null;
430
 
        try {
431
 
            switch (type.getBaseType()) {
432
 
            case XQItemType.XQBASETYPE_BOOLEAN:
433
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createBoolean(Boolean.parseBoolean(value)), type);
434
 
                break;
435
 
            case XQItemType.XQBASETYPE_ANYURI:
436
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createAnyURI(value), type);
437
 
                break;
438
 
            case XQItemType.XQBASETYPE_BASE64BINARY:
439
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createBase64Binary(value, value.length()), type);
440
 
                break;
441
 
            case XQItemType.XQBASETYPE_BYTE:
442
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createByte(value.charAt(0)), type);
443
 
                break;
444
 
            case XQItemType.XQBASETYPE_DATE:
445
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDate(value), type);
446
 
                break;
447
 
            case XQItemType.XQBASETYPE_DATETIME:
448
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDateTime(value), type);
449
 
                break;
450
 
            case XQItemType.XQBASETYPE_DAYTIMEDURATION:
451
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDuration(value), type);
452
 
                break;
453
 
            case XQItemType.XQBASETYPE_DECIMAL:
454
 
                BigDecimal dec = new BigDecimal(value);
455
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDecimal(value), type);
456
 
                break;
457
 
            case XQItemType.XQBASETYPE_DOUBLE:
458
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDouble(Double.parseDouble(value)), type);
459
 
                break;
460
 
            case XQItemType.XQBASETYPE_DURATION:
461
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDuration(value), type);
462
 
                break;
463
 
            case XQItemType.XQBASETYPE_FLOAT:
464
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createFloat(value), type);
465
 
                break;
466
 
            case XQItemType.XQBASETYPE_GDAY:
467
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGDay(value), type);
468
 
                break;
469
 
            case XQItemType.XQBASETYPE_GMONTH:
470
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGMonth(value), type);
471
 
                break;
472
 
            case XQItemType.XQBASETYPE_GMONTHDAY:
473
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGMonthDay(value), type);
474
 
                break;
475
 
            case XQItemType.XQBASETYPE_GYEAR:
476
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGYear(value), type);
477
 
                break;
478
 
            case XQItemType.XQBASETYPE_GYEARMONTH:
479
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGYearMonth(value), type);
480
 
                break;
481
 
            case XQItemType.XQBASETYPE_HEXBINARY:
482
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createHexBinary(value, value.length()), type);
483
 
                break;
484
 
            case XQItemType.XQBASETYPE_INT:
485
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createInt(Integer.parseInt(value)), type);
486
 
                break;
487
 
            case XQItemType.XQBASETYPE_INTEGER:
488
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createInteger(Integer.parseInt(value)), type);
489
 
                break;
490
 
            case XQItemType.XQBASETYPE_LONG:
491
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createLong(Long.parseLong(value)), type);
492
 
                break;
493
 
            case XQItemType.XQBASETYPE_NCNAME:
494
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNCName(value), type);
495
 
                break;
496
 
            case XQItemType.XQBASETYPE_NEGATIVE_INTEGER:
497
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNegativeInteger(Long.parseLong(value)), type);
498
 
                break;
499
 
            case XQItemType.XQBASETYPE_NONNEGATIVE_INTEGER:
500
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNonNegativeInteger(new BigInteger(value)), type);
501
 
                break;
502
 
            case XQItemType.XQBASETYPE_NONPOSITIVE_INTEGER:
503
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNonPositiveInteger(Long.parseLong(value)), type);
504
 
                break;
505
 
            case XQItemType.XQBASETYPE_POSITIVE_INTEGER:
506
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createPositiveInteger(new BigInteger(value)), type);
507
 
                break;
508
 
            case XQItemType.XQBASETYPE_QNAME:
509
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createQName(type.getSchemaURI().toString(), value), type);
510
 
                break;
511
 
            case XQItemType.XQBASETYPE_SHORT:
512
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createShort(Short.parseShort(value)), type);
513
 
                break;
514
 
            case XQItemType.XQBASETYPE_STRING:
515
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createString(value), type);
516
 
                break;
517
 
            case XQItemType.XQBASETYPE_TIME:
518
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createTime(value), type);
519
 
                break;
520
 
            case XQItemType.XQBASETYPE_UNSIGNED_BYTE:
521
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedByte(Short.parseShort(value)), type);
522
 
                break;
523
 
            case XQItemType.XQBASETYPE_UNSIGNED_INT:
524
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedInt(Long.parseLong(value)), type);
525
 
                break;
526
 
            case XQItemType.XQBASETYPE_UNSIGNED_LONG:
527
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedLong(new BigInteger(value)), type);
528
 
                break;
529
 
            case XQItemType.XQBASETYPE_UNSIGNED_SHORT:
530
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedShort(Integer.parseInt(value)), type);
531
 
                break;
532
 
            case XQItemType.XQBASETYPE_YEARMONTHDURATION:
533
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDuration(value), type);
534
 
                break;
535
 
            // TODO: revisit this posibilities
536
 
            case XQItemType.XQBASETYPE_ANYATOMICTYPE:
537
 
            case XQItemType.XQBASETYPE_ANYSIMPLETYPE:
538
 
            case XQItemType.XQBASETYPE_ENTITY:
539
 
            case XQItemType.XQBASETYPE_ENTITIES:
540
 
            case XQItemType.XQBASETYPE_ANYTYPE:
541
 
            case XQItemType.XQBASETYPE_LANGUAGE:
542
 
            case XQItemType.XQBASETYPE_ID:
543
 
            case XQItemType.XQBASETYPE_IDREF:
544
 
            case XQItemType.XQBASETYPE_IDREFS:
545
 
            case XQItemType.XQBASETYPE_NAME:
546
 
            case XQItemType.XQBASETYPE_NMTOKEN:
547
 
            case XQItemType.XQBASETYPE_NMTOKENS:
548
 
            case XQItemType.XQBASETYPE_NORMALIZED_STRING:
549
 
            case XQItemType.XQBASETYPE_NOTATION:
550
 
            case XQItemType.XQBASETYPE_TOKEN:
551
 
            case XQItemType.XQBASETYPE_UNTYPED:
552
 
            case XQItemType.XQBASETYPE_UNTYPEDATOMIC:
553
 
                throw new UnsupportedOperationException("Not supported yet.");
554
 
            default:
555
 
                
556
 
                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createString(value), type);
557
 
                break;
558
 
            }
559
 
        } catch (Exception e) {
560
 
            throw new XQException ("Error parsing value" + e.getLocalizedMessage());
561
 
        }
562
 
        return item;
563
 
    }
564
 
 
565
 
    @Override
566
 
    public XQItem createItemFromDocument(String value, String baseURI, XQItemType type) throws XQException {
567
 
        isClosedXQException();
568
 
        isNullXQException(value);
569
 
        if (type!=null) {
570
 
            if ( ! ((type.getItemKind()== XQItemType.XQITEMKIND_DOCUMENT_ELEMENT)||(type.getItemKind()== XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT)) ) {
571
 
                throw new XQException("Invalid type");
572
 
            }
573
 
        } else {
574
 
            type =  this.createElementType(null, XQItemType.XQBASETYPE_UNTYPED);
575
 
        }
576
 
        
577
 
        XmlDataManager dm = null;
578
 
        Item doc = null;
579
 
        XQItem item = null;
580
 
        try {
581
 
            dm = zorba.getXmlDataManager();
582
 
            doc = new Item();
583
 
            org.zorbaxquery.api.Iterator iterator =  dm.parseXML(value);
584
 
            iterator.open();
585
 
            iterator.next(doc);
586
 
            iterator.close();
587
 
            iterator.delete();
588
 
            item = new org.zorbaxquery.api.xqj.XQItem(doc);
589
 
        } catch (Exception e) {
590
 
            throw new XQException("Error creating Item" + e.getLocalizedMessage());
591
 
        }
592
 
        return item;
593
 
    }
594
 
 
595
 
    @Override
596
 
    public XQItem createItemFromDocument(Reader value, String baseURI, XQItemType type) throws XQException {
597
 
        isClosedXQException();
598
 
        isNullXQException(value);
599
 
        
600
 
        StringBuffer string = new StringBuffer();
601
 
        CharBuffer buffer = CharBuffer.allocate(1024);
602
 
        Writer writer = new StringWriter();
603
 
        
604
 
        try {
605
 
            while( value.read(buffer) >= 0 ) {
606
 
                buffer.flip();
607
 
                writer.append(buffer);
608
 
                buffer.clear();
609
 
            }
610
 
            value.close();
611
 
        } catch (Exception ex) {
612
 
            throw new XQException("Error preparing expression" + ex.getLocalizedMessage());
613
 
        }
614
 
        
615
 
        XQItem item = createItemFromDocument(writer.toString(), baseURI, type);
616
 
        return item;
617
 
    }
618
 
 
619
 
    @Override
620
 
    public XQItem createItemFromDocument(InputStream value, String baseURI, XQItemType type) throws XQException {
621
 
        isClosedXQException();
622
 
        isNullXQException(value);
623
 
        // TODO: Rodolfo: optimize this, not good to have a string
624
 
        StringBuffer out = new StringBuffer ();
625
 
        try {
626
 
            byte[] b = new byte[4096];
627
 
            for (int n; (n = value.read(b)) != -1;) {
628
 
                out.append(new String(b, 0, n));
629
 
            }
630
 
        } catch (Exception ex) {
631
 
            throw new XQException("Error preparing expression" + ex.getLocalizedMessage());
632
 
        }
633
 
        XQItem item = createItemFromDocument(out.toString(), baseURI, type);
634
 
        return item;
635
 
    }
636
 
 
637
 
    @Override
638
 
    public XQItem createItemFromDocument(XMLStreamReader value, XQItemType type) throws XQException {
639
 
        isClosedXQException();
640
 
        isNullXQException(value);
641
 
        TransformerFactory tf = TransformerFactory.newInstance();
642
 
        Transformer t;
643
 
        StAXSource source;
644
 
        StAXResult result;
645
 
        XMLOutputFactory xof = XMLOutputFactory.newInstance();
646
 
        Writer writer = new StringWriter();
647
 
        try {
648
 
            XMLStreamWriter xmlStreamWriter =  xof.createXMLStreamWriter(writer);
649
 
            t = tf.newTransformer();
650
 
            source = new StAXSource(value);
651
 
            result = new StAXResult(xmlStreamWriter);
652
 
            t.transform(source, result);        
653
 
        } catch (Exception ex) {
654
 
            throw new XQException("Error transforming xml expression" + ex.getLocalizedMessage());
655
 
        }
656
 
        XQItem item = createItemFromDocument(writer.toString(), "", type);
657
 
        return item;
658
 
    }
659
 
    
660
 
    private String nodeToString(Node node) {
661
 
     StringWriter sw = new StringWriter();
662
 
     try {
663
 
       Transformer t = TransformerFactory.newInstance().newTransformer();
664
 
       t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
665
 
       t.transform(new DOMSource(node), new StreamResult(sw));
666
 
     } catch (TransformerException te) {
667
 
       System.out.println("nodeToString Transformer Exception" + te.getLocalizedMessage());
668
 
     }
669
 
     return sw.toString();
670
 
    }
671
 
    
672
 
    @Override
673
 
    public XQItem createItemFromDocument(Source value, XQItemType type) throws XQException {
674
 
        isClosedXQException();
675
 
        isNullXQException(value);
676
 
        XQItem item = null;
677
 
        if (value instanceof StreamSource) {
678
 
            item = createItemFromDocument(((StreamSource)value).getReader(), "", type);
679
 
        } else if (value instanceof SAXSource) {
680
 
            item = createItemFromDocument(((SAXSource)value).getInputSource().getByteStream(), "", type);
681
 
        } else if (value instanceof DOMSource) {
682
 
            item = createItemFromDocument( nodeToString(((DOMSource)value).getNode()), "", type);
683
 
        } else {
684
 
            throw new UnsupportedOperationException("Not supported yet.");
685
 
        }
686
 
        return item;
687
 
        
688
 
    }
689
 
 
690
 
    @Override
691
 
    public XQItem createItemFromObject(Object value, XQItemType type) throws XQException {
692
 
        isClosedXQException();
693
 
        isNullXQException(value);
694
 
        if (value instanceof XQItem) {
695
 
            return (XQItem)value;
696
 
        }
697
 
        
698
 
        ItemFactory itemFactory = zorba.getItemFactory();
699
 
        XQItem item = null;
700
 
        if (type==null) {
701
 
            
702
 
            if (value instanceof Boolean) {
703
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_BOOLEAN);
704
 
            } else if (value instanceof Byte) {
705
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_BYTE);
706
 
            } else if (value instanceof Float) {
707
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_FLOAT);
708
 
            } else if (value instanceof Double) {
709
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_DOUBLE);
710
 
            } else if (value instanceof Integer) {
711
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_INT);
712
 
            } else if (value instanceof Long) {
713
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_LONG);
714
 
            } else if (value instanceof Short) {
715
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_SHORT);
716
 
            } else if (value instanceof String) {
717
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_STRING);
718
 
            } else if (value instanceof BigDecimal) {
719
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_DECIMAL);
720
 
            } else if (value instanceof BigInteger) {
721
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_INTEGER);
722
 
            } else if (value instanceof Duration) {
723
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_DURATION);
724
 
            } else if (value instanceof XMLGregorianCalendar) {
725
 
                QName schType = ((XMLGregorianCalendar)value).getXMLSchemaType();
726
 
                if (schType.equals(DatatypeConstants.GDAY)) {
727
 
                    type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_GDAY);
728
 
                } else if (schType.equals(DatatypeConstants.GMONTHDAY)) {
729
 
                    type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_GMONTHDAY);
730
 
                } else if (schType.equals(DatatypeConstants.GMONTH)) {
731
 
                    type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_GMONTH);
732
 
                } else if (schType.equals(DatatypeConstants.GYEAR)) {
733
 
                    type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_GYEAR);
734
 
                } else if (schType.equals(DatatypeConstants.GYEARMONTH)) {
735
 
                    type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_GYEARMONTH);
736
 
                } else if (schType.equals(DatatypeConstants.DATETIME)) {
737
 
                    type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_DATETIME);
738
 
                } else if (schType.equals(DatatypeConstants.DATE)) {
739
 
                    type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_DATE);
740
 
                } else if (schType.equals(DatatypeConstants.TIME)) {
741
 
                    type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_TIME);
742
 
                }
743
 
            } else if (value instanceof QName) {
744
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_QNAME);
745
 
            } else if (value instanceof Document) {
746
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_DOCUMENT);
747
 
            } else if (value instanceof DocumentFragment) {
748
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_DOCUMENT);
749
 
            } else if (value instanceof Element){
750
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ELEMENT);
751
 
            } else if (value instanceof Attr) {
752
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATTRIBUTE);
753
 
            } else if (value instanceof Comment) {
754
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_COMMENT);
755
 
            } else if (value instanceof ProcessingInstruction) {
756
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_PI);
757
 
            } else if (value instanceof Text) {
758
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_TEXT);
759
 
            } else {
760
 
                type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC);
761
 
            }
762
 
        }
763
 
        try {
764
 
            switch (type.getItemKind()) {
765
 
                case XQItemType.XQITEMKIND_ATOMIC:
766
 
                    switch (type.getBaseType()) {
767
 
                    case XQItemType.XQBASETYPE_BOOLEAN:
768
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createBoolean((Boolean)value), type);
769
 
                        break;
770
 
                    case XQItemType.XQBASETYPE_ANYURI:
771
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createAnyURI(value.toString()), type);
772
 
                        break;
773
 
                    case XQItemType.XQBASETYPE_BASE64BINARY:
774
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createBase64Binary(value.toString(), (value.toString()).length()), type);
775
 
                        break;
776
 
                    case XQItemType.XQBASETYPE_BYTE:
777
 
                        if (value instanceof Byte) {
778
 
                            byte tmpByte = ((Byte)value).byteValue();
779
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createByte((char)tmpByte), type);
780
 
                        } else {
781
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createByte((value.toString()).charAt(0)), type);
782
 
                        }
783
 
                        break;
784
 
                    case XQItemType.XQBASETYPE_DATE:
785
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDate(value.toString()), type);
786
 
                        break;
787
 
                    case XQItemType.XQBASETYPE_DATETIME:
788
 
                        if (value.toString().contains(":")) {
789
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDateTime(value.toString()), type);
790
 
                        } else {
791
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDate(value.toString()), type);
792
 
                        }
793
 
                        break;
794
 
                    case XQItemType.XQBASETYPE_DAYTIMEDURATION:
795
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDuration(value.toString()), type);
796
 
                        break;
797
 
                    case XQItemType.XQBASETYPE_DECIMAL:
798
 
                        if (value instanceof BigDecimal) {
799
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDecimal(((BigDecimal)value).toPlainString()), type);
800
 
                        } else {
801
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDecimal(value.toString()), type);
802
 
                        }
803
 
                        break;
804
 
                    case XQItemType.XQBASETYPE_DOUBLE:
805
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDouble(value.toString()), type);
806
 
                        break;
807
 
                    case XQItemType.XQBASETYPE_DURATION:
808
 
                        if (value instanceof Duration) {
809
 
                            Duration duration = (Duration)value;
810
 
                            Boolean daytime = duration.isSet(DatatypeConstants.DAYS) || duration.isSet(DatatypeConstants.HOURS) || 
811
 
                                              duration.isSet(DatatypeConstants.MINUTES) || duration.isSet(DatatypeConstants.SECONDS);
812
 
                            Boolean yearmonth = duration.isSet(DatatypeConstants.YEARS) || duration.isSet(DatatypeConstants.MONTHS);
813
 
                            if (daytime && yearmonth){
814
 
                                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDuration(value.toString()), type);
815
 
                            } else if (yearmonth) {
816
 
                                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createYearMonthDuration(value.toString()), type);
817
 
                            } else if (daytime) {
818
 
                                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDayTimeDuration(value.toString()), type);
819
 
                            }
820
 
                        } else {
821
 
                            boolean yearMonth = value.toString().contains("Y") || value.toString().contains("M");
822
 
                            boolean dayTime = value.toString().contains("D") || value.toString().contains("T");
823
 
                            if (yearMonth && dayTime) {
824
 
                                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDuration(value.toString()), type);
825
 
                            } else if (yearMonth) {
826
 
                                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createYearMonthDuration(value.toString()), type);
827
 
                            } else if (dayTime) {
828
 
                                item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDayTimeDuration(value.toString()), type);
829
 
                            }
830
 
                        }
831
 
                        break;
832
 
                    case XQItemType.XQBASETYPE_FLOAT:
833
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createFloat((Float)value), type);
834
 
                        break;
835
 
                    case XQItemType.XQBASETYPE_GDAY:
836
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGDay(value.toString()), type);
837
 
                        break;
838
 
                    case XQItemType.XQBASETYPE_GMONTH:
839
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGMonth(value.toString()), type);
840
 
                        break;
841
 
                    case XQItemType.XQBASETYPE_GMONTHDAY:
842
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGMonthDay(value.toString()), type);
843
 
                        break;
844
 
                    case XQItemType.XQBASETYPE_GYEAR:
845
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGYear(value.toString()), type);
846
 
                        break;
847
 
                    case XQItemType.XQBASETYPE_GYEARMONTH:
848
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createGYearMonth(value.toString()), type);
849
 
                        break;
850
 
                    case XQItemType.XQBASETYPE_HEXBINARY:
851
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createHexBinary(value.toString(), (value.toString()).length()), type);
852
 
                        break;
853
 
                    case XQItemType.XQBASETYPE_INT:
854
 
                    case XQItemType.XQBASETYPE_INTEGER:
855
 
                        if (value instanceof BigInteger) {
856
 
                            BigInteger val = (BigInteger)value;
857
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createInteger(val.longValue()), type);
858
 
                        } else if (value instanceof Integer) {
859
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createInt((Integer)value), type);
860
 
                        } else if (value instanceof String) {
861
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createInteger(value.toString()), type);
862
 
                        } else {
863
 
                            throw new XQException ("Error parsing integer: " + value.toString());
864
 
                        }
865
 
                        break;
866
 
                    case XQItemType.XQBASETYPE_LONG:
867
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createLong((Long)value), type);
868
 
                        break;
869
 
                    case XQItemType.XQBASETYPE_NCNAME:
870
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNCName(value.toString()), type);
871
 
                        break;
872
 
                    case XQItemType.XQBASETYPE_NEGATIVE_INTEGER:
873
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNegativeInteger((Long)value), type);
874
 
                        break;
875
 
                    case XQItemType.XQBASETYPE_NONNEGATIVE_INTEGER:
876
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNonNegativeInteger(new BigInteger(value.toString())), type);
877
 
                        break;
878
 
                    case XQItemType.XQBASETYPE_NONPOSITIVE_INTEGER:
879
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNonPositiveInteger((Long)value), type);
880
 
                        break;
881
 
                    case XQItemType.XQBASETYPE_POSITIVE_INTEGER:
882
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createPositiveInteger(new BigInteger(value.toString())), type);
883
 
                        break;
884
 
                    case XQItemType.XQBASETYPE_QNAME:
885
 
                        if (value instanceof QName) {
886
 
                            QName qname =  (QName) value;
887
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createQName(qname.getNamespaceURI(), qname.getPrefix(), qname.getLocalPart()), type);
888
 
                        } else if (value.toString().contains("{")) {
889
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createQName(value.toString()), type);
890
 
                        } else {
891
 
                            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createQName("", value.toString()), type);
892
 
                        }
893
 
                        break;
894
 
                    case XQItemType.XQBASETYPE_SHORT:
895
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createShort((Short)value), type);
896
 
                        break;
897
 
                    case XQItemType.XQBASETYPE_STRING:
898
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createString(value.toString()), type);
899
 
                        break;
900
 
                    case XQItemType.XQBASETYPE_TIME:
901
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createTime(value.toString()), type);
902
 
                        break;
903
 
                    case XQItemType.XQBASETYPE_TOKEN:
904
 
                        break;
905
 
                    case XQItemType.XQBASETYPE_UNSIGNED_BYTE:
906
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedByte((Short)value), type);
907
 
                        break;
908
 
                    case XQItemType.XQBASETYPE_UNSIGNED_INT:
909
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedInt((Long)value), type);
910
 
                        break;
911
 
                    case XQItemType.XQBASETYPE_UNSIGNED_LONG:
912
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedLong(new BigInteger(value.toString())), type);
913
 
                        break;
914
 
                    case XQItemType.XQBASETYPE_UNSIGNED_SHORT:
915
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedShort((Integer)value), type);
916
 
                        break;
917
 
                    case XQItemType.XQBASETYPE_YEARMONTHDURATION:
918
 
                        item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDuration(value.toString()), type);
919
 
                        break;
920
 
                    case XQItemType.XQBASETYPE_ANYATOMICTYPE:
921
 
                    case XQItemType.XQBASETYPE_ANYSIMPLETYPE:
922
 
                    case XQItemType.XQBASETYPE_ANYTYPE:
923
 
                    case XQItemType.XQBASETYPE_ENTITIES:
924
 
                    case XQItemType.XQBASETYPE_ENTITY:
925
 
                    case XQItemType.XQBASETYPE_ID:
926
 
                    case XQItemType.XQBASETYPE_IDREF:
927
 
                    case XQItemType.XQBASETYPE_IDREFS:
928
 
                    case XQItemType.XQBASETYPE_LANGUAGE:
929
 
                    case XQItemType.XQBASETYPE_NAME:
930
 
                    case XQItemType.XQBASETYPE_NMTOKEN:
931
 
                    case XQItemType.XQBASETYPE_NMTOKENS:
932
 
                    case XQItemType.XQBASETYPE_NORMALIZED_STRING:
933
 
                    case XQItemType.XQBASETYPE_NOTATION:
934
 
                    case XQItemType.XQBASETYPE_UNTYPED:
935
 
                    case XQItemType.XQBASETYPE_UNTYPEDATOMIC:
936
 
                        throw new XQException ("Base type not supported yet.");
937
 
                    default:
938
 
                        throw new XQException ("Unable to determine XQBASETYPE.");
939
 
                    }
940
 
                    break;
941
 
                case XQItemType.XQITEMKIND_ATTRIBUTE:
942
 
                    if (value instanceof Attr){
943
 
                        Attr attribute = (Attr) value;
944
 
                        Item iEmpty = new Item();
945
 
                        Item nodeName = itemFactory.createQName(attribute.getNamespaceURI()==null?"":attribute.getNamespaceURI(), 
946
 
                                                                attribute.getPrefix()==null?"":attribute.getPrefix(), 
947
 
                                                                attribute.getName()==null?"":attribute.getName());
948
 
                        Item nodeValue = null;
949
 
                        if (!attribute.getValue().isEmpty()) {
950
 
                            nodeValue = itemFactory.createQName(attribute.getNamespaceURI()==null?"":attribute.getNamespaceURI(), 
951
 
                                                                attribute.getPrefix()==null?"":attribute.getPrefix(), 
952
 
                                                                attribute.getValue()==null?"":attribute.getValue());
953
 
                        } else {
954
 
                            nodeValue = new Item();
955
 
                        }
956
 
                        //TODO: Rodolfo: use centralized constants instead of strings
957
 
                        Item iUntyped = itemFactory.createQName("http://www.w3.org/2001/XMLSchema", "xs", "untyped");
958
 
                        Item attributeNode = itemFactory.createAttributeNode(iEmpty, nodeName, iUntyped, nodeValue);
959
 
                        item = new org.zorbaxquery.api.xqj.XQItem(attributeNode, type);
960
 
                    }
961
 
                    break;
962
 
                case XQItemType.XQITEMKIND_COMMENT:
963
 
                    if (value instanceof Comment){
964
 
                        Comment comment = (Comment) value;
965
 
                        Item iEmpty = new Item();
966
 
                        Item elementNode = itemFactory.createCommentNode(iEmpty, comment.getTextContent());
967
 
                        item = new org.zorbaxquery.api.xqj.XQItem(elementNode, type);
968
 
                    } else {
969
 
                        Item iEmpty = new Item();
970
 
                        Item elementNode = itemFactory.createCommentNode(iEmpty, value.toString());
971
 
                        item = new org.zorbaxquery.api.xqj.XQItem(elementNode, type);
972
 
                    }
973
 
                    break;
974
 
                case XQItemType.XQITEMKIND_DOCUMENT:
975
 
                    if ((value instanceof Document) || (value instanceof DocumentFragment)){
976
 
                        DOMSource source = null;
977
 
                        if (value instanceof Document) {
978
 
                            source = new DOMSource((Document)value);
979
 
                        } else {
980
 
                            source = new DOMSource((DocumentFragment)value);
981
 
                        }
982
 
 
983
 
                        Transformer transformer = TransformerFactory.newInstance().newTransformer();
984
 
                        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
985
 
                        StreamResult result = new StreamResult(new StringWriter());
986
 
                        
987
 
                        transformer.transform(source, result);
988
 
                        String xmlString = result.getWriter().toString();
989
 
                        Item tmpItem = new Item();
990
 
                        if (xmlString.length()>0) {
991
 
                            XmlDataManager dataManager = zorba.getXmlDataManager();
992
 
                            org.zorbaxquery.api.Iterator iter = dataManager.parseXML(xmlString);
993
 
                            iter.open();
994
 
                            iter.next(tmpItem);
995
 
                            iter.close();
996
 
                            iter.delete();
997
 
                        } else {
998
 
                            tmpItem = itemFactory.createDocumentNode("", "");
999
 
                        }
1000
 
                        
1001
 
                        item = new org.zorbaxquery.api.xqj.XQItem(tmpItem, type);
1002
 
                    }
1003
 
                      
1004
 
                    break;
1005
 
                case XQItemType.XQITEMKIND_ELEMENT:
1006
 
                    if (value instanceof Element){
1007
 
                        Element element = (Element) value;
1008
 
                        Item iEmpty = new Item();
1009
 
                        Item nodeName = itemFactory.createQName(element.getNamespaceURI()==null?"":element.getNamespaceURI(), 
1010
 
                                                                element.getPrefix()==null?"":element.getPrefix(), 
1011
 
                                                                element.getNodeName()==null?"":element.getNodeName());
1012
 
                        Item iUntyped = itemFactory.createQName("http://www.w3.org/2001/XMLSchema", "xs", "untyped");
1013
 
                        Item elementNode = itemFactory.createElementNode(iEmpty, nodeName, iUntyped, false, false);
1014
 
                        item = new org.zorbaxquery.api.xqj.XQItem(elementNode, type);
1015
 
                    }
1016
 
                    break;
1017
 
                case XQItemType.XQITEMKIND_PI:
1018
 
                    if (value instanceof ProcessingInstruction){
1019
 
                        ProcessingInstruction pi = (ProcessingInstruction) value;
1020
 
                        Item iEmpty = new Item();
1021
 
                        Item elementNode = itemFactory.createPiNode(iEmpty, 
1022
 
                                pi.getTarget(), 
1023
 
                                pi.getTextContent(), 
1024
 
                                pi.getBaseURI()==null?"":pi.getBaseURI());
1025
 
                        item = new org.zorbaxquery.api.xqj.XQItem(elementNode, type);
1026
 
                    }
1027
 
                    break;
1028
 
                case XQItemType.XQITEMKIND_TEXT:
1029
 
                    if (value instanceof Text){
1030
 
                        Text text = (Text) value;
1031
 
                        Item iEmpty = new Item();
1032
 
                        Item elementNode = itemFactory.createTextNode(iEmpty, text.getWholeText());
1033
 
                        item = new org.zorbaxquery.api.xqj.XQItem(elementNode, type);
1034
 
                    }
1035
 
                    break;
1036
 
                case XQItemType.XQITEMKIND_DOCUMENT_ELEMENT:
1037
 
                case XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT:
1038
 
                case XQItemType.XQITEMKIND_ITEM:
1039
 
                case XQItemType.XQITEMKIND_NODE:
1040
 
                case XQItemType.XQITEMKIND_SCHEMA_ATTRIBUTE:
1041
 
                case XQItemType.XQITEMKIND_SCHEMA_ELEMENT:
1042
 
                    throw new XQException ("This item kind is currently unsupported.");
1043
 
                default:
1044
 
                    throw new XQException ("Unable to determine XQITEMKIND.");
1045
 
            }
1046
 
        } catch (Exception e) {
1047
 
            throw new XQException ("Error parsing value" + e.getLocalizedMessage());
1048
 
        }
1049
 
        return item;
1050
 
    }
1051
 
 
1052
 
    @Override
1053
 
    public XQItem createItemFromBoolean(boolean bln, XQItemType type) throws XQException {
1054
 
        isClosedXQException();
1055
 
        if (type == null) {
1056
 
            type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_BOOLEAN);
1057
 
        }
1058
 
        if (type.getBaseType() != XQItemType.XQBASETYPE_BOOLEAN) {
1059
 
            throw new XQException("Type is not boolean, use proper method");
1060
 
        }
1061
 
        
1062
 
        XQItem item = null;
1063
 
        try {
1064
 
            ItemFactory itemFactory = zorba.getItemFactory();
1065
 
            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createBoolean(bln));
1066
 
        } catch (Exception e) {
1067
 
            throw new XQException("Error creating new item");
1068
 
        }
1069
 
        return item;
1070
 
    }
1071
 
 
1072
 
    // This method works for Decimal and all subtypes,
1073
 
    // verifies that the type is correct and create the Item
1074
 
    private XQItem createDecimal(BigDecimal value, XQItemType type) throws XQException {
1075
 
        XQItem item = null;
1076
 
        try {
1077
 
            ItemFactory itemFactory = zorba.getItemFactory();
1078
 
            switch (type.getBaseType()) {
1079
 
                case XQItemType.XQBASETYPE_BYTE:
1080
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createByte((char)value.byteValue()), type);
1081
 
                    break;
1082
 
                case XQItemType.XQBASETYPE_INTEGER:
1083
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createInteger(value.longValue()), type);
1084
 
                    break;
1085
 
                case XQItemType.XQBASETYPE_DECIMAL:
1086
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDecimalFromLong(value.longValue()), type);
1087
 
                    break;
1088
 
                case XQItemType.XQBASETYPE_INT:
1089
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createInt(value.intValue()), type);
1090
 
                    break;
1091
 
                case XQItemType.XQBASETYPE_LONG:
1092
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createLong(value.longValue()), type);
1093
 
                    break;
1094
 
                case XQItemType.XQBASETYPE_NEGATIVE_INTEGER:
1095
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNegativeInteger(value.longValue()), type);
1096
 
                    break;
1097
 
                case XQItemType.XQBASETYPE_NONNEGATIVE_INTEGER:
1098
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNonNegativeInteger(value.toBigInteger()), type);
1099
 
                    break;
1100
 
                case XQItemType.XQBASETYPE_NONPOSITIVE_INTEGER:
1101
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createNonPositiveInteger(value.longValue()), type);
1102
 
                    break;
1103
 
                case XQItemType.XQBASETYPE_POSITIVE_INTEGER:
1104
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createPositiveInteger(value.toBigInteger()), type);
1105
 
                    break;
1106
 
                case XQItemType.XQBASETYPE_SHORT:
1107
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createShort(value.shortValue()), type);
1108
 
                    break;
1109
 
                case XQItemType.XQBASETYPE_UNSIGNED_BYTE:
1110
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedByte(value.shortValue()), type);
1111
 
                    break;
1112
 
                case XQItemType.XQBASETYPE_UNSIGNED_INT:
1113
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedInt(value.longValue()), type);
1114
 
                    break;
1115
 
                case XQItemType.XQBASETYPE_UNSIGNED_LONG:
1116
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createUnsignedLong(value.toBigInteger()), type);
1117
 
                    break;
1118
 
                case XQItemType.XQBASETYPE_UNSIGNED_SHORT:
1119
 
                    item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createShort(value.shortValue()), type);
1120
 
                    break;
1121
 
                default:
1122
 
                    throw new XQException("Type is not xs:decimal or a derivate.");
1123
 
            }
1124
 
        } catch (Exception e) {
1125
 
            throw new XQException("Error creating Item: " + e.getLocalizedMessage());
1126
 
        }
1127
 
        return item;
1128
 
    }
1129
 
    
1130
 
    @Override
1131
 
    public XQItem createItemFromByte(byte b, XQItemType type) throws XQException {
1132
 
        isClosedXQException();
1133
 
        if (type == null) {
1134
 
            type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_BYTE);
1135
 
        }
1136
 
        return createDecimal(new BigDecimal(b), type);
1137
 
    }
1138
 
 
1139
 
    @Override
1140
 
    public XQItem createItemFromDouble(double value, XQItemType type) throws XQException {
1141
 
        isClosedXQException();
1142
 
        if (type == null) {
1143
 
            type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_DOUBLE);
1144
 
        }
1145
 
        if (type.getBaseType() != XQItemType.XQBASETYPE_DOUBLE) {
1146
 
            throw new XQException("Type is not double, use proper method");
1147
 
        }
1148
 
        XQItem item = null;
1149
 
        try {
1150
 
            ItemFactory itemFactory = zorba.getItemFactory();
1151
 
            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createDouble(value), type);
1152
 
        } catch (Exception e) {
1153
 
            throw new XQException("Error Creating Item From Double" + e.getLocalizedMessage());
1154
 
        }
1155
 
        return item;
1156
 
    }
1157
 
 
1158
 
    @Override
1159
 
    public XQItem createItemFromFloat(float value, XQItemType type) throws XQException {
1160
 
        isClosedXQException();
1161
 
        if (type == null) {
1162
 
            type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_FLOAT);
1163
 
        }
1164
 
        if (type.getBaseType() != XQItemType.XQBASETYPE_FLOAT) {
1165
 
            throw new XQException("Type is not float, use proper method");
1166
 
        }
1167
 
        XQItem item = null;
1168
 
        try {
1169
 
            ItemFactory itemFactory = zorba.getItemFactory();
1170
 
            item = new org.zorbaxquery.api.xqj.XQItem(itemFactory.createFloat(value), type);
1171
 
        } catch (Exception e) {
1172
 
            throw new XQException("Error Creating Item From Float" + e.getLocalizedMessage());
1173
 
        }
1174
 
        return item;
1175
 
    }
1176
 
 
1177
 
    @Override
1178
 
    public XQItem createItemFromInt(int value, XQItemType type) throws XQException {
1179
 
        isClosedXQException();
1180
 
        if (type == null) {
1181
 
            type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_INT);
1182
 
        }
1183
 
        switch (type.getBaseType()) {
1184
 
            case XQItemType.XQBASETYPE_BYTE:
1185
 
            case XQItemType.XQBASETYPE_SHORT:
1186
 
                throw new XQException("Can't downgrade the Base Type from an Int number");
1187
 
            default:
1188
 
                break;
1189
 
        }
1190
 
        return createDecimal(new BigDecimal(value), type);
1191
 
    }
1192
 
 
1193
 
    @Override
1194
 
    public XQItem createItemFromLong(long value, XQItemType type) throws XQException {
1195
 
        isClosedXQException();
1196
 
        if (type == null) {
1197
 
            type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_LONG);
1198
 
        }
1199
 
        switch (type.getBaseType()) {
1200
 
            case XQItemType.XQBASETYPE_BYTE:
1201
 
            case XQItemType.XQBASETYPE_SHORT:
1202
 
            case XQItemType.XQBASETYPE_INT:
1203
 
                throw new XQException("Can't downgrade the Base Type from an Long number");
1204
 
            default:
1205
 
                break;
1206
 
        }
1207
 
        return createDecimal(new BigDecimal(value), type);
1208
 
    }
1209
 
 
1210
 
    @Override
1211
 
    public XQItem createItemFromNode(Node value, XQItemType type) throws XQException {
1212
 
        isClosedXQException();
1213
 
        isNullXQException(value);
1214
 
        
1215
 
        XQItem result = null;
1216
 
        try {
1217
 
            result = createItemFromString(nodeToString(value), type);
1218
 
        } catch( Exception e ) {
1219
 
            throw new XQException("Error Creating Item From Node" + e.getLocalizedMessage());
1220
 
        }
1221
 
        return result;
1222
 
    }
1223
 
 
1224
 
    @Override
1225
 
    public XQItem createItemFromShort(short value, XQItemType type) throws XQException {
1226
 
        isClosedXQException();
1227
 
        if (type == null) {
1228
 
            type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, XQItemType.XQBASETYPE_SHORT);
1229
 
        }
1230
 
        if (type.getBaseType()==XQItemType.XQBASETYPE_BYTE) {
1231
 
            throw new XQException("Can't create a Byte from a Short number");
1232
 
        }
1233
 
        return createDecimal(new BigDecimal(value), type);
1234
 
    }
1235
 
 
1236
 
    @Override
1237
 
    public XQItem createItem(XQItem value) throws XQException {
1238
 
        isClosedXQException();
1239
 
        isNullXQException(value);
1240
 
        if (value.isClosed()) {
1241
 
            throw new XQException("Item is closed.");
1242
 
        }
1243
 
        XQItem result = new org.zorbaxquery.api.xqj.XQItem(value);
1244
 
        return result;
1245
 
    }
1246
 
 
1247
 
    @Override
1248
 
    public XQSequence createSequence(XQSequence value) throws XQException {
1249
 
        isClosedXQException();
1250
 
        isNullXQException(value);
1251
 
        if (value.isClosed()) {
1252
 
            throw new XQException("Sequence is closed.");
1253
 
        }
1254
 
        XQSequence result = null;
1255
 
        try {
1256
 
            result = new org.zorbaxquery.api.xqj.XQSequence(value);
1257
 
        } catch (Exception ex) {
1258
 
            throw new XQException("Error creating sequence: " + ex.getLocalizedMessage());
1259
 
        }
1260
 
        return result;
1261
 
    }
1262
 
 
1263
 
    @Override
1264
 
    public XQSequence createSequence(Iterator value) throws XQException {
1265
 
        isClosedXQException();
1266
 
        isNullXQException(value);
1267
 
        XQSequence result = null;
1268
 
        try {
1269
 
            result = new org.zorbaxquery.api.xqj.XQSequence(value);
1270
 
        } catch (Exception ex) {
1271
 
            throw new XQException("Error creating sequence: " + ex.getLocalizedMessage());
1272
 
        }
1273
 
        return result;
1274
 
    }
1275
 
 
1276
 
    @Override
1277
 
    public XQItemType createAtomicType(int basetype) throws XQException {
1278
 
        isClosedXQException();
1279
 
        if ((basetype==XQItemType.XQBASETYPE_UNTYPED) || 
1280
 
            (basetype==XQItemType.XQBASETYPE_ANYTYPE) || 
1281
 
            (basetype==XQItemType.XQBASETYPE_IDREFS) || 
1282
 
            (basetype==XQItemType.XQBASETYPE_NMTOKENS) || 
1283
 
            (basetype==XQItemType.XQBASETYPE_ENTITIES) || 
1284
 
            (basetype==XQItemType.XQBASETYPE_ANYSIMPLETYPE)) {
1285
 
            throw new XQException("Invalid base type.");
1286
 
        }
1287
 
        XQItemType type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, basetype);
1288
 
        return type;
1289
 
    }
1290
 
 
1291
 
    @Override
1292
 
    public XQItemType createAtomicType(int basetype, QName qname, URI uri) throws XQException {
1293
 
        if (closed) {
1294
 
            throw new XQException("Object closed");
1295
 
        }
1296
 
        if ((basetype==XQItemType.XQBASETYPE_UNTYPED) || 
1297
 
            (basetype==XQItemType.XQBASETYPE_ANYTYPE) || 
1298
 
            (basetype==XQItemType.XQBASETYPE_IDREFS) || 
1299
 
            (basetype==XQItemType.XQBASETYPE_NMTOKENS) || 
1300
 
            (basetype==XQItemType.XQBASETYPE_ENTITIES) || 
1301
 
            (basetype==XQItemType.XQBASETYPE_ANYSIMPLETYPE)) {
1302
 
            throw new XQException("Invalid base type.");
1303
 
        }
1304
 
        XQItemType type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATOMIC, qname, basetype, uri);
1305
 
        return type;
1306
 
    }
1307
 
 
1308
 
    @Override
1309
 
    public XQItemType createAttributeType(QName nodename, int basetype) throws XQException {
1310
 
        isClosedXQException();
1311
 
        if ((basetype==XQItemType.XQBASETYPE_UNTYPED)||(basetype==XQItemType.XQBASETYPE_ANYTYPE)) {
1312
 
            throw new XQException("Base Type can't be XQItemType.XQBASETYPE_UNTYPED or XQItemType.XQBASETYPE_ANYTYPE");
1313
 
        }
1314
 
        return new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATTRIBUTE, nodename, basetype);
1315
 
    }
1316
 
 
1317
 
    @Override
1318
 
    public XQItemType createAttributeType(QName nodename, int basetype, QName typename, URI schemaURI) throws XQException {
1319
 
        isClosedXQException();
1320
 
        if ((basetype==XQItemType.XQBASETYPE_UNTYPED)||(basetype==XQItemType.XQBASETYPE_ANYTYPE)) {
1321
 
            throw new XQException("Base Type can't be XQItemType.XQBASETYPE_UNTYPED or XQItemType.XQBASETYPE_ANYTYPE");
1322
 
        }
1323
 
        if ((schemaURI!=null) && (typename==null)) {
1324
 
            throw new XQException("If Schema URI is specified, Base Type must be also specified");
1325
 
        }
1326
 
        return new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ATTRIBUTE, nodename, basetype, typename, schemaURI, true);
1327
 
    }
1328
 
 
1329
 
    @Override
1330
 
    public XQItemType createSchemaAttributeType(QName nodename, int basetype, URI uri) throws XQException {
1331
 
        isClosedXQException();
1332
 
        return new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_SCHEMA_ATTRIBUTE, nodename, basetype, uri);
1333
 
    }
1334
 
 
1335
 
    @Override
1336
 
    public XQItemType createCommentType() throws XQException {
1337
 
        isClosedXQException();
1338
 
        return new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_COMMENT);
1339
 
    }
1340
 
 
1341
 
    @Override
1342
 
    public XQItemType createDocumentElementType(XQItemType elementType) throws XQException {
1343
 
        isClosedXQException();
1344
 
        isNullXQException(elementType);
1345
 
        if (elementType.getItemKind()!=XQItemType.XQITEMKIND_ELEMENT) {
1346
 
            throw new XQException("Item Kind must be XQItemType.XQITEMKIND_ELEMENT");
1347
 
        }
1348
 
        return new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_DOCUMENT_ELEMENT, elementType.getNodeName(), elementType.getBaseType(), elementType.getSchemaURI());
1349
 
    }
1350
 
 
1351
 
    @Override
1352
 
    public XQItemType createDocumentSchemaElementType(XQItemType elementType) throws XQException {
1353
 
        isClosedXQException();
1354
 
        if (elementType.getItemKind()!=XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT) {
1355
 
            throw new XQException("Item Kind must be XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT");
1356
 
        }
1357
 
        return new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_DOCUMENT_ELEMENT, elementType.getNodeName(), elementType.getBaseType(), elementType.getSchemaURI());
1358
 
    }
1359
 
 
1360
 
    @Override
1361
 
    public XQItemType createDocumentType() throws XQException {
1362
 
        isClosedXQException();
1363
 
        return new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_DOCUMENT);
1364
 
    }
1365
 
 
1366
 
    @Override
1367
 
    public XQItemType createElementType(QName nodename, int baseType) throws XQException {
1368
 
        isClosedXQException();
1369
 
        XQItemType item = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ELEMENT, nodename, baseType);
1370
 
        return item;
1371
 
    }
1372
 
 
1373
 
    @Override
1374
 
    public XQItemType createElementType(QName nodename, int baseType, QName typename, URI schemaURI, boolean allowNill) throws XQException {
1375
 
        isClosedXQException();
1376
 
        XQItemType item = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ELEMENT, nodename, baseType, typename, schemaURI, allowNill);
1377
 
        return item;
1378
 
    }
1379
 
 
1380
 
    @Override
1381
 
    public XQItemType createSchemaElementType(QName nodename, int baseType, URI schemaURI) throws XQException {
1382
 
        isClosedXQException();
1383
 
        XQItemType item = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_SCHEMA_ELEMENT, nodename, baseType, schemaURI);
1384
 
        return item;
1385
 
    }
1386
 
 
1387
 
    @Override
1388
 
    public XQItemType createItemType() throws XQException {
1389
 
        isClosedXQException();
1390
 
        XQItemType type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_ITEM);
1391
 
        return type;
1392
 
    }
1393
 
 
1394
 
    @Override
1395
 
    public XQItemType createNodeType() throws XQException {
1396
 
        isClosedXQException();
1397
 
        XQItemType type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_NODE);
1398
 
        return type;
1399
 
    }
1400
 
 
1401
 
    @Override
1402
 
    public XQItemType createProcessingInstructionType(String piTarget) throws XQException {
1403
 
        isClosedXQException();
1404
 
        XQItemType type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_PI, piTarget);
1405
 
        return type;
1406
 
    }
1407
 
 
1408
 
    @Override
1409
 
    public XQSequenceType createSequenceType(XQItemType item, int occurence) throws XQException {
1410
 
        isClosedXQException();
1411
 
        if ( ((item==null) && (occurence != XQSequenceType.OCC_EMPTY)) || ((item!=null) && (occurence == XQSequenceType.OCC_EMPTY))) {
1412
 
            throw new XQException("Item is null");
1413
 
        }
1414
 
        if (!((occurence ==  XQSequenceType.OCC_ZERO_OR_ONE) ||
1415
 
            (occurence == XQSequenceType.OCC_EXACTLY_ONE) ||
1416
 
            (occurence == XQSequenceType.OCC_ZERO_OR_MORE) ||
1417
 
            (occurence == XQSequenceType.OCC_ONE_OR_MORE) ||
1418
 
            (occurence == XQSequenceType.OCC_EMPTY))) {
1419
 
            throw new XQException("Occurence must be from: OCC_ZERO_OR_ONE, OCC_EXACTLY_ONE, OCC_ZERO_OR_MORE, OCC_ONE_OR_MORE, OCC_EMPTY ");
1420
 
        }
1421
 
        
1422
 
        XQSequenceType result = new org.zorbaxquery.api.xqj.XQSequenceType(item, occurence);
1423
 
        return result;
1424
 
    }
1425
 
 
1426
 
    @Override
1427
 
    public XQItemType createTextType() throws XQException {
1428
 
        isClosedXQException();
1429
 
        XQItemType type = new org.zorbaxquery.api.xqj.XQItemType(XQItemType.XQITEMKIND_TEXT);
1430
 
        return type;
1431
 
    }
1432
 
    
1433
 
    private void isClosedXQException() throws XQException {
1434
 
        if (closed) {
1435
 
            throw new XQException("This connection is closed");
1436
 
        }
1437
 
    }
1438
 
    private void isNullXQException(Object value) throws XQException {
1439
 
        if (value==null) {
1440
 
            throw new XQException("Parameter shouldn't be null");
1441
 
        }
1442
 
    }
1443
 
   
1444
 
}