View Javadoc

1   /**
2    * JSpiff
3    * -----------------
4    * Copyright (c) 2005-2006 Emil A. Lefkof III
5    *
6    * I always give it my best shot to make a program useful and solid, but
7    * remeber that there is absolutely no warranty for using this program as
8    * stated in the following terms:
9    *
10   * Licensed under the Apache License, Version 2.0 (the "License");
11   * you may not use this file except in compliance with the License.
12   * You may obtain a copy of the License at
13   *
14   *     http://www.apache.org/licenses/LICENSE-2.0
15   *
16   * Unless required by applicable law or agreed to in writing, software
17   * distributed under the License is distributed on an "AS IS" BASIS,
18   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19   * See the License for the specific language governing permissions and
20   * limitations under the License.
21   */
22  package com.melloware.jspiff.jaxp;
23  
24  import java.io.ByteArrayOutputStream;
25  import java.io.File;
26  import java.io.IOException;
27  import java.io.PrintWriter;
28  import java.io.Writer;
29  import java.math.BigDecimal;
30  import java.math.BigInteger;
31  import java.net.MalformedURLException;
32  import java.net.URL;
33  import java.text.DateFormat;
34  import java.text.ParseException;
35  import java.util.ArrayList;
36  import java.util.Collection;
37  import java.util.Date;
38  import java.util.List;
39  import java.util.Locale;
40  import java.util.Stack;
41  import java.util.StringTokenizer;
42  
43  import org.w3c.dom.Attr;
44  import org.w3c.dom.Document;
45  import org.w3c.dom.Element;
46  import org.w3c.dom.EntityReference;
47  import org.w3c.dom.NamedNodeMap;
48  import org.w3c.dom.Node;
49  import org.w3c.dom.NodeList;
50  import org.w3c.dom.Text;
51  
52  /**
53   * URelaxer
54   *
55   * @since   Jan. 19, 2000
56   * @version Dec. 15, 2004
57   * @author  ASAMI, Tomoharu (asami@relaxer.org)
58   * @author Emil A. Lefkof III <info@melloware.com>
59   */
60  public final class URelaxer {
61  
62      private static char[] map__ = {
63          'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
64          'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
65          's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
66      };
67  
68      // Auto
69  
70      private static Object autoIDHandler__ = null;
71      private static String autoIDPrefix__ = null;
72      private static Boolean autoIDThreadSingle__ = null;
73      private static Boolean autoIDThreadGroupSingle__ = null;
74  
75      /*
76       *  public static class RelativeStreamHandler     extends java.net.URLStreamHandler {
77       *
78       *   protected URLConnection openConnection(URL u) throws IOException {         throw (new
79       * IOException("UnsupportedOperation"));     }
80       *
81       *   protected void parseURL(URL u, String spec, int start, int limit) {         String protocol;         String
82       * file;         String ref;         int afterProtocol = spec.indexOf(":");         protocol = spec.substring(0,
83       * afterProtocol);         int afterFile = spec.indexOf("#");         if (afterFile == -1) {             file =
84       * spec.substring(afterProtocol + 1);             ref = null;         } else {             file =
85       * spec.substring(afterProtocol + 1, afterFile);             ref = spec.substring(afterFile + 1);         }
86       * setURL(u, protocol, null, -1, file, ref);     }
87       *
88       *   protected String toExternalForm(URL u) {         return (u.getFile());     } }
89       */
90      //
91      static boolean isRigid__ = true;
92      static boolean isBadNumber__ = true;
93  
94      public static String getAttribute(Element element, String name) {
95          Attr attr = element.getAttributeNode(name);
96          if (attr == null) {
97              return (null);
98          }
99          return (attr.getValue());
100     }
101 
102     public static String getAttributeHungry(RStack stack, String name) {
103         Attr attr = stack.getContextElement().getAttributeNode(name);
104         if (attr == null) {
105             return (null);
106         }
107         if (stack.isConsumedAttribute(attr)) {
108             throw (new IllegalArgumentException());
109         }
110         stack.consumeAttribute(attr);
111         return (attr.getValue());
112     }
113 
114     public static BigDecimal getAttributePropertyAsBigDecimal(Element element, String name) {
115         try {
116             String value = getAttribute(element, name);
117             if (value == null) {
118                 return (null);
119             } else {
120                 return (new BigDecimal(value));
121             }
122         } catch (Exception e) {
123             return (_invalidBigDecimal(e));
124         }
125     }
126 
127     public static List getAttributePropertyAsBigDecimalList(Element element, String name) {
128         String value = getAttribute(element, name);
129         if (value == null) {
130             return (null);
131         }
132         List list = makeStringList(value);
133         List result = new ArrayList();
134         int size = list.size();
135         for (int i = 0; i < size; i++) {
136             String data = list.get(i).toString();
137             result.add(getBigDecimalObject(data));
138         }
139         return (result);
140     }
141 
142     public static BigInteger getAttributePropertyAsBigInteger(Element element, String name) {
143         try {
144             String value = getAttribute(element, name);
145             if (value == null) {
146                 return (null);
147             } else {
148                 return (new BigInteger(value));
149             }
150         } catch (Exception e) {
151             return (_invalidBigInteger(e));
152         }
153     }
154 
155     public static List getAttributePropertyAsBigIntegerList(Element element, String name) {
156         String value = getAttribute(element, name);
157         if (value == null) {
158             return (null);
159         }
160         List list = makeStringList(value);
161         List result = new ArrayList();
162         int size = list.size();
163         for (int i = 0; i < size; i++) {
164             String data = list.get(i).toString();
165             result.add(getBigIntegerObject(data));
166         }
167         return (result);
168     }
169 
170     public static byte[] getAttributePropertyAsBinaryBASE64(Element element, String name) {
171         String value = getAttribute(element, name);
172         return (makeBytesByBASE64(value));
173     }
174 
175     public static List getAttributePropertyAsBinaryBASE64List(Element element, String name) {
176         String value = getAttribute(element, name);
177         if (value == null) {
178             return (null);
179         }
180         List list = makeStringList(value);
181         List result = new ArrayList();
182         int size = list.size();
183         for (int i = 0; i < size; i++) {
184             String data = list.get(i).toString();
185             result.add(makeBytesByBASE64(data));
186         }
187         return (result);
188     }
189 
190     public static byte[] getAttributePropertyAsBinaryHEX(Element element, String name) {
191         String value = getAttribute(element, name);
192         return (makeBytesByHEX(value));
193     }
194 
195     public static List getAttributePropertyAsBinaryHEXList(Element element, String name) {
196         String value = getAttribute(element, name);
197         if (value == null) {
198             return (null);
199         }
200         List list = makeStringList(value);
201         List result = new ArrayList();
202         int size = list.size();
203         for (int i = 0; i < size; i++) {
204             String data = list.get(i).toString();
205             result.add(makeBytesByHEX(data));
206         }
207         return (result);
208     }
209 
210     public static boolean getAttributePropertyAsBoolean(Element element, String name) {
211         String value = getAttribute(element, name);
212         if (value == null) {
213             return (false);
214         }
215         return ("true".equals(value));
216     }
217 
218     public static List getAttributePropertyAsBooleanList(Element element, String name) {
219         String value = getAttribute(element, name);
220         if (value == null) {
221             return (null);
222         }
223         List list = makeStringList(value);
224         List result = new ArrayList();
225         int size = list.size();
226         for (int i = 0; i < size; i++) {
227             String data = list.get(i).toString();
228             if ("true".equals(data) || "1".equals(data)) {
229                 result.add(Boolean.TRUE);
230             } else {
231                 result.add(Boolean.FALSE);
232             }
233         }
234         return (result);
235     }
236 
237     public static Boolean getAttributePropertyAsBooleanObject(Element element, String name) {
238         String value = getAttribute(element, name);
239         if (value == null) {
240             return (null);
241         }
242         return (getBooleanObject(value));
243     }
244 
245     public static byte getAttributePropertyAsByte(Element element, String name) {
246         try {
247             String value = getAttribute(element, name);
248             if (value == null) {
249                 return (0);
250             } else {
251                 return (Byte.parseByte(value));
252             }
253         } catch (Exception e) {
254             return (_invalidByteValue(e));
255         }
256     }
257 
258     public static List getAttributePropertyAsByteList(Element element, String name) {
259         String value = getAttribute(element, name);
260         if (value == null) {
261             return (null);
262         }
263         List list = makeStringList(value);
264         List result = new ArrayList();
265         int size = list.size();
266         for (int i = 0; i < size; i++) {
267             String data = list.get(i).toString();
268             result.add(getByteObject(data));
269         }
270         return (result);
271     }
272 
273     public static Byte getAttributePropertyAsByteObject(Element element, String name) {
274         String value = getAttribute(element, name);
275         if (value == null) {
276             return (null);
277         } else {
278             return (getByteObject(value));
279         }
280     }
281 
282     public static Date getAttributePropertyAsDate(Element element, String name) {
283         try {
284             String value = getAttribute(element, name);
285             if (value == null) {
286                 return (null);
287             } else {
288                 DateFormat df = DateFormat.getDateInstance();
289                 return (df.parse(value));
290             }
291         } catch (Exception e) {
292             return (_invalidDate(e));
293         }
294     }
295 
296     public static List getAttributePropertyAsDateList(Element element, String name) {
297         String value = getAttribute(element, name);
298         if (value == null) {
299             return (null);
300         }
301         List list = makeStringList(value);
302         List result = new ArrayList();
303         int size = list.size();
304         for (int i = 0; i < size; i++) {
305             String data = list.get(i).toString();
306             result.add(getDateObject(data));
307         }
308         return (result);
309     }
310 
311     public static double getAttributePropertyAsDouble(Element element, String name) {
312         try {
313             String value = getAttribute(element, name);
314             if (value == null) {
315                 return (0);
316             } else {
317                 return (Double.parseDouble(value));
318             }
319         } catch (Exception e) {
320             return (_invalidDoubleValue(e));
321         }
322     }
323 
324     public static List getAttributePropertyAsDoubleList(Element element, String name) {
325         String value = getAttribute(element, name);
326         if (value == null) {
327             return (null);
328         }
329         List list = makeStringList(value);
330         List result = new ArrayList();
331         int size = list.size();
332         for (int i = 0; i < size; i++) {
333             String data = list.get(i).toString();
334             result.add(getDoubleObject(data));
335         }
336         return (result);
337     }
338 
339     public static Double getAttributePropertyAsDoubleObject(Element element, String name) {
340         String value = getAttribute(element, name);
341         if (value == null) {
342             return (null);
343         } else {
344             return (getDoubleObject(value));
345         }
346     }
347 
348     public static float getAttributePropertyAsFloat(Element element, String name) {
349         try {
350             String value = getAttribute(element, name);
351             if (value == null) {
352                 return (0);
353             } else {
354                 return (Float.parseFloat(value));
355             }
356         } catch (Exception e) {
357             return (_invalidFloatValue(e));
358         }
359     }
360 
361     public static List getAttributePropertyAsFloatList(Element element, String name) {
362         String value = getAttribute(element, name);
363         if (value == null) {
364             return (null);
365         }
366         List list = makeStringList(value);
367         List result = new ArrayList();
368         int size = list.size();
369         for (int i = 0; i < size; i++) {
370             String data = list.get(i).toString();
371             result.add(getFloatObject(data));
372         }
373         return (result);
374     }
375 
376     public static Float getAttributePropertyAsFloatObject(Element element, String name) {
377         String value = getAttribute(element, name);
378         if (value == null) {
379             return (null);
380         } else {
381             return (getFloatObject(value));
382         }
383     }
384 
385     public static int getAttributePropertyAsInt(Element element, String name) {
386         try {
387             String value = getAttribute(element, name);
388             if (value == null) {
389                 return (0);
390             } else {
391                 return (Integer.parseInt(value));
392             }
393         } catch (Exception e) {
394             return (_invalidIntValue(e));
395         }
396     }
397 
398     public static List getAttributePropertyAsIntList(Element element, String name) {
399         String value = getAttribute(element, name);
400         if (value == null) {
401             return (null);
402         }
403         List list = makeStringList(value);
404         List result = new ArrayList();
405         int size = list.size();
406         for (int i = 0; i < size; i++) {
407             String data = list.get(i).toString();
408             result.add(getIntObject(data));
409         }
410         return (result);
411     }
412 
413     public static Integer getAttributePropertyAsIntObject(Element element, String name) {
414         String value = getAttribute(element, name);
415         if (value == null) {
416             return (null);
417         } else {
418             return (getIntObject(value));
419         }
420     }
421 
422     public static Locale getAttributePropertyAsLocale(Element element, String name) {
423         String value = getAttribute(element, name);
424         if (value == null) {
425             return (null);
426         } else {
427             return (makeLocale(value));
428         }
429     }
430 
431     public static List getAttributePropertyAsLocaleList(Element element, String name) {
432         String value = getAttribute(element, name);
433         if (value == null) {
434             return (null);
435         }
436         List list = makeStringList(value);
437         List result = new ArrayList();
438         int size = list.size();
439         for (int i = 0; i < size; i++) {
440             String data = list.get(i).toString();
441             result.add(makeLocale(data));
442         }
443         return (result);
444     }
445 
446     public static long getAttributePropertyAsLong(Element element, String name) {
447         try {
448             String value = getAttribute(element, name);
449             if (value == null) {
450                 return (0);
451             } else {
452                 return (Long.parseLong(value));
453             }
454         } catch (Exception e) {
455             return (_invalidLongValue(e));
456         }
457     }
458 
459     public static List getAttributePropertyAsLongList(Element element, String name) {
460         String value = getAttribute(element, name);
461         if (value == null) {
462             return (null);
463         }
464         List list = makeStringList(value);
465         List result = new ArrayList();
466         int size = list.size();
467         for (int i = 0; i < size; i++) {
468             String data = list.get(i).toString();
469             result.add(getLongObject(data));
470         }
471         return (result);
472     }
473 
474     public static Long getAttributePropertyAsLongObject(Element element, String name) {
475         String value = getAttribute(element, name);
476         if (value == null) {
477             return (null);
478         } else {
479             return (getLongObject(value));
480         }
481     }
482 
483     public static short getAttributePropertyAsShort(Element element, String name) {
484         try {
485             String value = getAttribute(element, name);
486             if (value == null) {
487                 return (0);
488             } else {
489                 return (Short.parseShort(value));
490             }
491         } catch (Exception e) {
492             return (_invalidShortValue(e));
493         }
494     }
495 
496     public static List getAttributePropertyAsShortList(Element element, String name) {
497         String value = getAttribute(element, name);
498         if (value == null) {
499             return (null);
500         }
501         List list = makeStringList(value);
502         List result = new ArrayList();
503         int size = list.size();
504         for (int i = 0; i < size; i++) {
505             String data = list.get(i).toString();
506             result.add(getShortObject(data));
507         }
508         return (result);
509     }
510 
511     public static Short getAttributePropertyAsShortObject(Element element, String name) {
512         String value = getAttribute(element, name);
513         if (value == null) {
514             return (null);
515         } else {
516             return (getShortObject(value));
517         }
518     }
519 
520     public static java.sql.Date getAttributePropertyAsSQLDate(Element element, String name) {
521         String value = getAttribute(element, name);
522         if (value == null) {
523             return (null);
524         } else {
525             return (getSQLDate(value));
526         }
527     }
528 
529     public static List getAttributePropertyAsSQLDateList(Element element, String name) {
530         String value = getAttribute(element, name);
531         if (value == null) {
532             return (null);
533         }
534         List list = makeStringList(value);
535         List result = new ArrayList();
536         int size = list.size();
537         for (int i = 0; i < size; i++) {
538             String data = list.get(i).toString();
539             result.add(getSQLDate(data));
540         }
541         return (result);
542     }
543 
544     public static java.sql.Time getAttributePropertyAsSQLTime(Element element, String name) {
545         String value = getAttribute(element, name);
546         if (value == null) {
547             return (null);
548         } else {
549             return (getSQLTime(value));
550         }
551     }
552 
553     public static List getAttributePropertyAsSQLTimeList(Element element, String name) {
554         String value = getAttribute(element, name);
555         if (value == null) {
556             return (null);
557         }
558         List list = makeStringList(value);
559         List result = new ArrayList();
560         int size = list.size();
561         for (int i = 0; i < size; i++) {
562             String data = list.get(i).toString();
563             result.add(getSQLTime(data));
564         }
565         return (result);
566     }
567 
568     public static java.sql.Timestamp getAttributePropertyAsSQLTimestamp(Element element, String name) {
569         String value = getAttribute(element, name);
570         if (value == null) {
571             return (null);
572         } else {
573             return (getSQLTimestamp(value));
574         }
575     }
576 
577     public static List getAttributePropertyAsSQLTimestampList(Element element, String name) {
578         String value = getAttribute(element, name);
579         if (value == null) {
580             return (null);
581         }
582         List list = makeStringList(value);
583         List result = new ArrayList();
584         int size = list.size();
585         for (int i = 0; i < size; i++) {
586             String data = list.get(i).toString();
587             result.add(getSQLTimestamp(data));
588         }
589         return (result);
590     }
591 
592     public static String getAttributePropertyAsString(Element element, String name) {
593         String value = getAttribute(element, name);
594         if (value == null) {
595             return (null);
596         } else {
597             return (value);
598         }
599     }
600 
601     public static List getAttributePropertyAsStringList(Element element, String name) {
602         String value = getAttribute(element, name);
603         if (value == null) {
604             return (null);
605         }
606         return (makeStringList(value));
607     }
608 
609     public static URL getAttributePropertyAsURL(Element element, String name) {
610         String value = getAttribute(element, name);
611         if (value == null) {
612             return (null);
613         } else {
614             return (makeURL4Property(value));
615         }
616     }
617 
618     public static List getAttributePropertyAsURLList(Element element, String name) {
619         String value = getAttribute(element, name);
620         if (value == null) {
621             return (null);
622         }
623         List list = makeStringList(value);
624         List result = new ArrayList();
625         int size = list.size();
626         for (int i = 0; i < size; i++) {
627             String data = list.get(i).toString();
628             URL url = makeURL4Property(data);
629             if (url != null) {
630                 result.add(url);
631             }
632         }
633         return (result);
634     }
635 
636     public static String getAttributePropertyAsValue(Element element, String attrName, String typeName) {
637         if ("string".equals(typeName)) {
638             return (getAttributePropertyAsString(element, attrName));
639         } else {
640             return (getAttributePropertyAsValueData(element, attrName));
641         }
642     }
643 
644     public static String getAttributePropertyAsValueData(Element element, String attrName) {
645         String data = getAttributePropertyAsString(element, attrName);
646         if (data == null) {
647             return (null);
648         }
649         return (data.trim());
650     }
651 
652     public static String getAutoIDPrefix() {
653         return (autoIDPrefix__);
654     }
655 
656     public static Boolean getAutoIDThreadGroupSingle() {
657         return (autoIDThreadGroupSingle__);
658     }
659 
660     public static Boolean getAutoIDThreadSingle() {
661         return (autoIDThreadSingle__);
662     }
663 
664     public static BigDecimal getBigDecimal(String value) {
665         try {
666             return (new BigDecimal(value));
667         } catch (Exception e) {
668             return (_invalidBigDecimal(e));
669         }
670     }
671 
672     public static BigDecimal[] getBigDecimalList(String text) {
673         String[] strings = getStringList(text);
674         BigDecimal[] list = new BigDecimal[strings.length];
675         for (int i = 0; i < strings.length; i++) {
676             list[i] = getBigDecimal(strings[i]);
677         }
678         return (list);
679     }
680 
681     public static BigDecimal getBigDecimalObject(Object value) {
682         try {
683             if (value instanceof BigDecimal) {
684                 return ((BigDecimal)value);
685             } else {
686                 return (new BigDecimal(value.toString()));
687             }
688         } catch (Exception e) {
689             return (_invalidBigDecimal(e));
690         }
691     }
692 
693     public static BigInteger getBigInteger(String value) {
694         try {
695             return (new BigInteger(value));
696         } catch (Exception e) {
697             return (_invalidBigInteger(e));
698         }
699     }
700 
701     public static BigInteger[] getBigIntegerList(String text) {
702         String[] strings = getStringList(text);
703         BigInteger[] list = new BigInteger[strings.length];
704         for (int i = 0; i < strings.length; i++) {
705             list[i] = getBigInteger(strings[i]);
706         }
707         return (list);
708     }
709 
710     public static BigInteger getBigIntegerObject(Object value) {
711         try {
712             if (value instanceof BigInteger) {
713                 return ((BigInteger)value);
714             } else {
715                 return (new BigInteger(value.toString()));
716             }
717         } catch (Exception e) {
718             return (_invalidBigInteger(e));
719         }
720     }
721 
722     public static byte[] getBinary(String value) {
723         return (makeBytesByBASE64(value));
724     }
725 
726     public static byte[] getBinaryHEX(String value) {
727         return (makeBytesByHEX(value));
728     }
729 
730     public static byte[][] getBinaryHEXList(String text) {
731         String[] strings = getStringList(text);
732         byte[][] list = new byte[strings.length][];
733         for (int i = 0; i < strings.length; i++) {
734             list[i] = getBinaryHEX(strings[i]);
735         }
736         return (list);
737     }
738 
739     public static byte[] getBinaryHEXObject(Object value) {
740         if (value instanceof byte[]) {
741             return ((byte[])value);
742         } else {
743             return (makeBytesByHEX(value.toString()));
744         }
745     }
746 
747     public static byte[][] getBinaryList(String text) {
748         String[] strings = getStringList(text);
749         byte[][] list = new byte[strings.length][];
750         for (int i = 0; i < strings.length; i++) {
751             list[i] = getBinary(strings[i]);
752         }
753         return (list);
754     }
755 
756     public static byte[] getBinaryObject(Object value) {
757         if (value instanceof byte[]) {
758             return ((byte[])value);
759         } else {
760             return (getBinary(value.toString()));
761         }
762     }
763 
764     // binary type (BASE64)
765     public static String getBinaryString(byte[] value) {
766         if (value == null) {
767             return (null);
768         }
769         return (makeStringAsBASE64(value));
770     }
771 
772     public static String getBinaryString(byte[][] value) {
773         if (value == null) {
774             return (null);
775         }
776         if (value.length == 0) {
777             return ("");
778         }
779         StringBuffer buffer = new StringBuffer();
780         buffer.append(makeStringAsBASE64(value[0]));
781         for (int i = 1; i < value.length; i++) {
782             buffer.append(" ");
783             buffer.append(makeStringAsBASE64(value[i]));
784         }
785         return (new String(buffer));
786     }
787 
788     public static Boolean getBooleanObject(String text) {
789         if ("true".equals(text) || "1".equals(text)) {
790             return (Boolean.TRUE);
791         } else if ("false".equals(text) || "0".equals(text)) {
792             return (Boolean.FALSE);
793         } else {
794             return (_invalidBooleanObject(text));
795         }
796     }
797 
798     public static Boolean[] getBooleanObjectList(String text) {
799         String[] strings = getStringList(text);
800         Boolean[] list = new Boolean[strings.length];
801         for (int i = 0; i < strings.length; i++) {
802             list[i] = getBooleanObject(strings[i]);
803         }
804         return (list);
805     }
806 
807     public static boolean getBooleanValue(Object value) {
808         Boolean object;
809         if (value instanceof Boolean) {
810             object = (Boolean)value;
811             return (object.booleanValue());
812         } else {
813             String string = value.toString();
814             return ("true".equals(string) || "1".equals(string));
815         }
816     }
817 
818     public static Byte getByteObject(String text) {
819         try {
820             return (new Byte(text));
821         } catch (Exception e) {
822             return (_invalidByteObject(e));
823         }
824     }
825 
826     public static Byte[] getByteObjectList(String text) {
827         String[] strings = getStringList(text);
828         Byte[] list = new Byte[strings.length];
829         for (int i = 0; i < strings.length; i++) {
830             list[i] = getByteObject(strings[i]);
831         }
832         return (list);
833     }
834 
835     public static byte getByteValue(Object value) {
836         try {
837             Number object;
838             if (value instanceof Number) {
839                 object = (Number)value;
840             } else {
841                 object = new Byte(value.toString());
842             }
843             return (object.byteValue());
844         } catch (Exception e) {
845             return (_invalidByteValue(e));
846         }
847     }
848 
849     public static Date getDateObject(Object value) {
850         if (value instanceof Date) {
851             return ((Date)value);
852         } else {
853             return (getSQLTimestampObject(value));
854         }
855     }
856 
857     public static Double getDoubleObject(String text) {
858         try {
859             return (new Double(text));
860         } catch (Exception e) {
861             return (_invalidDoubleObject(e));
862         }
863     }
864 
865     public static Double[] getDoubleObjectList(String text) {
866         String[] strings = getStringList(text);
867         Double[] list = new Double[strings.length];
868         for (int i = 0; i < strings.length; i++) {
869             list[i] = getDoubleObject(strings[i]);
870         }
871         return (list);
872     }
873 
874     public static double getDoubleValue(Object value) {
875         try {
876             Number object;
877             if (value instanceof Number) {
878                 object = (Number)value;
879             } else {
880                 object = new Double(value.toString());
881             }
882             return (object.doubleValue());
883         } catch (Exception e) {
884             return (_invalidDoubleValue(e));
885         }
886     }
887 
888     public static BigDecimal getElementPropertyAsBigDecimal(Element element) {
889         try {
890             String text = element2Data(element);
891             return (new BigDecimal(text));
892         } catch (Exception e) {
893             return (_invalidBigDecimal(e));
894         }
895     }
896 
897     public static BigDecimal getElementPropertyAsBigDecimal(Element element, String name) {
898         try {
899             Element property = getOnlyElement(element, name);
900             String text = element2Data(property);
901             return (new BigDecimal(text));
902         } catch (Exception e) {
903             return (_invalidBigDecimal(e));
904         }
905     }
906 
907     public static BigDecimal getElementPropertyAsBigDecimalByStack(RStack stack, String name) {
908         if (stack.isEmptyElement()) {
909             return (null);
910         }
911         Element property = stack.peekElement();
912         if (!name.equals(property.getTagName())) {
913             return (null);
914         }
915         stack.popElement();
916         return (getElementPropertyAsBigDecimal(property));
917     }
918 
919     // g1u
920     public static List getElementPropertyAsBigDecimalDataList(Element element) {
921         List result = new ArrayList();
922         List strings = getElementPropertyAsStringDataList(element);
923         int size = strings.size();
924         for (int i = 0; i < size; i++) {
925             result.add(getBigDecimalObject((String)strings.get(i)));
926         }
927         return (result);
928     }
929 
930     // g2a
931     public static List getElementPropertyAsBigDecimalDataList(Element element, String name) {
932         Element property = getOnlyElement(element, name);
933         return (getElementPropertyAsBigDecimalDataList(property));
934     }
935 
936     // g4a
937     public static List getElementPropertyAsBigDecimalDataListByStack(RStack stack, String name) {
938         if (stack.isEmptyElement()) {
939             return (null);
940         }
941         Element property = stack.peekElement();
942         if (!name.equals(property.getTagName())) {
943             return (null);
944         }
945         stack.popElement();
946         return (getElementPropertyAsBigDecimalDataList(property));
947     }
948 
949     public static List getElementPropertyAsBigDecimalList(Element element, String name) {
950         Element[] nodes = getElements(element, name);
951         List list = new ArrayList();
952         for (int i = 0; i < nodes.length; i++) {
953             try {
954                 list.add(new BigDecimal(element2Data(nodes[i])));
955             } catch (Exception e) {
956                 _invalidBigDecimal(e);
957             }
958         }
959         return (list);
960     }
961 
962     public static List getElementPropertyAsBigDecimalListByStack(RStack stack, String name) {
963         List list = new ArrayList();
964         for (;;) {
965             if (stack.isEmptyElement()) {
966                 break;
967             }
968             Element property = stack.peekElement();
969             if (!name.equals(property.getTagName())) {
970                 break;
971             }
972             stack.popElement();
973             try {
974                 list.add(new BigDecimal(element2Text(property)));
975             } catch (Exception e) {
976                 _invalidBigDecimal(e);
977             }
978         }
979         return (list);
980     }
981 
982     // g3a
983     public static List getElementPropertyAsBigDecimalListDataList(Element element, String name) {
984         Element[] nodes = getElements(element, name);
985         List list = new ArrayList();
986         for (int i = 0; i < nodes.length; i++) {
987             List values = getElementPropertyAsBigDecimalDataList(nodes[i]);
988             if (values != null) {
989                 list.add(values);
990             }
991         }
992         return (list);
993     }
994 
995     // g5a
996     public static List getElementPropertyAsBigDecimalListDataListByStack(RStack stack, String name) {
997         List list = new ArrayList();
998         for (;;) {
999             if (stack.isEmptyElement()) {
1000                 break;
1001             }
1002             Element property = stack.peekElement();
1003             if (!name.equals(property.getTagName())) {
1004                 break;
1005             }
1006             stack.popElement();
1007             List value = getElementPropertyAsBigDecimalDataList(property);
1008             if (value != null) {
1009                 list.add(value);
1010             }
1011         }
1012         return (list);
1013     }
1014 
1015     public static BigInteger getElementPropertyAsBigInteger(Element element) {
1016         try {
1017             String text = element2Data(element);
1018             return (new BigInteger(text));
1019         } catch (Exception e) {
1020             return (_invalidBigInteger(e));
1021         }
1022     }
1023 
1024     public static BigInteger getElementPropertyAsBigInteger(Element element, String name) {
1025         try {
1026             Element property = getOnlyElement(element, name);
1027             String text = element2Data(property);
1028             return (new BigInteger(text));
1029         } catch (Exception e) {
1030             return (_invalidBigInteger(e));
1031         }
1032     }
1033 
1034     public static BigInteger getElementPropertyAsBigIntegerByStack(RStack stack, String name) {
1035         if (stack.isEmptyElement()) {
1036             return (null);
1037         }
1038         Element property = stack.peekElement();
1039         if (!name.equals(property.getTagName())) {
1040             return (null);
1041         }
1042         stack.popElement();
1043         return (getElementPropertyAsBigInteger(property));
1044     }
1045 
1046     // g1u
1047     public static List getElementPropertyAsBigIntegerDataList(Element element) {
1048         List result = new ArrayList();
1049         List strings = getElementPropertyAsStringDataList(element);
1050         int size = strings.size();
1051         for (int i = 0; i < size; i++) {
1052             result.add(getBigIntegerObject((String)strings.get(i)));
1053         }
1054         return (result);
1055     }
1056 
1057     // g2a
1058     public static List getElementPropertyAsBigIntegerDataList(Element element, String name) {
1059         Element property = getOnlyElement(element, name);
1060         return (getElementPropertyAsBigIntegerDataList(property));
1061     }
1062 
1063     // g4a
1064     public static List getElementPropertyAsBigIntegerDataListByStack(RStack stack, String name) {
1065         if (stack.isEmptyElement()) {
1066             return (null);
1067         }
1068         Element property = stack.peekElement();
1069         if (!name.equals(property.getTagName())) {
1070             return (null);
1071         }
1072         stack.popElement();
1073         return (getElementPropertyAsBigIntegerDataList(property));
1074     }
1075 
1076     public static List getElementPropertyAsBigIntegerList(Element element, String name) {
1077         Element[] nodes = getElements(element, name);
1078         List list = new ArrayList();
1079         for (int i = 0; i < nodes.length; i++) {
1080             try {
1081                 list.add(new BigInteger(element2Data(nodes[i])));
1082             } catch (Exception e) {
1083                 _invalidBigInteger(e);
1084             }
1085         }
1086         return (list);
1087     }
1088 
1089     public static List getElementPropertyAsBigIntegerListByStack(RStack stack, String name) {
1090         List list = new ArrayList();
1091         for (;;) {
1092             if (stack.isEmptyElement()) {
1093                 break;
1094             }
1095             Element property = stack.peekElement();
1096             if (!name.equals(property.getTagName())) {
1097                 break;
1098             }
1099             stack.popElement();
1100             try {
1101                 list.add(new BigInteger(element2Text(property)));
1102             } catch (Exception e) {
1103                 _invalidBigInteger(e);
1104             }
1105         }
1106         return (list);
1107     }
1108 
1109     // g3a
1110     public static List getElementPropertyAsBigIntegerListDataList(Element element, String name) {
1111         Element[] nodes = getElements(element, name);
1112         List list = new ArrayList();
1113         for (int i = 0; i < nodes.length; i++) {
1114             List values = getElementPropertyAsBigIntegerDataList(nodes[i]);
1115             if (values != null) {
1116                 list.add(values);
1117             }
1118         }
1119         return (list);
1120     }
1121 
1122     // g5a
1123     public static List getElementPropertyAsBigIntegerListDataListByStack(RStack stack, String name) {
1124         List list = new ArrayList();
1125         for (;;) {
1126             if (stack.isEmptyElement()) {
1127                 break;
1128             }
1129             Element property = stack.peekElement();
1130             if (!name.equals(property.getTagName())) {
1131                 break;
1132             }
1133             stack.popElement();
1134             List value = getElementPropertyAsBigIntegerDataList(property);
1135             if (value != null) {
1136                 list.add(value);
1137             }
1138         }
1139         return (list);
1140     }
1141 
1142     public static byte[] getElementPropertyAsBinaryBASE64(Element element) {
1143         String text = element2Data(element);
1144         return (makeBytesByBASE64(text));
1145     }
1146 
1147     public static byte[] getElementPropertyAsBinaryBASE64(Element element, String name) {
1148         Element property = getOnlyElement(element, name);
1149         String text = element2Data(property);
1150         return (makeBytesByBASE64(text));
1151     }
1152 
1153     public static byte[] getElementPropertyAsBinaryBASE64ByStack(RStack stack, String name) {
1154         if (stack.isEmptyElement()) {
1155             return (null);
1156         }
1157         Element property = stack.peekElement();
1158         if (!name.equals(property.getTagName())) {
1159             return (null);
1160         }
1161         stack.popElement();
1162         return (getElementPropertyAsBinaryBASE64(property));
1163     }
1164 
1165     // g1u
1166     public static List getElementPropertyAsBinaryBASE64DataList(Element element) {
1167         List result = new ArrayList();
1168         List strings = getElementPropertyAsStringDataList(element);
1169         int size = strings.size();
1170         for (int i = 0; i < size; i++) {
1171             result.add(getBinaryObject((String)strings.get(i)));
1172         }
1173         return (result);
1174     }
1175 
1176     // g2a
1177     public static List getElementPropertyAsBinaryBASE64DataList(Element element, String name) {
1178         Element property = getOnlyElement(element, name);
1179         return (getElementPropertyAsBinaryBASE64DataList(property));
1180     }
1181 
1182     // g4a
1183     public static List getElementPropertyAsBinaryBASE64DataListByStack(RStack stack, String name) {
1184         if (stack.isEmptyElement()) {
1185             return (null);
1186         }
1187         Element property = stack.peekElement();
1188         if (!name.equals(property.getTagName())) {
1189             return (null);
1190         }
1191         stack.popElement();
1192         return (getElementPropertyAsBinaryBASE64DataList(property));
1193     }
1194 
1195     // g3a
1196     public static List getElementPropertyAsBinaryBASE64ListDataList(Element element, String name) {
1197         Element[] nodes = getElements(element, name);
1198         List list = new ArrayList();
1199         for (int i = 0; i < nodes.length; i++) {
1200             List values = getElementPropertyAsBinaryBASE64DataList(nodes[i]);
1201             if (values != null) {
1202                 list.add(values);
1203             }
1204         }
1205         return (list);
1206     }
1207 
1208     // g5a
1209     public static List getElementPropertyAsBinaryBASE64ListDataListByStack(RStack stack, String name) {
1210         List list = new ArrayList();
1211         for (;;) {
1212             if (stack.isEmptyElement()) {
1213                 break;
1214             }
1215             Element property = stack.peekElement();
1216             if (!name.equals(property.getTagName())) {
1217                 break;
1218             }
1219             stack.popElement();
1220             List value = getElementPropertyAsBinaryBASE64DataList(property);
1221             if (value != null) {
1222                 list.add(value);
1223             }
1224         }
1225         return (list);
1226     }
1227 
1228     public static byte[] getElementPropertyAsBinaryHEX(Element element) {
1229         String text = element2Data(element);
1230         return (makeBytesByHEX(text));
1231     }
1232 
1233     public static byte[] getElementPropertyAsBinaryHEX(Element element, String name) {
1234         Element property = getOnlyElement(element, name);
1235         String text = element2Data(property);
1236         return (makeBytesByHEX(text));
1237     }
1238 
1239     public static byte[] getElementPropertyAsBinaryHEXByStack(RStack stack, String name) {
1240         if (stack.isEmptyElement()) {
1241             return (null);
1242         }
1243         Element property = stack.peekElement();
1244         if (!name.equals(property.getTagName())) {
1245             return (null);
1246         }
1247         stack.popElement();
1248         return (getElementPropertyAsBinaryHEX(property));
1249     }
1250 
1251     // g1u
1252     public static List getElementPropertyAsBinaryHEXDataList(Element element) {
1253         List result = new ArrayList();
1254         List strings = getElementPropertyAsStringDataList(element);
1255         int size = strings.size();
1256         for (int i = 0; i < size; i++) {
1257             result.add(getBinaryHEXObject((String)strings.get(i)));
1258         }
1259         return (result);
1260     }
1261 
1262     // g2a
1263     public static List getElementPropertyAsBinaryHEXDataList(Element element, String name) {
1264         Element property = getOnlyElement(element, name);
1265         return (getElementPropertyAsBinaryHEXDataList(property));
1266     }
1267 
1268     // g4a
1269     public static List getElementPropertyAsBinaryHEXDataListByStack(RStack stack, String name) {
1270         if (stack.isEmptyElement()) {
1271             return (null);
1272         }
1273         Element property = stack.peekElement();
1274         if (!name.equals(property.getTagName())) {
1275             return (null);
1276         }
1277         stack.popElement();
1278         return (getElementPropertyAsBinaryHEXDataList(property));
1279     }
1280 
1281     // g3a
1282     public static List getElementPropertyAsBinaryHEXListDataList(Element element, String name) {
1283         Element[] nodes = getElements(element, name);
1284         List list = new ArrayList();
1285         for (int i = 0; i < nodes.length; i++) {
1286             List values = getElementPropertyAsBinaryHEXDataList(nodes[i]);
1287             if (values != null) {
1288                 list.add(values);
1289             }
1290         }
1291         return (list);
1292     }
1293 
1294     // g5a
1295     public static List getElementPropertyAsBinaryHEXListDataListByStack(RStack stack, String name) {
1296         List list = new ArrayList();
1297         for (;;) {
1298             if (stack.isEmptyElement()) {
1299                 break;
1300             }
1301             Element property = stack.peekElement();
1302             if (!name.equals(property.getTagName())) {
1303                 break;
1304             }
1305             stack.popElement();
1306             List value = getElementPropertyAsBinaryHEXDataList(property);
1307             if (value != null) {
1308                 list.add(value);
1309             }
1310         }
1311         return (list);
1312     }
1313 
1314     public static List getElementPropertyAsBinaryListBASE64(Element element, String name) {
1315         Element[] nodes = getElements(element, name);
1316         List list = new ArrayList();
1317         for (int i = 0; i < nodes.length; i++) {
1318             byte[] binary = makeBytesByBASE64(element2Data(nodes[i]));
1319             if (binary != null) {
1320                 list.add(binary);
1321             }
1322         }
1323         return (list);
1324     }
1325 
1326     public static List getElementPropertyAsBinaryListBASE64ByStack(RStack stack, String name) {
1327         List list = new ArrayList();
1328         for (;;) {
1329             if (stack.isEmptyElement()) {
1330                 break;
1331             }
1332             Element property = stack.peekElement();
1333             if (!name.equals(property.getTagName())) {
1334                 break;
1335             }
1336             stack.popElement();
1337             byte[] binary = makeBytesByBASE64(element2Data(property));
1338             if (binary != null) {
1339                 list.add(binary);
1340             }
1341         }
1342         return (list);
1343     }
1344 
1345     public static List getElementPropertyAsBinaryListHEX(Element element, String name) {
1346         Element[] nodes = getElements(element, name);
1347         List list = new ArrayList();
1348         for (int i = 0; i < nodes.length; i++) {
1349             byte[] binary = makeBytesByHEX(element2Data(nodes[i]));
1350             if (binary != null) {
1351                 list.add(binary);
1352             }
1353         }
1354         return (list);
1355     }
1356 
1357     public static List getElementPropertyAsBinaryListHEXByStack(RStack stack, String name) {
1358         List list = new ArrayList();
1359         for (;;) {
1360             if (stack.isEmptyElement()) {
1361                 break;
1362             }
1363             Element property = stack.peekElement();
1364             if (!name.equals(property.getTagName())) {
1365                 break;
1366             }
1367             stack.popElement();
1368             byte[] binary = getElementPropertyAsBinaryHEX(property);
1369             if (binary != null) {
1370                 list.add(binary);
1371             }
1372         }
1373         return (list);
1374     }
1375 
1376     public static boolean getElementPropertyAsBoolean(Element element) {
1377         String text = element2Data(element);
1378         return ("true".equals(text) || "1".equals(text));
1379     }
1380 
1381     public static boolean getElementPropertyAsBoolean(Element element, String name) {
1382         Element property = getOnlyElement(element, name);
1383         return (getElementPropertyAsBoolean(property));
1384     }
1385 
1386     public static Boolean getElementPropertyAsBooleanByStack(RStack stack, String name) {
1387         if (stack.isEmptyElement()) {
1388             return (null);
1389         }
1390         Element property = stack.peekElement();
1391         if (!name.equals(property.getTagName())) {
1392             return (null);
1393         }
1394         stack.popElement();
1395         return (getElementPropertyAsBooleanObject(property));
1396     }
1397 
1398     // g1u
1399     public static List getElementPropertyAsBooleanDataList(Element element) {
1400         List result = new ArrayList();
1401         List strings = getElementPropertyAsStringDataList(element);
1402         int size = strings.size();
1403         for (int i = 0; i < size; i++) {
1404             result.add(getBooleanObject((String)strings.get(i)));
1405         }
1406         return (result);
1407     }
1408 
1409     // g2a
1410     public static List getElementPropertyAsBooleanDataList(Element element, String name) {
1411         Element property = getOnlyElement(element, name);
1412         return (getElementPropertyAsBooleanDataList(property));
1413     }
1414 
1415     // g4a
1416     public static List getElementPropertyAsBooleanDataListByStack(RStack stack, String name) {
1417         if (stack.isEmptyElement()) {
1418             return (null);
1419         }
1420         Element property = stack.peekElement();
1421         if (!name.equals(property.getTagName())) {
1422             return (null);
1423         }
1424         stack.popElement();
1425         return (getElementPropertyAsBooleanDataList(property));
1426     }
1427 
1428     public static List getElementPropertyAsBooleanList(Element element, String name) {
1429         Element[] nodes = getElements(element, name);
1430         List list = new ArrayList();
1431         for (int i = 0; i < nodes.length; i++) {
1432             Boolean value = getElementPropertyAsBooleanObject(nodes[i]);
1433             if (value != null) {
1434                 list.add(value);
1435             }
1436         }
1437         return (list);
1438     }
1439 
1440     public static List getElementPropertyAsBooleanListByStack(RStack stack, String name) {
1441         List list = new ArrayList();
1442         for (;;) {
1443             if (stack.isEmptyElement()) {
1444                 break;
1445             }
1446             Element property = stack.peekElement();
1447             if (!name.equals(property.getTagName())) {
1448                 break;
1449             }
1450             stack.popElement();
1451             Boolean value = getElementPropertyAsBooleanObject(property);
1452             if (value != null) {
1453                 list.add(value);
1454             }
1455         }
1456         return (list);
1457     }
1458 
1459     // g3a
1460     public static List getElementPropertyAsBooleanListDataList(Element element, String name) {
1461         Element[] nodes = getElements(element, name);
1462         List list = new ArrayList();
1463         for (int i = 0; i < nodes.length; i++) {
1464             List values = getElementPropertyAsBooleanDataList(nodes[i]);
1465             if (values != null) {
1466                 list.add(values);
1467             }
1468         }
1469         return (list);
1470     }
1471 
1472     // g5a
1473     public static List getElementPropertyAsBooleanListDataListByStack(RStack stack, String name) {
1474         List list = new ArrayList();
1475         for (;;) {
1476             if (stack.isEmptyElement()) {
1477                 break;
1478             }
1479             Element property = stack.peekElement();
1480             if (!name.equals(property.getTagName())) {
1481                 break;
1482             }
1483             stack.popElement();
1484             List value = getElementPropertyAsBooleanDataList(property);
1485             if (value != null) {
1486                 list.add(value);
1487             }
1488         }
1489         return (list);
1490     }
1491 
1492     public static Boolean getElementPropertyAsBooleanObject(Element element) {
1493         String text = element2Data(element);
1494         return (getBooleanObject(text));
1495     }
1496 
1497     public static byte getElementPropertyAsByte(Element element) {
1498         try {
1499             String text = element2Data(element);
1500             return (Byte.parseByte(text));
1501         } catch (Exception e) {
1502             return (_invalidByteValue(e));
1503         }
1504     }
1505 
1506     public static byte getElementPropertyAsByte(Element element, String name) {
1507         try {
1508             Element property = getOnlyElement(element, name);
1509             String text = element2Data(property);
1510             return (Byte.parseByte(text));
1511         } catch (Exception e) {
1512             return (_invalidByteValue(e));
1513         }
1514     }
1515 
1516     public static Byte getElementPropertyAsByteByStack(RStack stack, String name) {
1517         if (stack.isEmptyElement()) {
1518             return (null);
1519         }
1520         Element property = stack.peekElement();
1521         if (!name.equals(property.getTagName())) {
1522             return (null);
1523         }
1524         stack.popElement();
1525         return (getElementPropertyAsByteObject(property));
1526     }
1527 
1528     // g1u
1529     public static List getElementPropertyAsByteDataList(Element element) {
1530         List result = new ArrayList();
1531         List strings = getElementPropertyAsStringDataList(element);
1532         int size = strings.size();
1533         for (int i = 0; i < size; i++) {
1534             result.add(getByteObject((String)strings.get(i)));
1535         }
1536         return (result);
1537     }
1538 
1539     // g2a
1540     public static List getElementPropertyAsByteDataList(Element element, String name) {
1541         Element property = getOnlyElement(element, name);
1542         return (getElementPropertyAsByteDataList(property));
1543     }
1544 
1545     // g4a
1546     public static List getElementPropertyAsByteDataListByStack(RStack stack, String name) {
1547         if (stack.isEmptyElement()) {
1548             return (null);
1549         }
1550         Element property = stack.peekElement();
1551         if (!name.equals(property.getTagName())) {
1552             return (null);
1553         }
1554         stack.popElement();
1555         return (getElementPropertyAsByteDataList(property));
1556     }
1557 
1558     public static List getElementPropertyAsByteList(Element element, String name) {
1559         Element[] nodes = getElements(element, name);
1560         List list = new ArrayList();
1561         for (int i = 0; i < nodes.length; i++) {
1562             Byte value = getElementPropertyAsByteObject(nodes[i]);
1563             if (value != null) {
1564                 list.add(value);
1565             }
1566         }
1567         return (list);
1568     }
1569 
1570     public static List getElementPropertyAsByteListByStack(RStack stack, String name) {
1571         List list = new ArrayList();
1572         for (;;) {
1573             if (stack.isEmptyElement()) {
1574                 break;
1575             }
1576             Element property = stack.peekElement();
1577             if (!name.equals(property.getTagName())) {
1578                 break;
1579             }
1580             stack.popElement();
1581             Byte value = getElementPropertyAsByteObject(property);
1582             if (value != null) {
1583                 list.add(value);
1584             }
1585         }
1586         return (list);
1587     }
1588 
1589     // g3a
1590     public static List getElementPropertyAsByteListDataList(Element element, String name) {
1591         Element[] nodes = getElements(element, name);
1592         List list = new ArrayList();
1593         for (int i = 0; i < nodes.length; i++) {
1594             List values = getElementPropertyAsByteDataList(nodes[i]);
1595             if (values != null) {
1596                 list.add(values);
1597             }
1598         }
1599         return (list);
1600     }
1601 
1602     // g5a
1603     public static List getElementPropertyAsByteListDataListByStack(RStack stack, String name) {
1604         List list = new ArrayList();
1605         for (;;) {
1606             if (stack.isEmptyElement()) {
1607                 break;
1608             }
1609             Element property = stack.peekElement();
1610             if (!name.equals(property.getTagName())) {
1611                 break;
1612             }
1613             stack.popElement();
1614             List value = getElementPropertyAsByteDataList(property);
1615             if (value != null) {
1616                 list.add(value);
1617             }
1618         }
1619         return (list);
1620     }
1621 
1622     public static Byte getElementPropertyAsByteObject(Element element) {
1623         String text = element2Data(element);
1624         return (getByteObject(text));
1625     }
1626 
1627     public static Date getElementPropertyAsDate(Element element) {
1628         try {
1629             String text = element2Data(element);
1630             DateFormat df = DateFormat.getDateInstance();
1631             return (df.parse(text));
1632         } catch (Exception e) {
1633             return (_invalidDate(e));
1634         }
1635     }
1636 
1637     public static Date getElementPropertyAsDate(Element element, String name) {
1638         try {
1639             Element property = getOnlyElement(element, name);
1640             String text = element2Data(property);
1641             DateFormat df = DateFormat.getDateInstance();
1642             return (df.parse(text));
1643         } catch (Exception e) {
1644             return (_invalidDate(e));
1645         }
1646     }
1647 
1648     public static Date getElementPropertyAsDateByStack(RStack stack, String name) {
1649         if (stack.isEmptyElement()) {
1650             return (null);
1651         }
1652         Element property = stack.peekElement();
1653         if (!name.equals(property.getTagName())) {
1654             return (null);
1655         }
1656         stack.popElement();
1657         return (getElementPropertyAsDate(property));
1658     }
1659 
1660     // g1u
1661     public static List getElementPropertyAsDateDataList(Element element) {
1662         List result = new ArrayList();
1663         List strings = getElementPropertyAsStringDataList(element);
1664         int size = strings.size();
1665         for (int i = 0; i < size; i++) {
1666             result.add(getDateObject((String)strings.get(i)));
1667         }
1668         return (result);
1669     }
1670 
1671     // g2a
1672     public static List getElementPropertyAsDateDataList(Element element, String name) {
1673         Element property = getOnlyElement(element, name);
1674         return (getElementPropertyAsDateDataList(property));
1675     }
1676 
1677     // g4a
1678     public static List getElementPropertyAsDateDataListByStack(RStack stack, String name) {
1679         if (stack.isEmptyElement()) {
1680             return (null);
1681         }
1682         Element property = stack.peekElement();
1683         if (!name.equals(property.getTagName())) {
1684             return (null);
1685         }
1686         stack.popElement();
1687         return (getElementPropertyAsDateDataList(property));
1688     }
1689 
1690     public static List getElementPropertyAsDateList(Element element, String name) {
1691         Element[] nodes = getElements(element, name);
1692         DateFormat df = DateFormat.getDateInstance();
1693         List list = new ArrayList();
1694         for (int i = 0; i < nodes.length; i++) {
1695             try {
1696                 list.add(df.parse(element2Data(nodes[i])));
1697             } catch (Exception e) {
1698                 _invalidDate(e);
1699             }
1700         }
1701         return (list);
1702     }
1703 
1704     public static List getElementPropertyAsDateListByStack(RStack stack, String name) {
1705         List list = new ArrayList();
1706         for (;;) {
1707             if (stack.isEmptyElement()) {
1708                 break;
1709             }
1710             Element property = stack.peekElement();
1711             if (!name.equals(property.getTagName())) {
1712                 break;
1713             }
1714             stack.popElement();
1715             String value = element2Text(property);
1716             try {
1717                 DateFormat df = DateFormat.getDateInstance();
1718                 list.add(df.parse(value));
1719             } catch (Exception e) {
1720                 _invalidDate(e);
1721             }
1722         }
1723         return (list);
1724     }
1725 
1726     // g3a
1727     public static List getElementPropertyAsDateListDataList(Element element, String name) {
1728         Element[] nodes = getElements(element, name);
1729         List list = new ArrayList();
1730         for (int i = 0; i < nodes.length; i++) {
1731             List values = getElementPropertyAsDateDataList(nodes[i]);
1732             if (values != null) {
1733                 list.add(values);
1734             }
1735         }
1736         return (list);
1737     }
1738 
1739     // g5a
1740     public static List getElementPropertyAsDateListDataListByStack(RStack stack, String name) {
1741         List list = new ArrayList();
1742         for (;;) {
1743             if (stack.isEmptyElement()) {
1744                 break;
1745             }
1746             Element property = stack.peekElement();
1747             if (!name.equals(property.getTagName())) {
1748                 break;
1749             }
1750             stack.popElement();
1751             List value = getElementPropertyAsDateDataList(property);
1752             if (value != null) {
1753                 list.add(value);
1754             }
1755         }
1756         return (list);
1757     }
1758 
1759     public static double getElementPropertyAsDouble(Element element) {
1760         try {
1761             String text = element2Data(element);
1762             return (Double.parseDouble(text));
1763         } catch (Exception e) {
1764             return (_invalidDoubleValue(e));
1765         }
1766     }
1767 
1768     public static double getElementPropertyAsDouble(Element element, String name) {
1769         try {
1770             Element property = getOnlyElement(element, name);
1771             String text = element2Data(property);
1772             return (Double.parseDouble(text));
1773         } catch (Exception e) {
1774             return (_invalidDoubleValue(e));
1775         }
1776     }
1777 
1778     public static Double getElementPropertyAsDoubleByStack(RStack stack, String name) {
1779         if (stack.isEmptyElement()) {
1780             return (null);
1781         }
1782         Element property = stack.peekElement();
1783         if (!name.equals(property.getTagName())) {
1784             return (null);
1785         }
1786         stack.popElement();
1787         return (getElementPropertyAsDoubleObject(property));
1788     }
1789 
1790     // g1u
1791     public static List getElementPropertyAsDoubleDataList(Element element) {
1792         List result = new ArrayList();
1793         List strings = getElementPropertyAsStringDataList(element);
1794         int size = strings.size();
1795         for (int i = 0; i < size; i++) {
1796             result.add(getDoubleObject((String)strings.get(i)));
1797         }
1798         return (result);
1799     }
1800 
1801     // g2a
1802     public static List getElementPropertyAsDoubleDataList(Element element, String name) {
1803         Element property = getOnlyElement(element, name);
1804         return (getElementPropertyAsDoubleDataList(property));
1805     }
1806 
1807     // g4a
1808     public static List getElementPropertyAsDoubleDataListByStack(RStack stack, String name) {
1809         if (stack.isEmptyElement()) {
1810             return (null);
1811         }
1812         Element property = stack.peekElement();
1813         if (!name.equals(property.getTagName())) {
1814             return (null);
1815         }
1816         stack.popElement();
1817         return (getElementPropertyAsDoubleDataList(property));
1818     }
1819 
1820     public static List getElementPropertyAsDoubleList(Element element) {
1821         List result = new ArrayList();
1822         List strings = getElementPropertyAsStringDataList(element);
1823         int size = strings.size();
1824         for (int i = 0; i < size; i++) {
1825             result.add(getDoubleObject((String)strings.get(i)));
1826         }
1827         return (result);
1828     }
1829 
1830     public static List getElementPropertyAsDoubleList(Element element, String name) {
1831         Element[] nodes = getElements(element, name);
1832         List list = new ArrayList();
1833         for (int i = 0; i < nodes.length; i++) {
1834             Double value = getElementPropertyAsDoubleObject(nodes[i]);
1835             if (value != null) {
1836                 list.add(value);
1837             }
1838         }
1839         return (list);
1840     }
1841 
1842     public static List getElementPropertyAsDoubleListByStack(RStack stack, String name) {
1843         List list = new ArrayList();
1844         for (;;) {
1845             if (stack.isEmptyElement()) {
1846                 break;
1847             }
1848             Element property = stack.peekElement();
1849             if (!name.equals(property.getTagName())) {
1850                 break;
1851             }
1852             stack.popElement();
1853             Double value = getElementPropertyAsDoubleObject(property);
1854             if (value != null) {
1855                 list.add(value);
1856             }
1857         }
1858         return (list);
1859     }
1860 
1861     // g3a
1862     public static List getElementPropertyAsDoubleListDataList(Element element, String name) {
1863         Element[] nodes = getElements(element, name);
1864         List list = new ArrayList();
1865         for (int i = 0; i < nodes.length; i++) {
1866             List values = getElementPropertyAsDoubleDataList(nodes[i]);
1867             if (values != null) {
1868                 list.add(values);
1869             }
1870         }
1871         return (list);
1872     }
1873 
1874     // g5a
1875     public static List getElementPropertyAsDoubleListDataListByStack(RStack stack, String name) {
1876         List list = new ArrayList();
1877         for (;;) {
1878             if (stack.isEmptyElement()) {
1879                 break;
1880             }
1881             Element property = stack.peekElement();
1882             if (!name.equals(property.getTagName())) {
1883                 break;
1884             }
1885             stack.popElement();
1886             List value = getElementPropertyAsDoubleDataList(property);
1887             if (value != null) {
1888                 list.add(value);
1889             }
1890         }
1891         return (list);
1892     }
1893 
1894     public static Double getElementPropertyAsDoubleObject(Element element) {
1895         String text = element2Data(element);
1896         return (getDoubleObject(text));
1897     }
1898 
1899     public static float getElementPropertyAsFloat(Element element) {
1900         try {
1901             String text = element2Data(element);
1902             return (Float.parseFloat(text));
1903         } catch (Exception e) {
1904             return (_invalidFloatValue(e));
1905         }
1906     }
1907 
1908     public static float getElementPropertyAsFloat(Element element, String name) {
1909         try {
1910             Element property = getOnlyElement(element, name);
1911             String text = element2Data(property);
1912             return (Float.parseFloat(text));
1913         } catch (Exception e) {
1914             return (_invalidFloatValue(e));
1915         }
1916     }
1917 
1918     public static Float getElementPropertyAsFloatByStack(RStack stack, String name) {
1919         if (stack.isEmptyElement()) {
1920             return (null);
1921         }
1922         Element property = stack.peekElement();
1923         if (!name.equals(property.getTagName())) {
1924             return (null);
1925         }
1926         stack.popElement();
1927         return (getElementPropertyAsFloatObject(property));
1928     }
1929 
1930     // g1u
1931     public static List getElementPropertyAsFloatDataList(Element element) {
1932         List result = new ArrayList();
1933         List strings = getElementPropertyAsStringDataList(element);
1934         int size = strings.size();
1935         for (int i = 0; i < size; i++) {
1936             result.add(getFloatObject((String)strings.get(i)));
1937         }
1938         return (result);
1939     }
1940 
1941     // g2a
1942     public static List getElementPropertyAsFloatDataList(Element element, String name) {
1943         Element property = getOnlyElement(element, name);
1944         return (getElementPropertyAsFloatDataList(property));
1945     }
1946 
1947     // g4a
1948     public static List getElementPropertyAsFloatDataListByStack(RStack stack, String name) {
1949         if (stack.isEmptyElement()) {
1950             return (null);
1951         }
1952         Element property = stack.peekElement();
1953         if (!name.equals(property.getTagName())) {
1954             return (null);
1955         }
1956         stack.popElement();
1957         return (getElementPropertyAsFloatDataList(property));
1958     }
1959 
1960     public static List getElementPropertyAsFloatList(Element element, String name) {
1961         Element[] nodes = getElements(element, name);
1962         List list = new ArrayList();
1963         for (int i = 0; i < nodes.length; i++) {
1964             Float value = getElementPropertyAsFloatObject(nodes[i]);
1965             if (value != null) {
1966                 list.add(value);
1967             }
1968         }
1969         return (list);
1970     }
1971 
1972     public static List getElementPropertyAsFloatListByStack(RStack stack, String name) {
1973         List list = new ArrayList();
1974         for (;;) {
1975             if (stack.isEmptyElement()) {
1976                 break;
1977             }
1978             Element property = stack.peekElement();
1979             if (!name.equals(property.getTagName())) {
1980                 break;
1981             }
1982             stack.popElement();
1983             Float value = getElementPropertyAsFloatObject(property);
1984             if (value != null) {
1985                 list.add(value);
1986             }
1987         }
1988         return (list);
1989     }
1990 
1991     // g3a
1992     public static List getElementPropertyAsFloatListDataList(Element element, String name) {
1993         Element[] nodes = getElements(element, name);
1994         List list = new ArrayList();
1995         for (int i = 0; i < nodes.length; i++) {
1996             List values = getElementPropertyAsFloatDataList(nodes[i]);
1997             if (values != null) {
1998                 list.add(values);
1999             }
2000         }
2001         return (list);
2002     }
2003 
2004     // g5a
2005     public static List getElementPropertyAsFloatListDataListByStack(RStack stack, String name) {
2006         List list = new ArrayList();
2007         for (;;) {
2008             if (stack.isEmptyElement()) {
2009                 break;
2010             }
2011             Element property = stack.peekElement();
2012             if (!name.equals(property.getTagName())) {
2013                 break;
2014             }
2015             stack.popElement();
2016             List value = getElementPropertyAsFloatDataList(property);
2017             if (value != null) {
2018                 list.add(value);
2019             }
2020         }
2021         return (list);
2022     }
2023 
2024     public static Float getElementPropertyAsFloatObject(Element element) {
2025         String text = element2Data(element);
2026         return (getFloatObject(text));
2027     }
2028 
2029     public static int getElementPropertyAsInt(Element element) {
2030         try {
2031             String text = element2Data(element);
2032             return (Integer.parseInt(text));
2033         } catch (Exception e) {
2034             return (_invalidIntValue(e));
2035         }
2036     }
2037 
2038     public static int getElementPropertyAsInt(Element element, String name) {
2039         try {
2040             Element property = getOnlyElement(element, name);
2041             String text = element2Data(property);
2042             return (Integer.parseInt(text));
2043         } catch (Exception e) {
2044             return (_invalidIntValue(e));
2045         }
2046     }
2047 
2048     public static Integer getElementPropertyAsIntByStack(RStack stack, String name) {
2049         if (stack.isEmptyElement()) {
2050             return (null);
2051         }
2052         Element property = stack.peekElement();
2053         if (!name.equals(property.getTagName())) {
2054             return (null);
2055         }
2056         stack.popElement();
2057         return (getElementPropertyAsIntObject(property));
2058     }
2059 
2060     // g1u
2061     public static List getElementPropertyAsIntDataList(Element element) {
2062         List result = new ArrayList();
2063         List strings = getElementPropertyAsStringDataList(element);
2064         int size = strings.size();
2065         for (int i = 0; i < size; i++) {
2066             result.add(getIntObject((String)strings.get(i)));
2067         }
2068         return (result);
2069     }
2070 
2071     // g2a
2072     public static List getElementPropertyAsIntDataList(Element element, String name) {
2073         Element property = getOnlyElement(element, name);
2074         return (getElementPropertyAsIntDataList(property));
2075     }
2076 
2077     // ga4
2078     public static List getElementPropertyAsIntDataListByStack(RStack stack, String name) {
2079         if (stack.isEmptyElement()) {
2080             return (null);
2081         }
2082         Element property = stack.peekElement();
2083         if (!name.equals(property.getTagName())) {
2084             return (null);
2085         }
2086         stack.popElement();
2087         return (getElementPropertyAsIntDataList(property));
2088     }
2089 
2090     public static List getElementPropertyAsIntList(Element element, String name) {
2091         Element[] nodes = getElements(element, name);
2092         List list = new ArrayList();
2093         for (int i = 0; i < nodes.length; i++) {
2094             Integer value = getElementPropertyAsIntObject(nodes[i]);
2095             if (value != null) {
2096                 list.add(value);
2097             }
2098         }
2099         return (list);
2100     }
2101 
2102     public static List getElementPropertyAsIntListByStack(RStack stack, String name) {
2103         List list = new ArrayList();
2104         for (;;) {
2105             if (stack.isEmptyElement()) {
2106                 break;
2107             }
2108             Element property = stack.peekElement();
2109             if (!name.equals(property.getTagName())) {
2110                 break;
2111             }
2112             stack.popElement();
2113             Integer value = getElementPropertyAsIntObject(property);
2114             if (value != null) {
2115                 list.add(value);
2116             }
2117         }
2118         return (list);
2119     }
2120 
2121     // g3a
2122     public static List getElementPropertyAsIntListDataList(Element element, String name) {
2123         Element[] nodes = getElements(element, name);
2124         List list = new ArrayList();
2125         for (int i = 0; i < nodes.length; i++) {
2126             List values = getElementPropertyAsIntDataList(nodes[i]);
2127             if (values != null) {
2128                 list.add(values);
2129             }
2130         }
2131         return (list);
2132     }
2133 
2134     // g5a
2135     public static List getElementPropertyAsIntListDataListByStack(RStack stack, String name) {
2136         List list = new ArrayList();
2137         for (;;) {
2138             if (stack.isEmptyElement()) {
2139                 break;
2140             }
2141             Element property = stack.peekElement();
2142             if (!name.equals(property.getTagName())) {
2143                 break;
2144             }
2145             stack.popElement();
2146             List value = getElementPropertyAsIntDataList(property);
2147             if (value != null) {
2148                 list.add(value);
2149             }
2150         }
2151         return (list);
2152     }
2153 
2154     public static Integer getElementPropertyAsIntObject(Element element) {
2155         String text = element2Data(element);
2156         return (getIntObject(text));
2157     }
2158 
2159     public static Locale getElementPropertyAsLocale(Element element) {
2160         String text = element2Data(element);
2161         return (makeLocale(text));
2162     }
2163 
2164     public static Locale getElementPropertyAsLocale(Element element, String name) {
2165         Element property = getOnlyElement(element, name);
2166         String text = element2Data(property);
2167         return (makeLocale(text));
2168     }
2169 
2170     public static Locale getElementPropertyAsLocaleByStack(RStack stack, String name) {
2171         if (stack.isEmptyElement()) {
2172             return (null);
2173         }
2174         Element property = stack.peekElement();
2175         if (!name.equals(property.getTagName())) {
2176             return (null);
2177         }
2178         stack.popElement();
2179         return (getElementPropertyAsLocale(property));
2180     }
2181 
2182     // g1u
2183     public static List getElementPropertyAsLocaleDataList(Element element) {
2184         List result = new ArrayList();
2185         List strings = getElementPropertyAsStringDataList(element);
2186         int size = strings.size();
2187         for (int i = 0; i < size; i++) {
2188             result.add(getLocaleObject((String)strings.get(i)));
2189         }
2190         return (result);
2191     }
2192 
2193     // g2a
2194     public static List getElementPropertyAsLocaleDataList(Element element, String name) {
2195         Element property = getOnlyElement(element, name);
2196         return (getElementPropertyAsLocaleDataList(property));
2197     }
2198 
2199     // g4a
2200     public static List getElementPropertyAsLocaleDataListByStack(RStack stack, String name) {
2201         if (stack.isEmptyElement()) {
2202             return (null);
2203         }
2204         Element property = stack.peekElement();
2205         if (!name.equals(property.getTagName())) {
2206             return (null);
2207         }
2208         stack.popElement();
2209         return (getElementPropertyAsLocaleDataList(property));
2210     }
2211 
2212     public static List getElementPropertyAsLocaleList(Element element, String name) {
2213         Element[] nodes = getElements(element, name);
2214         List list = new ArrayList();
2215         for (int i = 0; i < nodes.length; i++) {
2216             Locale locale = makeLocale(element2Data(nodes[i]));
2217             if (locale != null) {
2218                 list.add(locale);
2219             }
2220         }
2221         return (list);
2222     }
2223 
2224     public static List getElementPropertyAsLocaleListByStack(RStack stack, String name) {
2225         List list = new ArrayList();
2226         for (;;) {
2227             if (stack.isEmptyElement()) {
2228                 break;
2229             }
2230             Element property = stack.peekElement();
2231             if (!name.equals(property.getTagName())) {
2232                 break;
2233             }
2234             stack.popElement();
2235             Locale locale = makeLocale(element2Text(property));
2236             if (locale != null) {
2237                 list.add(locale);
2238             }
2239         }
2240         return (list);
2241     }
2242 
2243     // g3a
2244     public static List getElementPropertyAsLocaleListDataList(Element element, String name) {
2245         Element[] nodes = getElements(element, name);
2246         List list = new ArrayList();
2247         for (int i = 0; i < nodes.length; i++) {
2248             List values = getElementPropertyAsLocaleDataList(nodes[i]);
2249             if (values != null) {
2250                 list.add(values);
2251             }
2252         }
2253         return (list);
2254     }
2255 
2256     // g5a
2257     public static List getElementPropertyAsLocaleListDataListByStack(RStack stack, String name) {
2258         List list = new ArrayList();
2259         for (;;) {
2260             if (stack.isEmptyElement()) {
2261                 break;
2262             }
2263             Element property = stack.peekElement();
2264             if (!name.equals(property.getTagName())) {
2265                 break;
2266             }
2267             stack.popElement();
2268             List value = getElementPropertyAsLocaleDataList(property);
2269             if (value != null) {
2270                 list.add(value);
2271             }
2272         }
2273         return (list);
2274     }
2275 
2276     public static long getElementPropertyAsLong(Element element) {
2277         try {
2278             String text = element2Data(element);
2279             return (Long.parseLong(text));
2280         } catch (Exception e) {
2281             return (_invalidLongValue(e));
2282         }
2283     }
2284 
2285     public static long getElementPropertyAsLong(Element element, String name) {
2286         try {
2287             Element property = getOnlyElement(element, name);
2288             String text = element2Data(property);
2289             return (Long.parseLong(text));
2290         } catch (Exception e) {
2291             return (_invalidLongValue(e));
2292         }
2293     }
2294 
2295     public static Long getElementPropertyAsLongByStack(RStack stack, String name) {
2296         try {
2297             if (stack.isEmptyElement()) {
2298                 return (null);
2299             }
2300             Element property = stack.peekElement();
2301             if (!name.equals(property.getTagName())) {
2302                 return (null);
2303             }
2304             stack.popElement();
2305             return (new Long(element2Data(property)));
2306         } catch (Exception e) {
2307             return (_invalidLongObject(e));
2308         }
2309     }
2310 
2311     // g1u
2312     public static List getElementPropertyAsLongDataList(Element element) {
2313         List result = new ArrayList();
2314         List strings = getElementPropertyAsStringDataList(element);
2315         int size = strings.size();
2316         for (int i = 0; i < size; i++) {
2317             result.add(getLongObject((String)strings.get(i)));
2318         }
2319         return (result);
2320     }
2321 
2322     // g2a
2323     public static List getElementPropertyAsLongDataList(Element element, String name) {
2324         Element property = getOnlyElement(element, name);
2325         return (getElementPropertyAsLongDataList(property));
2326     }
2327 
2328     // g4a
2329     public static List getElementPropertyAsLongDataListByStack(RStack stack, String name) {
2330         if (stack.isEmptyElement()) {
2331             return (null);
2332         }
2333         Element property = stack.peekElement();
2334         if (!name.equals(property.getTagName())) {
2335             return (null);
2336         }
2337         stack.popElement();
2338         return (getElementPropertyAsLongDataList(property));
2339     }
2340 
2341     public static List getElementPropertyAsLongList(Element element, String name) {
2342         Element[] nodes = getElements(element, name);
2343         List list = new ArrayList();
2344         for (int i = 0; i < nodes.length; i++) {
2345             Long value = getElementPropertyAsLongObject(nodes[i]);
2346             if (value != null) {
2347                 list.add(value);
2348             }
2349         }
2350         return (list);
2351     }
2352 
2353     public static List getElementPropertyAsLongListByStack(RStack stack, String name) {
2354         List list = new ArrayList();
2355         for (;;) {
2356             if (stack.isEmptyElement()) {
2357                 break;
2358             }
2359             Element property = stack.peekElement();
2360             if (!name.equals(property.getTagName())) {
2361                 break;
2362             }
2363             stack.popElement();
2364             Long value = getElementPropertyAsLongObject(property);
2365             if (value != null) {
2366                 list.add(value);
2367             }
2368         }
2369         return (list);
2370     }
2371 
2372     // g3a
2373     public static List getElementPropertyAsLongListDataList(Element element, String name) {
2374         Element[] nodes = getElements(element, name);
2375         List list = new ArrayList();
2376         for (int i = 0; i < nodes.length; i++) {
2377             List values = getElementPropertyAsLongDataList(nodes[i]);
2378             if (values != null) {
2379                 list.add(values);
2380             }
2381         }
2382         return (list);
2383     }
2384 
2385     // g5a
2386     public static List getElementPropertyAsLongListDataListByStack(RStack stack, String name) {
2387         List list = new ArrayList();
2388         for (;;) {
2389             if (stack.isEmptyElement()) {
2390                 break;
2391             }
2392             Element property = stack.peekElement();
2393             if (!name.equals(property.getTagName())) {
2394                 break;
2395             }
2396             stack.popElement();
2397             List value = getElementPropertyAsLongDataList(property);
2398             if (value != null) {
2399                 list.add(value);
2400             }
2401         }
2402         return (list);
2403     }
2404 
2405     public static Long getElementPropertyAsLongObject(Element element) {
2406         String text = element2Data(element);
2407         return (getLongObject(text));
2408     }
2409 
2410     public static short getElementPropertyAsShort(Element element) {
2411         try {
2412             String text = element2Data(element);
2413             return (Short.parseShort(text));
2414         } catch (Exception e) {
2415             return (_invalidShortValue(e));
2416         }
2417     }
2418 
2419     public static short getElementPropertyAsShort(Element element, String name) {
2420         try {
2421             Element property = getOnlyElement(element, name);
2422             String text = element2Data(property);
2423             return (Short.parseShort(text));
2424         } catch (Exception e) {
2425             return (_invalidShortValue(e));
2426         }
2427     }
2428 
2429     public static Short getElementPropertyAsShortByStack(RStack stack, String name) {
2430         if (stack.isEmptyElement()) {
2431             return (null);
2432         }
2433         Element property = stack.peekElement();
2434         if (!name.equals(property.getTagName())) {
2435             return (null);
2436         }
2437         stack.popElement();
2438         return (getElementPropertyAsShortObject(property));
2439     }
2440 
2441     // g1u
2442     public static List getElementPropertyAsShortDataList(Element element) {
2443         List result = new ArrayList();
2444         List strings = getElementPropertyAsStringDataList(element);
2445         int size = strings.size();
2446         for (int i = 0; i < size; i++) {
2447             result.add(getShortObject((String)strings.get(i)));
2448         }
2449         return (result);
2450     }
2451 
2452     // g2a
2453     public static List getElementPropertyAsShortDataList(Element element, String name) {
2454         Element property = getOnlyElement(element, name);
2455         return (getElementPropertyAsShortDataList(property));
2456     }
2457 
2458     // g4a
2459     public static List getElementPropertyAsShortDataListByStack(RStack stack, String name) {
2460         if (stack.isEmptyElement()) {
2461             return (null);
2462         }
2463         Element property = stack.peekElement();
2464         if (!name.equals(property.getTagName())) {
2465             return (null);
2466         }
2467         stack.popElement();
2468         return (getElementPropertyAsShortDataList(property));
2469     }
2470 
2471     public static List getElementPropertyAsShortList(Element element, String name) {
2472         Element[] nodes = getElements(element, name);
2473         List list = new ArrayList();
2474         for (int i = 0; i < nodes.length; i++) {
2475             Short value = getElementPropertyAsShortObject(nodes[i]);
2476             if (value != null) {
2477                 list.add(value);
2478             }
2479         }
2480         return (list);
2481     }
2482 
2483     public static List getElementPropertyAsShortListByStack(RStack stack, String name) {
2484         List list = new ArrayList();
2485         for (;;) {
2486             if (stack.isEmptyElement()) {
2487                 break;
2488             }
2489             Element property = stack.peekElement();
2490             if (!name.equals(property.getTagName())) {
2491                 break;
2492             }
2493             stack.popElement();
2494             Short value = getElementPropertyAsShortObject(property);
2495             if (value != null) {
2496                 list.add(value);
2497             }
2498         }
2499         return (list);
2500     }
2501 
2502     // g3a
2503     public static List getElementPropertyAsShortListDataList(Element element, String name) {
2504         Element[] nodes = getElements(element, name);
2505         List list = new ArrayList();
2506         for (int i = 0; i < nodes.length; i++) {
2507             List values = getElementPropertyAsShortDataList(nodes[i]);
2508             if (values != null) {
2509                 list.add(values);
2510             }
2511         }
2512         return (list);
2513     }
2514 
2515     // g5a
2516     public static List getElementPropertyAsShortListDataListByStack(RStack stack, String name) {
2517         List list = new ArrayList();
2518         for (;;) {
2519             if (stack.isEmptyElement()) {
2520                 break;
2521             }
2522             Element property = stack.peekElement();
2523             if (!name.equals(property.getTagName())) {
2524                 break;
2525             }
2526             stack.popElement();
2527             List value = getElementPropertyAsShortDataList(property);
2528             if (value != null) {
2529                 list.add(value);
2530             }
2531         }
2532         return (list);
2533     }
2534 
2535     public static Short getElementPropertyAsShortObject(Element element) {
2536         String text = element2Data(element);
2537         return (getShortObject(text));
2538     }
2539 
2540     public static java.sql.Date getElementPropertyAsSQLDate(Element element) {
2541         String text = element2Data(element);
2542         return (getSQLDate(text));
2543     }
2544 
2545     public static java.sql.Date getElementPropertyAsSQLDate(Element element, String name) {
2546         Element property = getOnlyElement(element, name);
2547         String text = element2Data(property);
2548         return (getSQLDate(text));
2549     }
2550 
2551     public static java.sql.Date getElementPropertyAsSQLDateByStack(RStack stack, String name) {
2552         if (stack.isEmptyElement()) {
2553             return (null);
2554         }
2555         Element property = stack.peekElement();
2556         if (!name.equals(property.getTagName())) {
2557             return (null);
2558         }
2559         stack.popElement();
2560         return (getElementPropertyAsSQLDate(property));
2561     }
2562 
2563     // g1u
2564     public static List getElementPropertyAsSQLDateDataList(Element element) {
2565         List result = new ArrayList();
2566         List strings = getElementPropertyAsStringDataList(element);
2567         int size = strings.size();
2568         for (int i = 0; i < size; i++) {
2569             result.add(getSQLDateObject((String)strings.get(i)));
2570         }
2571         return (result);
2572     }
2573 
2574     // g2a
2575     public static List getElementPropertyAsSQLDateDataList(Element element, String name) {
2576         Element property = getOnlyElement(element, name);
2577         return (getElementPropertyAsSQLDateDataList(property));
2578     }
2579 
2580     // g4a
2581     public static List getElementPropertyAsSQLDateDataListByStack(RStack stack, String name) {
2582         if (stack.isEmptyElement()) {
2583             return (null);
2584         }
2585         Element property = stack.peekElement();
2586         if (!name.equals(property.getTagName())) {
2587             return (null);
2588         }
2589         stack.popElement();
2590         return (getElementPropertyAsSQLDateDataList(property));
2591     }
2592 
2593     public static List getElementPropertyAsSQLDateList(Element element, String name) {
2594         Element[] nodes = getElements(element, name);
2595         List list = new ArrayList();
2596         for (int i = 0; i < nodes.length; i++) {
2597             java.sql.Date date = getSQLDate(element2Data(nodes[i]));
2598             if (date != null) {
2599                 list.add(date);
2600             }
2601         }
2602         return (list);
2603     }
2604 
2605     public static List getElementPropertyAsSQLDateListByStack(RStack stack, String name) {
2606         List list = new ArrayList();
2607         for (;;) {
2608             if (stack.isEmptyElement()) {
2609                 break;
2610             }
2611             Element property = stack.peekElement();
2612             if (!name.equals(property.getTagName())) {
2613                 break;
2614             }
2615             stack.popElement();
2616             java.sql.Date date = getSQLDate(element2Data(property));
2617             if (date != null) {
2618                 list.add(date);
2619             }
2620         }
2621         return (list);
2622     }
2623 
2624     // g3a
2625     public static List getElementPropertyAsSQLDateListDataList(Element element, String name) {
2626         Element[] nodes = getElements(element, name);
2627         List list = new ArrayList();
2628         for (int i = 0; i < nodes.length; i++) {
2629             List values = getElementPropertyAsSQLDateDataList(nodes[i]);
2630             if (values != null) {
2631                 list.add(values);
2632             }
2633         }
2634         return (list);
2635     }
2636 
2637     // g5a
2638     public static List getElementPropertyAsSQLDateListDataListByStack(RStack stack, String name) {
2639         List list = new ArrayList();
2640         for (;;) {
2641             if (stack.isEmptyElement()) {
2642                 break;
2643             }
2644             Element property = stack.peekElement();
2645             if (!name.equals(property.getTagName())) {
2646                 break;
2647             }
2648             stack.popElement();
2649             List value = getElementPropertyAsSQLDateDataList(property);
2650             if (value != null) {
2651                 list.add(value);
2652             }
2653         }
2654         return (list);
2655     }
2656 
2657     public static java.sql.Time getElementPropertyAsSQLTime(Element element) {
2658         String text = element2Data(element);
2659         return (getSQLTime(text));
2660     }
2661 
2662     public static java.sql.Time getElementPropertyAsSQLTime(Element element, String name) {
2663         Element property = getOnlyElement(element, name);
2664         String text = element2Data(property);
2665         return (getSQLTime(text));
2666     }
2667 
2668     public static java.sql.Time getElementPropertyAsSQLTimeByStack(RStack stack, String name) {
2669         if (stack.isEmptyElement()) {
2670             return (null);
2671         }
2672         Element property = stack.peekElement();
2673         if (!name.equals(property.getTagName())) {
2674             return (null);
2675         }
2676         stack.popElement();
2677         return (getElementPropertyAsSQLTime(property));
2678     }
2679 
2680     // g1u
2681     public static List getElementPropertyAsSQLTimeDataList(Element element) {
2682         List result = new ArrayList();
2683         List strings = getElementPropertyAsStringDataList(element);
2684         int size = strings.size();
2685         for (int i = 0; i < size; i++) {
2686             result.add(getSQLTimeObject((String)strings.get(i)));
2687         }
2688         return (result);
2689     }
2690 
2691     // g2a
2692     public static List getElementPropertyAsSQLTimeDataList(Element element, String name) {
2693         Element property = getOnlyElement(element, name);
2694         return (getElementPropertyAsSQLTimeDataList(property));
2695     }
2696 
2697     // g4a
2698     public static List getElementPropertyAsSQLTimeDataListByStack(RStack stack, String name) {
2699         if (stack.isEmptyElement()) {
2700             return (null);
2701         }
2702         Element property = stack.peekElement();
2703         if (!name.equals(property.getTagName())) {
2704             return (null);
2705         }
2706         stack.popElement();
2707         return (getElementPropertyAsSQLTimeDataList(property));
2708     }
2709 
2710     public static List getElementPropertyAsSQLTimeList(Element element, String name) {
2711         Element[] nodes = getElements(element, name);
2712         List list = new ArrayList();
2713         for (int i = 0; i < nodes.length; i++) {
2714             java.sql.Time time = getSQLTime(element2Data(nodes[i]));
2715             if (time != null) {
2716                 list.add(time);
2717             }
2718         }
2719         return (list);
2720     }
2721 
2722     public static List getElementPropertyAsSQLTimeListByStack(RStack stack, String name) {
2723         List list = new ArrayList();
2724         for (;;) {
2725             if (stack.isEmptyElement()) {
2726                 break;
2727             }
2728             Element property = stack.peekElement();
2729             if (!name.equals(property.getTagName())) {
2730                 break;
2731             }
2732             stack.popElement();
2733             java.sql.Time time = getSQLTime(element2Data(property));
2734             if (time != null) {
2735                 list.add(time);
2736             }
2737         }
2738         return (list);
2739     }
2740 
2741     // g3a
2742     public static List getElementPropertyAsSQLTimeListDataList(Element element, String name) {
2743         Element[] nodes = getElements(element, name);
2744         List list = new ArrayList();
2745         for (int i = 0; i < nodes.length; i++) {
2746             List values = getElementPropertyAsSQLTimeDataList(nodes[i]);
2747             if (values != null) {
2748                 list.add(values);
2749             }
2750         }
2751         return (list);
2752     }
2753 
2754     // g5a
2755     public static List getElementPropertyAsSQLTimeListDataListByStack(RStack stack, String name) {
2756         List list = new ArrayList();
2757         for (;;) {
2758             if (stack.isEmptyElement()) {
2759                 break;
2760             }
2761             Element property = stack.peekElement();
2762             if (!name.equals(property.getTagName())) {
2763                 break;
2764             }
2765             stack.popElement();
2766             List value = getElementPropertyAsSQLTimeDataList(property);
2767             if (value != null) {
2768                 list.add(value);
2769             }
2770         }
2771         return (list);
2772     }
2773 
2774     public static java.sql.Timestamp getElementPropertyAsSQLTimestamp(Element element) {
2775         String text = element2Data(element);
2776         return (getSQLTimestamp(text));
2777     }
2778 
2779     public static java.sql.Timestamp getElementPropertyAsSQLTimestamp(Element element, String name) {
2780         Element property = getOnlyElement(element, name);
2781         String text = element2Data(property);
2782         return (getSQLTimestamp(text));
2783     }
2784 
2785     public static java.sql.Timestamp getElementPropertyAsSQLTimestampByStack(RStack stack, String name) {
2786         if (stack.isEmptyElement()) {
2787             return (null);
2788         }
2789         Element property = stack.peekElement();
2790         if (!name.equals(property.getTagName())) {
2791             return (null);
2792         }
2793         stack.popElement();
2794         return (getElementPropertyAsSQLTimestamp(property));
2795     }
2796 
2797     // g1u
2798     public static List getElementPropertyAsSQLTimestampDataList(Element element) {
2799         List result = new ArrayList();
2800         List strings = getElementPropertyAsStringDataList(element);
2801         int size = strings.size();
2802         for (int i = 0; i < size; i++) {
2803             result.add(getSQLTimestampObject((String)strings.get(i)));
2804         }
2805         return (result);
2806     }
2807 
2808     // g2a
2809     public static List getElementPropertyAsSQLTimestampDataList(Element element, String name) {
2810         Element property = getOnlyElement(element, name);
2811         return (getElementPropertyAsSQLTimestampDataList(property));
2812     }
2813 
2814     // g4a
2815     public static List getElementPropertyAsSQLTimestampDataListByStack(RStack stack, String name) {
2816         if (stack.isEmptyElement()) {
2817             return (null);
2818         }
2819         Element property = stack.peekElement();
2820         if (!name.equals(property.getTagName())) {
2821             return (null);
2822         }
2823         stack.popElement();
2824         return (getElementPropertyAsSQLTimestampDataList(property));
2825     }
2826 
2827     public static List getElementPropertyAsSQLTimestampList(Element element, String name) {
2828         Element[] nodes = getElements(element, name);
2829         List list = new ArrayList();
2830         for (int i = 0; i < nodes.length; i++) {
2831             java.sql.Timestamp ts = getSQLTimestamp(element2Data(nodes[i]));
2832             if (ts != null) {
2833                 list.add(ts);
2834             }
2835         }
2836         return (list);
2837     }
2838 
2839     public static List getElementPropertyAsSQLTimestampListByStack(RStack stack, String name) {
2840         List list = new ArrayList();
2841         for (;;) {
2842             if (stack.isEmptyElement()) {
2843                 break;
2844             }
2845             Element property = stack.peekElement();
2846             if (!name.equals(property.getTagName())) {
2847                 break;
2848             }
2849             stack.popElement();
2850             java.sql.Timestamp ts = getSQLTimestamp(element2Data(property));
2851             if (ts != null) {
2852                 list.add(ts);
2853             }
2854         }
2855         return (list);
2856     }
2857 
2858     // g3a
2859     public static List getElementPropertyAsSQLTimestampListDataList(Element element, String name) {
2860         Element[] nodes = getElements(element, name);
2861         List list = new ArrayList();
2862         for (int i = 0; i < nodes.length; i++) {
2863             List values = getElementPropertyAsSQLTimeDataList(nodes[i]);
2864             if (values != null) {
2865                 list.add(values);
2866             }
2867         }
2868         return (list);
2869     }
2870 
2871     // g5a
2872     public static List getElementPropertyAsSQLTimestampListDataListByStack(RStack stack, String name) {
2873         List list = new ArrayList();
2874         for (;;) {
2875             if (stack.isEmptyElement()) {
2876                 break;
2877             }
2878             Element property = stack.peekElement();
2879             if (!name.equals(property.getTagName())) {
2880                 break;
2881             }
2882             stack.popElement();
2883             List value = getElementPropertyAsSQLTimestampDataList(property);
2884             if (value != null) {
2885                 list.add(value);
2886             }
2887         }
2888         return (list);
2889     }
2890 
2891     public static String getElementPropertyAsString(Element element) {
2892         return (element2Text(element));
2893     }
2894 
2895     public static String getElementPropertyAsString(Element element, String name) {
2896         Element property = getOnlyElement(element, name);
2897         String text = element2Text(property);
2898         return (text);
2899     }
2900 
2901     public static String getElementPropertyAsStringByStack(RStack stack, String name) {
2902         if (stack.isEmptyElement()) {
2903             return (null);
2904         }
2905         Element property = stack.peekElement();
2906         if (!name.equals(property.getTagName())) {
2907             return (null);
2908         }
2909         stack.popElement();
2910         return (element2Text(property));
2911     }
2912 
2913     public static List getElementPropertyAsStringDataList(Element element) {
2914         return (makeStringList(element2Text(element)));
2915     }
2916 
2917     public static List getElementPropertyAsStringDataList(Element element, String name) {
2918         Element property = getOnlyElement(element, name);
2919         String text = element2Text(property);
2920         return (makeStringList(text));
2921     }
2922 
2923     public static List getElementPropertyAsStringDataListByStack(RStack stack, String name) {
2924         if (stack.isEmptyElement()) {
2925             return (null);
2926         }
2927         Element property = stack.peekElement();
2928         if (!name.equals(property.getTagName())) {
2929             return (null);
2930         }
2931         stack.popElement();
2932         return (makeStringList(element2Text(property)));
2933     }
2934 
2935     public static List getElementPropertyAsStringList(Element element, String name) {
2936         Element[] nodes = getElements(element, name);
2937         List list = new ArrayList();
2938         for (int i = 0; i < nodes.length; i++) {
2939             list.add(element2Text(nodes[i]));
2940         }
2941         return (list);
2942     }
2943 
2944     public static List getElementPropertyAsStringListByStack(RStack stack, String name) {
2945         List list = new ArrayList();
2946         for (;;) {
2947             if (stack.isEmptyElement()) {
2948                 break;
2949             }
2950             Element property = stack.peekElement();
2951             if (!name.equals(property.getTagName())) {
2952                 break;
2953             }
2954             stack.popElement();
2955             list.add(element2Text(property));
2956         }
2957         return (list);
2958     }
2959 
2960     public static List getElementPropertyAsStringListDataList(Element element, String name) {
2961         Element[] nodes = getElements(element, name);
2962         List list = new ArrayList();
2963         for (int i = 0; i < nodes.length; i++) {
2964             list.add(makeStringList(element2Text(nodes[i])));
2965         }
2966         return (list);
2967     }
2968 
2969     public static List getElementPropertyAsStringListDataListByStack(RStack stack, String name) {
2970         List list = new ArrayList();
2971         for (;;) {
2972             if (stack.isEmptyElement()) {
2973                 break;
2974             }
2975             Element property = stack.peekElement();
2976             if (!name.equals(property.getTagName())) {
2977                 break;
2978             }
2979             stack.popElement();
2980             list.add(makeStringList(element2Text(property)));
2981         }
2982         return (list);
2983     }
2984 
2985     public static URL getElementPropertyAsURL(Element element) {
2986         String text = element2Data(element);
2987         return (makeURL4Property(text));
2988     }
2989 
2990     public static URL getElementPropertyAsURL(Element element, String name) {
2991         Element property = getOnlyElement(element, name);
2992         String text = element2Data(property);
2993         return (makeURL4Property(text));
2994     }
2995 
2996     public static URL getElementPropertyAsURLByStack(RStack stack, String name) {
2997         if (stack.isEmptyElement()) {
2998             return (null);
2999         }
3000         Element property = stack.peekElement();
3001         if (!name.equals(property.getTagName())) {
3002             return (null);
3003         }
3004         stack.popElement();
3005         return (getElementPropertyAsURL(property));
3006     }
3007 
3008     // g1u
3009     public static List getElementPropertyAsURLDataList(Element element) {
3010         List result = new ArrayList();
3011         List strings = getElementPropertyAsStringDataList(element);
3012         int size = strings.size();
3013         for (int i = 0; i < size; i++) {
3014             result.add(getURLObject((String)strings.get(i)));
3015         }
3016         return (result);
3017     }
3018 
3019     // g2a
3020     public static List getElementPropertyAsURLDataList(Element element, String name) {
3021         Element property = getOnlyElement(element, name);
3022         return (getElementPropertyAsURLDataList(property));
3023     }
3024 
3025     // g4a
3026     public static List getElementPropertyAsURLDataListByStack(RStack stack, String name) {
3027         if (stack.isEmptyElement()) {
3028             return (null);
3029         }
3030         Element property = stack.peekElement();
3031         if (!name.equals(property.getTagName())) {
3032             return (null);
3033         }
3034         stack.popElement();
3035         return (getElementPropertyAsURLDataList(property));
3036     }
3037 
3038     public static List getElementPropertyAsURLList(Element element, String name) {
3039         Element[] nodes = getElements(element, name);
3040         List list = new ArrayList();
3041         for (int i = 0; i < nodes.length; i++) {
3042             URL url = makeURL4Property(element2Data(nodes[i]));
3043             if (url != null) {
3044                 list.add(url);
3045             }
3046         }
3047         return (list);
3048     }
3049 
3050     public static List getElementPropertyAsURLListByStack(RStack stack, String name) {
3051         List list = new ArrayList();
3052         for (;;) {
3053             if (stack.isEmptyElement()) {
3054                 break;
3055             }
3056             Element property = stack.peekElement();
3057             if (!name.equals(property.getTagName())) {
3058                 break;
3059             }
3060             stack.popElement();
3061             URL url = makeURL4Property(element2Text(property));
3062             if (url != null) {
3063                 list.add(url);
3064             }
3065         }
3066         return (list);
3067     }
3068 
3069     // g3a
3070     public static List getElementPropertyAsURLListDataList(Element element, String name) {
3071         Element[] nodes = getElements(element, name);
3072         List list = new ArrayList();
3073         for (int i = 0; i < nodes.length; i++) {
3074             List values = getElementPropertyAsURLDataList(nodes[i]);
3075             if (values != null) {
3076                 list.add(values);
3077             }
3078         }
3079         return (list);
3080     }
3081 
3082     // g5a
3083     public static List getElementPropertyAsURLListDataListByStack(RStack stack, String name) {
3084         List list = new ArrayList();
3085         for (;;) {
3086             if (stack.isEmptyElement()) {
3087                 break;
3088             }
3089             Element property = stack.peekElement();
3090             if (!name.equals(property.getTagName())) {
3091                 break;
3092             }
3093             stack.popElement();
3094             List value = getElementPropertyAsURLDataList(property);
3095             if (value != null) {
3096                 list.add(value);
3097             }
3098         }
3099         return (list);
3100     }
3101 
3102     public static String getElementPropertyAsValue(Element element, String typeName) {
3103         if ("string".equals(typeName)) {
3104             return (getElementPropertyAsString(element));
3105         } else {
3106             return (getElementPropertyAsValueData(element));
3107         }
3108     }
3109 
3110     public static String getElementPropertyAsValue(Element element, String slotName, String typeName) {
3111         if ("string".equals(typeName)) {
3112             return (getElementPropertyAsString(element, slotName));
3113         } else {
3114             return (getElementPropertyAsValueData(element, slotName));
3115         }
3116     }
3117 
3118     public static String getElementPropertyAsValueData(Element element) {
3119         return (getElementPropertyAsString(element).trim());
3120     }
3121 
3122     public static String getElementPropertyAsValueData(Element element, String slotName) {
3123         return (getElementPropertyAsString(element, slotName).trim());
3124     }
3125 
3126     public static Element[] getElements(Element element) {
3127         NodeList children = element.getChildNodes();
3128         List list = new ArrayList();
3129         int size = children.getLength();
3130         for (int i = 0; i < size; i++) {
3131             Node child = children.item(i);
3132             if (child.getNodeType() == Node.ELEMENT_NODE) {
3133                 list.add(child);
3134             }
3135         }
3136         Element[] array = new Element[list.size()];
3137         return ((Element[])list.toArray(array));
3138     }
3139 
3140     public static Element[] getElements(Element element, String name) {
3141         NodeList children = element.getChildNodes();
3142         List list = new ArrayList();
3143         int size = children.getLength();
3144         for (int i = 0; i < size; i++) {
3145             Node child = children.item(i);
3146             if (child.getNodeType() == Node.ELEMENT_NODE) {
3147                 Element childElement = (Element)child;
3148                 if (name.equals(childElement.getTagName())) {
3149                     list.add(childElement);
3150                 }
3151             }
3152         }
3153         Element[] array = new Element[list.size()];
3154         return ((Element[])list.toArray(array));
3155     }
3156 
3157     public static Stack getElementsAsStack(Element element) {
3158         NodeList children = element.getChildNodes();
3159         Stack stack = new Stack();
3160         int size = children.getLength();
3161         for (int i = size - 1; i >= 0; i--) {
3162             Node child = children.item(i);
3163             if (child.getNodeType() == Node.ELEMENT_NODE) {
3164                 stack.push(children.item(i));
3165             }
3166         }
3167         return (stack);
3168     }
3169 
3170     public static Float getFloatObject(String text) {
3171         try {
3172             return (new Float(text));
3173         } catch (Exception e) {
3174             return (_invalidFloatObject(e));
3175         }
3176     }
3177 
3178     public static Float[] getFloatObjectList(String text) {
3179         String[] strings = getStringList(text);
3180         Float[] list = new Float[strings.length];
3181         for (int i = 0; i < strings.length; i++) {
3182             list[i] = getFloatObject(strings[i]);
3183         }
3184         return (list);
3185     }
3186 
3187     public static float getFloatValue(Object value) {
3188         try {
3189             Number object;
3190             if (value instanceof Number) {
3191                 object = (Number)value;
3192             } else {
3193                 object = new Float(value.toString());
3194             }
3195             return (object.floatValue());
3196         } catch (Exception e) {
3197             return (_invalidFloatValue(e));
3198         }
3199     }
3200 
3201     public static Integer getIntObject(String text) {
3202         try {
3203             return (new Integer(text));
3204         } catch (Exception e) {
3205             return (_invalidIntegerObject(e));
3206         }
3207     }
3208 
3209     public static Integer[] getIntObjectList(String text) {
3210         String[] strings = getStringList(text);
3211         Integer[] list = new Integer[strings.length];
3212         for (int i = 0; i < strings.length; i++) {
3213             list[i] = getIntObject(strings[i]);
3214         }
3215         return (list);
3216     }
3217 
3218     public static int getIntValue(Object value) {
3219         try {
3220             Number object;
3221             if (value instanceof Number) {
3222                 object = (Number)value;
3223             } else {
3224                 object = new Integer(value.toString());
3225             }
3226             return (object.intValue());
3227         } catch (Exception e) {
3228             return (_invalidIntValue(e));
3229         }
3230     }
3231 
3232     public static Locale getLocale(String value) {
3233         if (value == null) {
3234             return (null);
3235         }
3236         return (makeLocale(value));
3237     }
3238 
3239     public static Locale[] getLocaleList(String text) {
3240         String[] strings = getStringList(text);
3241         Locale[] list = new Locale[strings.length];
3242         for (int i = 0; i < strings.length; i++) {
3243             list[i] = getLocale(strings[i]);
3244         }
3245         return (list);
3246     }
3247 
3248     public static Locale getLocaleObject(Object value) {
3249         if (value instanceof Locale) {
3250             return ((Locale)value);
3251         } else {
3252             return (makeLocale(value.toString()));
3253         }
3254     }
3255 
3256     public static Long getLongObject(String text) {
3257         try {
3258             return (new Long(text));
3259         } catch (Exception e) {
3260             return (_invalidLongObject(e));
3261         }
3262     }
3263 
3264     public static Long[] getLongObjectList(String text) {
3265         String[] strings = getStringList(text);
3266         Long[] list = new Long[strings.length];
3267         for (int i = 0; i < strings.length; i++) {
3268             list[i] = getLongObject(strings[i]);
3269         }
3270         return (list);
3271     }
3272 
3273     public static long getLongValue(Object value) {
3274         try {
3275             Number object;
3276             if (value instanceof Number) {
3277                 object = (Number)value;
3278             } else {
3279                 object = new Long(value.toString());
3280             }
3281             return (object.longValue());
3282         } catch (Exception e) {
3283             return (_invalidLongValue(e));
3284         }
3285     }
3286 
3287     public static String getNSMapping(String prefix, String uri) {
3288         if (prefix == null) {
3289             return ("");
3290         }
3291         if ("".equals(prefix)) {
3292             return (" xmlns=\"" + uri + "\"");
3293         }
3294         return (" xmlns:" + prefix + "=\"" + uri + "\"");
3295     }
3296 
3297     public static Element getOnlyElement(Element element, String name)
3298                                   throws IllegalArgumentException {
3299 
3300         Element[] nodes = getElements(element, name);
3301         switch (nodes.length) {
3302 
3303             case 0: {
3304                 return (null);
3305             }
3306             case 1: {
3307                 break;
3308             }
3309             default:
3310             {
3311                 throw (new IllegalArgumentException());
3312             }
3313         }
3314         return (nodes[0]);
3315     }
3316 
3317     // JavaBeans
3318 
3319     public static Object getPropertyObject(String value) {
3320         return (value);
3321     }
3322 
3323     public static Object getPropertyObject(boolean value) {
3324         return (new Boolean(value));
3325     }
3326 
3327     public static Object getPropertyObject(byte value) {
3328         return (new Byte(value));
3329     }
3330 
3331     public static Object getPropertyObject(short value) {
3332         return (new Short(value));
3333     }
3334 
3335     public static Object getPropertyObject(int value) {
3336         return (new Integer(value));
3337     }
3338 
3339     public static Object getPropertyObject(long value) {
3340         return (new Long(value));
3341     }
3342 
3343     public static Object getPropertyObject(float value) {
3344         return (new Float(value));
3345     }
3346 
3347     public static Object getPropertyObject(double value) {
3348         return (new Double(value));
3349     }
3350 
3351     public static Object getPropertyObject(Object value) {
3352         return (value);
3353     }
3354 
3355     public static Object getPropertyObject(Collection value) {
3356         return (value.toArray());
3357     }
3358 
3359     public static String getQName(String prefix, String localName) {
3360         if (prefix == null) {
3361             return (localName);
3362         } else if ("".equals(prefix)) {
3363             return (localName);
3364         } else {
3365             return (prefix + ":" + localName);
3366         }
3367     }
3368 
3369     public static Short getShortObject(String text) {
3370         try {
3371             return (new Short(text));
3372         } catch (Exception e) {
3373             return (_invalidShortObject(e));
3374         }
3375     }
3376 
3377     public static Short[] getShortObjectList(String text) {
3378         String[] strings = getStringList(text);
3379         Short[] list = new Short[strings.length];
3380         for (int i = 0; i < strings.length; i++) {
3381             list[i] = getShortObject(strings[i]);
3382         }
3383         return (list);
3384     }
3385 
3386     public static short getShortValue(Object value) {
3387         try {
3388             Number object;
3389             if (value instanceof Number) {
3390                 object = (Number)value;
3391             } else {
3392                 object = new Short(value.toString());
3393             }
3394             return (object.shortValue());
3395         } catch (Exception e) {
3396             return (_invalidShortValue(e));
3397         }
3398     }
3399 
3400     public static java.sql.Date getSQLDate(String value) {
3401         try {
3402             return (java.sql.Date.valueOf(value));
3403         } catch (Exception e) {
3404             return (_invalidSQLDate(e));
3405         }
3406     }
3407 
3408     public static java.sql.Date[] getSQLDateList(String text) {
3409         String[] strings = getStringList(text);
3410         java.sql.Date[] list = new java.sql.Date[strings.length];
3411         for (int i = 0; i < strings.length; i++) {
3412             list[i] = getSQLDate(strings[i]);
3413         }
3414         return (list);
3415     }
3416 
3417     public static java.sql.Date getSQLDateObject(Object value) {
3418         if (value instanceof java.sql.Date) {
3419             return ((java.sql.Date)value);
3420         } else {
3421             return (getSQLDate(value.toString()));
3422         }
3423     }
3424 
3425     public static java.sql.Time getSQLTime(String value) {
3426         try {
3427             return (java.sql.Time.valueOf(value));
3428         } catch (Exception e) {
3429             return (_invalidSQLTime(e));
3430         }
3431     }
3432 
3433     public static java.sql.Time[] getSQLTimeList(String text) {
3434         String[] strings = getStringList(text);
3435         java.sql.Time[] list = new java.sql.Time[strings.length];
3436         for (int i = 0; i < strings.length; i++) {
3437             list[i] = getSQLTime(strings[i]);
3438         }
3439         return (list);
3440     }
3441 
3442     public static java.sql.Time getSQLTimeObject(Object value) {
3443         if (value instanceof java.sql.Time) {
3444             return ((java.sql.Time)value);
3445         } else {
3446             return (getSQLTime(value.toString()));
3447         }
3448     }
3449 
3450     public static java.sql.Timestamp getSQLTimestamp(String value) {
3451         try {
3452             return (java.sql.Timestamp.valueOf(value.trim().replace('T', ' ')));
3453         } catch (Exception e) {
3454             return (_invalidSQLTimestamp(e));
3455         }
3456     }
3457 
3458     public static java.sql.Timestamp[] getSQLTimestampList(String text) {
3459         String[] strings = getStringList(text);
3460         java.sql.Timestamp[] list = new java.sql.Timestamp[strings.length];
3461         for (int i = 0; i < strings.length; i++) {
3462             list[i] = getSQLTimestamp(strings[i]);
3463         }
3464         return (list);
3465     }
3466 
3467     public static java.sql.Timestamp getSQLTimestampObject(Object value) {
3468         if (value instanceof java.sql.Timestamp) {
3469             return ((java.sql.Timestamp)value);
3470         } else {
3471             return (getSQLTimestamp(value.toString()));
3472         }
3473     }
3474 
3475     // String type
3476     public static String getString(String value) {
3477         return (value);
3478     }
3479 
3480     public static String getString(String[] values) {
3481         if (values == null) {
3482             return (null);
3483         }
3484         StringBuffer buffer = new StringBuffer();
3485         if (values.length > 0) {
3486             buffer.append(values[0]);
3487             for (int i = 1; i < values.length; i++) {
3488                 buffer.append(" ");
3489                 buffer.append(values[i]);
3490             }
3491         }
3492         return (new String(buffer));
3493     }
3494 
3495     public static String getString(List values) {
3496         if (values == null) {
3497             return (null);
3498         }
3499         int size = values.size();
3500         StringBuffer buffer = new StringBuffer();
3501         if (size > 0) {
3502             buffer.append(getString(values.get(0)));
3503             for (int i = 1; i < size; i++) {
3504                 buffer.append(" ");
3505                 buffer.append(getString(values.get(i)));
3506             }
3507         }
3508         return (new String(buffer));
3509     }
3510 
3511     // boolean type
3512     public static String getString(boolean value) {
3513         if (value) {
3514             return ("true");
3515         } else {
3516             return ("false");
3517         }
3518     }
3519 
3520     public static String getString(Boolean value) {
3521         if (value == null) {
3522             return (null);
3523         }
3524         return (value.toString());
3525     }
3526 
3527     public static String getString(boolean[] values) {
3528         if (values == null) {
3529             return (null);
3530         }
3531         StringBuffer buffer = new StringBuffer();
3532         if (values.length > 0) {
3533             if (values[0]) {
3534                 buffer.append("true");
3535             } else {
3536                 buffer.append("false");
3537             }
3538             for (int i = 1; i < values.length; i++) {
3539                 buffer.append(" ");
3540                 if (values[i]) {
3541                     buffer.append("true");
3542                 } else {
3543                     buffer.append("false");
3544                 }
3545             }
3546         }
3547         return (new String(buffer));
3548     }
3549 
3550     public static String getString(Boolean[] values) {
3551         if (values == null) {
3552             return (null);
3553         }
3554         StringBuffer buffer = new StringBuffer();
3555         if (values.length > 0) {
3556             buffer.append(values[0].toString());
3557             for (int i = 1; i < values.length; i++) {
3558                 buffer.append(" ");
3559                 buffer.append(values[i].toString());
3560             }
3561         }
3562         return (new String(buffer));
3563     }
3564 
3565     // byte type
3566     public static String getString(byte value) {
3567         return (Byte.toString(value));
3568     }
3569 
3570     public static String getString(Byte value) {
3571         if (value == null) {
3572             return (null);
3573         }
3574         return (value.toString());
3575     }
3576 
3577     public static String getString(byte[] values) {
3578         if (values == null) {
3579             return (null);
3580         }
3581         StringBuffer buffer = new StringBuffer();
3582         if (values.length > 0) {
3583             buffer.append(values[0]);
3584             for (int i = 1; i < values.length; i++) {
3585                 buffer.append(" ");
3586                 buffer.append(values[i]);
3587             }
3588         }
3589         return (new String(buffer));
3590     }
3591 
3592     public static String getString(Byte[] values) {
3593         if (values == null) {
3594             return (null);
3595         }
3596         StringBuffer buffer = new StringBuffer();
3597         if (values.length > 0) {
3598             buffer.append(values[0].toString());
3599             for (int i = 1; i < values.length; i++) {
3600                 buffer.append(" ");
3601                 buffer.append(values[i].toString());
3602             }
3603         }
3604         return (new String(buffer));
3605     }
3606 
3607     // short type
3608     public static String getString(short value) {
3609         return (Short.toString(value));
3610     }
3611 
3612     public static String getString(Short value) {
3613         if (value == null) {
3614             return (null);
3615         }
3616         return (value.toString());
3617     }
3618 
3619     public static String getString(short[] values) {
3620         if (values == null) {
3621             return (null);
3622         }
3623         StringBuffer buffer = new StringBuffer();
3624         if (values.length > 0) {
3625             buffer.append(values[0]);
3626             for (int i = 1; i < values.length; i++) {
3627                 buffer.append(" ");
3628                 buffer.append(values[i]);
3629             }
3630         }
3631         return (new String(buffer));
3632     }
3633 
3634     public static String getString(Short[] values) {
3635         if (values == null) {
3636             return (null);
3637         }
3638         StringBuffer buffer = new StringBuffer();
3639         if (values.length > 0) {
3640             buffer.append(values[0].toString());
3641             for (int i = 1; i < values.length; i++) {
3642                 buffer.append(" ");
3643                 buffer.append(values[i].toString());
3644             }
3645         }
3646         return (new String(buffer));
3647     }
3648 
3649     // int type
3650     public static String getString(int value) {
3651         return (Integer.toString(value));
3652     }
3653 
3654     public static String getString(Integer value) {
3655         if (value == null) {
3656             return (null);
3657         }
3658         return (value.toString());
3659     }
3660 
3661     public static String getString(int[] values) {
3662         if (values == null) {
3663             return (null);
3664         }
3665         StringBuffer buffer = new StringBuffer();
3666         if (values.length > 0) {
3667             buffer.append(values[0]);
3668             for (int i = 1; i < values.length; i++) {
3669                 buffer.append(" ");
3670                 buffer.append(values[i]);
3671             }
3672         }
3673         return (new String(buffer));
3674     }
3675 
3676     public static String getString(Integer[] values) {
3677         if (values == null) {
3678             return (null);
3679         }
3680         StringBuffer buffer = new StringBuffer();
3681         if (values.length > 0) {
3682             buffer.append(values[0].toString());
3683             for (int i = 1; i < values.length; i++) {
3684                 buffer.append(" ");
3685                 buffer.append(values[i].toString());
3686             }
3687         }
3688         return (new String(buffer));
3689     }
3690 
3691     // long type
3692     public static String getString(long value) {
3693         return (Long.toString(value));
3694     }
3695 
3696     public static String getString(Long value) {
3697         if (value == null) {
3698             return (null);
3699         }
3700         return (value.toString());
3701     }
3702 
3703     public static String getString(long[] values) {
3704         if (values == null) {
3705             return (null);
3706         }
3707         StringBuffer buffer = new StringBuffer();
3708         if (values.length > 0) {
3709             buffer.append(values[0]);
3710             for (int i = 1; i < values.length; i++) {
3711                 buffer.append(" ");
3712                 buffer.append(values[i]);
3713             }
3714         }
3715         return (new String(buffer));
3716     }
3717 
3718     public static String getString(Long[] values) {
3719         if (values == null) {
3720             return (null);
3721         }
3722         StringBuffer buffer = new StringBuffer();
3723         if (values.length > 0) {
3724             buffer.append(values[0].toString());
3725             for (int i = 1; i < values.length; i++) {
3726                 buffer.append(" ");
3727                 buffer.append(values[i].toString());
3728             }
3729         }
3730         return (new String(buffer));
3731     }
3732 
3733     // float type
3734     public static String getString(float value) {
3735         return (Float.toString(value));
3736     }
3737 
3738     public static String getString(Float value) {
3739         if (value == null) {
3740             return (null);
3741         }
3742         return (value.toString());
3743     }
3744 
3745     public static String getString(float[] values) {
3746         if (values == null) {
3747             return (null);
3748         }
3749         StringBuffer buffer = new StringBuffer();
3750         if (values.length > 0) {
3751             buffer.append(values[0]);
3752             for (int i = 1; i < values.length; i++) {
3753                 buffer.append(" ");
3754                 buffer.append(values[i]);
3755             }
3756         }
3757         return (new String(buffer));
3758     }
3759 
3760     public static String getString(Float[] values) {
3761         if (values == null) {
3762             return (null);
3763         }
3764         StringBuffer buffer = new StringBuffer();
3765         if (values.length > 0) {
3766             buffer.append(values[0].toString());
3767             for (int i = 1; i < values.length; i++) {
3768                 buffer.append(" ");
3769                 buffer.append(values[i].toString());
3770             }
3771         }
3772         return (new String(buffer));
3773     }
3774 
3775     // double type
3776     public static String getString(double value) {
3777         return (Double.toString(value));
3778     }
3779 
3780     public static String getString(Double value) {
3781         if (value == null) {
3782             return (null);
3783         }
3784         return (value.toString());
3785     }
3786 
3787     public static String getString(double[] values) {
3788         if (values == null) {
3789             return (null);
3790         }
3791         StringBuffer buffer = new StringBuffer();
3792         if (values.length > 0) {
3793             buffer.append(values[0]);
3794             for (int i = 1; i < values.length; i++) {
3795                 buffer.append(" ");
3796                 buffer.append(values[i]);
3797             }
3798         }
3799         return (new String(buffer));
3800     }
3801 
3802     public static String getString(Double[] values) {
3803         if (values == null) {
3804             return (null);
3805         }
3806         StringBuffer buffer = new StringBuffer();
3807         if (values.length > 0) {
3808             buffer.append(values[0].toString());
3809             for (int i = 1; i < values.length; i++) {
3810                 buffer.append(" ");
3811                 buffer.append(values[i].toString());
3812             }
3813         }
3814         return (new String(buffer));
3815     }
3816 
3817     // BigDecimal type
3818     public static String getString(BigDecimal value) {
3819         if (value == null) {
3820             return (null);
3821         }
3822         return (value.toString());
3823     }
3824 
3825     public static String getString(BigDecimal[] values) {
3826         if (values == null) {
3827             return (null);
3828         }
3829         StringBuffer buffer = new StringBuffer();
3830         if (values.length > 0) {
3831             buffer.append(values[0].toString());
3832             for (int i = 1; i < values.length; i++) {
3833                 buffer.append(" ");
3834                 buffer.append(values[i].toString());
3835             }
3836         }
3837         return (new String(buffer));
3838     }
3839 
3840     // BigInteger type
3841     public static String getString(BigInteger value) {
3842         if (value == null) {
3843             return (null);
3844         }
3845         return (value.toString());
3846     }
3847 
3848     public static String getString(BigInteger[] values) {
3849         if (values == null) {
3850             return (null);
3851         }
3852         StringBuffer buffer = new StringBuffer();
3853         if (values.length > 0) {
3854             buffer.append(values[0].toString());
3855             for (int i = 1; i < values.length; i++) {
3856                 buffer.append(" ");
3857                 buffer.append(values[i].toString());
3858             }
3859         }
3860         return (new String(buffer));
3861     }
3862 
3863     // Date type
3864     public static String getString(Date value) {
3865         if (value == null) {
3866             return (null);
3867         }
3868         return (getString(new java.sql.Timestamp(value.getTime())));
3869     }
3870 
3871     public static String getString(Date[] values) {
3872         if (values == null) {
3873             return (null);
3874         }
3875         StringBuffer buffer = new StringBuffer();
3876         if (values.length > 0) {
3877             buffer.append(values[0].toString());
3878             for (int i = 1; i < values.length; i++) {
3879                 buffer.append(" ");
3880                 buffer.append(values[i].toString());
3881             }
3882         }
3883         return (new String(buffer));
3884     }
3885 
3886     // Locale type
3887     public static String getString(Locale value) {
3888         return (value.toString());
3889     }
3890 
3891     public static String getString(Locale[] values) {
3892         if (values == null) {
3893             return (null);
3894         }
3895         StringBuffer buffer = new StringBuffer();
3896         if (values.length > 0) {
3897             buffer.append(values[0].toString());
3898             for (int i = 1; i < values.length; i++) {
3899                 buffer.append(" ");
3900                 buffer.append(values[i].toString());
3901             }
3902         }
3903         return (new String(buffer));
3904     }
3905 
3906     // URL type
3907     public static String getString(URL value) {
3908         if (value == null) {
3909             return (null);
3910         }
3911         return (value.toExternalForm());
3912     }
3913 
3914     public static String getString(URL[] values) {
3915         if (values == null) {
3916             return (null);
3917         }
3918         StringBuffer buffer = new StringBuffer();
3919         if (values.length > 0) {
3920             buffer.append(getString(values[0]));
3921             for (int i = 1; i < values.length; i++) {
3922                 buffer.append(" ");
3923                 buffer.append(getString(values[i]));
3924             }
3925         }
3926         return (new String(buffer));
3927     }
3928 
3929     // SQL Timestamp type
3930     public static String getString(java.sql.Timestamp value) {
3931         if (value == null) {
3932             return (null);
3933         }
3934         return (adjustTime_(value.toString().replace(' ', 'T')));
3935     }
3936 
3937     public static String getString(java.sql.Timestamp[] values) {
3938         if (values == null) {
3939             return (null);
3940         }
3941         StringBuffer buffer = new StringBuffer();
3942         if (values.length > 0) {
3943             buffer.append(getString(values[0]));
3944             for (int i = 1; i < values.length; i++) {
3945                 buffer.append(" ");
3946                 buffer.append(getString(values[i]));
3947             }
3948         }
3949         return (new String(buffer));
3950     }
3951 
3952     // SQL Time type
3953     public static String getString(java.sql.Time value) {
3954         if (value == null) {
3955             return (null);
3956         }
3957         return (adjustTime_(value.toString()));
3958     }
3959 
3960     public static String getString(java.sql.Time[] values) {
3961         if (values == null) {
3962             return (null);
3963         }
3964         StringBuffer buffer = new StringBuffer();
3965         if (values.length > 0) {
3966             buffer.append(values[0].toString());
3967             for (int i = 1; i < values.length; i++) {
3968                 buffer.append(" ");
3969                 buffer.append(values[i].toString());
3970             }
3971         }
3972         return (new String(buffer));
3973     }
3974 
3975     // SQL Date type
3976     public static String getString(java.sql.Date value) {
3977         if (value == null) {
3978             return (null);
3979         }
3980         return (value.toString());
3981     }
3982 
3983     public static String getString(java.sql.Date[] values) {
3984         if (values == null) {
3985             return (null);
3986         }
3987         StringBuffer buffer = new StringBuffer();
3988         if (values.length > 0) {
3989             buffer.append(values[0].toString());
3990             for (int i = 1; i < values.length; i++) {
3991                 buffer.append(" ");
3992                 buffer.append(values[i].toString());
3993             }
3994         }
3995         return (new String(buffer));
3996     }
3997 
3998     // Relaxer object
3999     public static String getString(Object object) {
4000         if (object instanceof java.sql.Timestamp) {
4001             return (getString((java.sql.Timestamp)object));
4002         } else if (object instanceof java.sql.Time) {
4003             return (getString((java.sql.Time)object));
4004         } else if (object instanceof java.sql.Date) {
4005             return (getString((java.sql.Date)object));
4006         } else if (object instanceof Date) {
4007             return (getString((Date)object));
4008         } else {
4009             return (object.toString());
4010         }
4011     }
4012 
4013     public static String[] getStringArray(String value) {
4014         return (getStringList(value));
4015     }
4016 
4017     public static String[] getStringArrayObject(Object value) {
4018         if (value instanceof String[]) {
4019             return ((String[])value);
4020         } else if (value instanceof Object[]) {
4021             Object[] values = (Object[])value;
4022             String[] result = new String[values.length];
4023             for (int i = 0; i < values.length; i++) {
4024                 result[i] = values[i].toString();
4025             }
4026             return (result);
4027         } else {
4028             return (getStringArray(value.toString()));
4029         }
4030     }
4031 
4032     // HEX type
4033     public static String getStringByBinaryHEX(byte[] bytes) {
4034         if (bytes == null) {
4035             return (null);
4036         }
4037         return (makeStringAsHEX(bytes));
4038     }
4039 
4040     public static String getStringByBinaryHEX(byte[][] value) {
4041         if (value == null) {
4042             return (null);
4043         }
4044         if (value.length == 0) {
4045             return ("");
4046         }
4047         StringBuffer buffer = new StringBuffer();
4048         buffer.append(makeStringAsHEX(value[0]));
4049         for (int i = 1; i < value.length; i++) {
4050             buffer.append(" ");
4051             buffer.append(makeStringAsHEX(value[i]));
4052         }
4053         return (new String(buffer));
4054     }
4055 
4056     public static String getStringByMixedList(List list) {    
4057         StringBuffer buffer = new StringBuffer();
4058         int size = list.size();
4059         for (int i = 0; i < size; i++) {
4060             Object object = list.get(i);
4061             if (object.getClass().getName().endsWith("RString")) {
4062                 buffer.append(object.toString());
4063             }
4064         }
4065         return (new String(buffer));
4066     }
4067 
4068     public static String[] getStringList(String value) {    
4069         StringTokenizer st = new StringTokenizer(value);
4070         String[] list = new String[st.countTokens()];
4071         int i = 0;
4072         while (st.hasMoreTokens()) {
4073             list[i++] = st.nextToken();
4074         }
4075         return (list);
4076     }
4077 
4078     public static URL getURL(String value) {
4079         return (makeURL4Property(value));
4080     }
4081 
4082     public static URL[] getURLList(String text) {
4083         String[] strings = getStringList(text);
4084         URL[] list = new URL[strings.length];
4085         for (int i = 0; i < strings.length; i++) {
4086             list[i] = getURL(strings[i]);
4087         }
4088         return (list);
4089     }
4090 
4091     public static URL getURLObject(Object value) {
4092         if (value instanceof URL) {
4093             return ((URL)value);
4094         } else {
4095             return (makeURL4Property(value.toString()));
4096         }
4097     }
4098 
4099     public static void setAttributePropertyByBigDecimal(Element element, String name, BigDecimal value) {
4100         if (value != null) {
4101             element.setAttribute(name, value.toString());
4102         }
4103     }
4104 
4105     public static void setAttributePropertyByBigDecimalList(Element element, String name, List values) {
4106         if (values == null) {
4107             return;
4108         }
4109         StringBuffer buffer = new StringBuffer();
4110         int size = values.size();
4111         if (size > 0) {
4112             buffer.append(values.get(0).toString());
4113             for (int i = 1; i < size; i++) {
4114                 buffer.append(" ");
4115                 buffer.append(values.get(i).toString());
4116             }
4117         }
4118         element.setAttribute(name, new String(buffer));
4119     }
4120 
4121     public static void setAttributePropertyByBigInteger(Element element, String name, BigInteger value) {
4122         if (value != null) {
4123             element.setAttribute(name, value.toString());
4124         }
4125     }
4126 
4127     public static void setAttributePropertyByBigIntegerList(Element element, String name, List values) {
4128         if (values == null) {
4129             return;
4130         }
4131         StringBuffer buffer = new StringBuffer();
4132         int size = values.size();
4133         if (size > 0) {
4134             buffer.append(values.get(0).toString());
4135             for (int i = 1; i < size; i++) {
4136                 buffer.append(" ");
4137                 buffer.append(values.get(i).toString());
4138             }
4139         }
4140         element.setAttribute(name, new String(buffer));
4141     }
4142 
4143     public static void setAttributePropertyByBinaryBASE64(Element element, String name, byte[] value) {
4144         if (value != null) {
4145             element.setAttribute(name, makeStringAsBASE64(value));
4146         }
4147     }
4148 
4149     public static void setAttributePropertyByBinaryBASE64List(Element element, String name, List values) {
4150         if (values == null) {
4151             return;
4152         }
4153         StringBuffer buffer = new StringBuffer();
4154         int size = values.size();
4155         if (size > 0) {
4156             buffer.append(makeStringAsBASE64((byte[])values.get(0)));
4157             for (int i = 1; i < size; i++) {
4158                 buffer.append(" ");
4159                 buffer.append(makeStringAsBASE64((byte[])values.get(i)));
4160             }
4161         }
4162         element.setAttribute(name, new String(buffer));
4163     }
4164 
4165     public static void setAttributePropertyByBinaryHEX(Element element, String name, byte[] value) {
4166         if (value != null) {
4167             element.setAttribute(name, makeStringAsHEX(value));
4168         }
4169     }
4170 
4171     public static void setAttributePropertyByBinaryHEXList(Element element, String name, List values) {
4172         if (values == null) {
4173             return;
4174         }
4175         StringBuffer buffer = new StringBuffer();
4176         int size = values.size();
4177         if (size > 0) {
4178             buffer.append(makeStringAsHEX((byte[])values.get(0)));
4179             for (int i = 1; i < size; i++) {
4180                 buffer.append(" ");
4181                 buffer.append(makeStringAsHEX((byte[])values.get(i)));
4182             }
4183         }
4184         element.setAttribute(name, new String(buffer));
4185     }
4186 
4187     public static void setAttributePropertyByBoolean(Element element, String name, boolean value) {
4188         element.setAttribute(name, getString(value));
4189     }
4190 
4191     public static void setAttributePropertyByBoolean(Element element, String name, Boolean value) {
4192         if (value == null) {
4193             return;
4194         }
4195         element.setAttribute(name, value.toString());
4196     }
4197 
4198     public static void setAttributePropertyByBooleanList(Element element, String name, List values) {
4199         if (values == null) {
4200             return;
4201         }
4202         StringBuffer buffer = new StringBuffer();
4203         int size = values.size();
4204         if (size > 0) {
4205             buffer.append(values.get(0).toString());
4206             for (int i = 1; i < size; i++) {
4207                 buffer.append(" ");
4208                 buffer.append(values.get(i).toString());
4209             }
4210         }
4211         element.setAttribute(name, new String(buffer));
4212     }
4213 
4214     public static void setAttributePropertyByByte(Element element, String name, byte value) {
4215         element.setAttribute(name, Byte.toString(value));
4216     }
4217 
4218     public static void setAttributePropertyByByte(Element element, String name, Byte value) {
4219         if (value == null) {
4220             return;
4221         }
4222         element.setAttribute(name, value.toString());
4223     }
4224 
4225     public static void setAttributePropertyByByteList(Element element, String name, List values) {
4226         if (values == null) {
4227             return;
4228         }
4229         StringBuffer buffer = new StringBuffer();
4230         int size = values.size();
4231         if (size > 0) {
4232             buffer.append(values.get(0).toString());
4233             for (int i = 1; i < size; i++) {
4234                 buffer.append(" ");
4235                 buffer.append(values.get(i).toString());
4236             }
4237         }
4238         element.setAttribute(name, new String(buffer));
4239     }
4240 
4241     public static void setAttributePropertyByDate(Element element, String name, Date value) {
4242         if (value != null) {
4243             DateFormat df = DateFormat.getDateInstance();
4244             element.setAttribute(name, df.format(value));
4245         }
4246     }
4247 
4248     public static void setAttributePropertyByDateList(Element element, String name, List values) {
4249         if (values == null) {
4250             return;
4251         }
4252         StringBuffer buffer = new StringBuffer();
4253         int size = values.size();
4254         if (size > 0) {
4255             buffer.append(values.get(0).toString());
4256             for (int i = 1; i < size; i++) {
4257                 buffer.append(" ");
4258                 buffer.append(values.get(i).toString());
4259             }
4260         }
4261         element.setAttribute(name, new String(buffer));
4262     }
4263 
4264     public static void setAttributePropertyByDouble(Element element, String name, double value) {
4265         element.setAttribute(name, Double.toString(value));
4266     }
4267 
4268     public static void setAttributePropertyByDouble(Element element, String name, Double value) {
4269         if (value == null) {
4270             return;
4271         }
4272         element.setAttribute(name, value.toString());
4273     }
4274 
4275     public static void setAttributePropertyByDoubleList(Element element, String name, List values) {
4276         if (values == null) {
4277             return;
4278         }
4279         StringBuffer buffer = new StringBuffer();
4280         int size = values.size();
4281         if (size > 0) {
4282             buffer.append(values.get(0).toString());
4283             for (int i = 1; i < size; i++) {
4284                 buffer.append(" ");
4285                 buffer.append(values.get(i).toString());
4286             }
4287         }
4288         element.setAttribute(name, new String(buffer));
4289     }
4290 
4291     public static void setAttributePropertyByFloat(Element element, String name, float value) {
4292         element.setAttribute(name, Float.toString(value));
4293     }
4294 
4295     public static void setAttributePropertyByFloat(Element element, String name, Float value) {
4296         if (value == null) {
4297             return;
4298         }
4299         element.setAttribute(name, value.toString());
4300     }
4301 
4302     public static void setAttributePropertyByFloatList(Element element, String name, List values) {
4303         if (values == null) {
4304             return;
4305         }
4306         StringBuffer buffer = new StringBuffer();
4307         int size = values.size();
4308         if (size > 0) {
4309             buffer.append(values.get(0).toString());
4310             for (int i = 1; i < size; i++) {
4311                 buffer.append(" ");
4312                 buffer.append(values.get(i).toString());
4313             }
4314         }
4315         element.setAttribute(name, new String(buffer));
4316     }
4317 
4318     public static void setAttributePropertyByInt(Element element, String name, int value) {
4319         element.setAttribute(name, Integer.toString(value));
4320     }
4321 
4322     public static void setAttributePropertyByInt(Element element, String name, Integer value) {
4323         if (value == null) {
4324             return;
4325         }
4326         element.setAttribute(name, value.toString());
4327     }
4328 
4329     public static void setAttributePropertyByIntList(Element element, String name, List values) {
4330         if (values == null) {
4331             return;
4332         }
4333         StringBuffer buffer = new StringBuffer();
4334         int size = values.size();
4335         if (size > 0) {
4336             buffer.append(values.get(0).toString());
4337             for (int i = 1; i < size; i++) {
4338                 buffer.append(" ");
4339                 buffer.append(values.get(i).toString());
4340             }
4341         }
4342         element.setAttribute(name, new String(buffer));
4343     }
4344 
4345     public static void setAttributePropertyByLocale(Element element, String name, Locale value) {
4346         if (value != null) {
4347             element.setAttribute(name, value.toString());
4348         }
4349     }
4350 
4351     public static void setAttributePropertyByLocaleList(Element element, String name, List values) {
4352         if (values == null) {
4353             return;
4354         }
4355         StringBuffer buffer = new StringBuffer();
4356         int size = values.size();
4357         if (size > 0) {
4358             buffer.append(values.get(0).toString());
4359             for (int i = 1; i < size; i++) {
4360                 buffer.append(" ");
4361                 buffer.append(values.get(i).toString());
4362             }
4363         }
4364         element.setAttribute(name, new String(buffer));
4365     }
4366 
4367     public static void setAttributePropertyByLong(Element element, String name, long value) {
4368         element.setAttribute(name, Long.toString(value));
4369     }
4370 
4371     public static void setAttributePropertyByLong(Element element, String name, Long value) {
4372         if (value == null) {
4373             return;
4374         }
4375         element.setAttribute(name, value.toString());
4376     }
4377 
4378     public static void setAttributePropertyByLongList(Element element, String name, List values) {
4379         if (values == null) {
4380             return;
4381         }
4382         StringBuffer buffer = new StringBuffer();
4383         int size = values.size();
4384         if (size > 0) {
4385             buffer.append(values.get(0).toString());
4386             for (int i = 1; i < size; i++) {
4387                 buffer.append(" ");
4388                 buffer.append(values.get(i).toString());
4389             }
4390         }
4391         element.setAttribute(name, new String(buffer));
4392     }
4393 
4394     public static void setAttributePropertyByShort(Element element, String name, short value) {
4395         element.setAttribute(name, Short.toString(value));
4396     }
4397 
4398     public static void setAttributePropertyByShort(Element element, String name, Short value) {
4399         if (value == null) {
4400             return;
4401         }
4402         element.setAttribute(name, value.toString());
4403     }
4404 
4405     public static void setAttributePropertyByShortList(Element element, String name, List values) {
4406         if (values == null) {
4407             return;
4408         }
4409         StringBuffer buffer = new StringBuffer();
4410         int size = values.size();
4411         if (size > 0) {
4412             buffer.append(values.get(0).toString());
4413             for (int i = 1; i < size; i++) {
4414                 buffer.append(" ");
4415                 buffer.append(values.get(i).toString());
4416             }
4417         }
4418         element.setAttribute(name, new String(buffer));
4419     }
4420 
4421     public static void setAttributePropertyBySQLDate(Element element, String name, java.sql.Date value) {
4422         if (value != null) {
4423             element.setAttribute(name, value.toString());
4424         }
4425     }
4426 
4427     public static void setAttributePropertyBySQLDateList(Element element, String name, List values) {
4428         if (values == null) {
4429             return;
4430         }
4431         element.setAttribute(name, getString(values));
4432     }
4433 
4434     public static void setAttributePropertyBySQLTime(Element element, String name, java.sql.Time value) {
4435         if (value != null) {
4436             element.setAttribute(name, value.toString());
4437         }
4438     }
4439 
4440     public static void setAttributePropertyBySQLTimeList(Element element, String name, List values) {
4441         if (values == null) {
4442             return;
4443         }
4444         element.setAttribute(name, getString(values));
4445     }
4446 
4447     public static void setAttributePropertyBySQLTimestamp(Element element, String name, java.sql.Timestamp value) {
4448         if (value != null) {
4449             element.setAttribute(name, getString(value));
4450         }
4451     }
4452 
4453     public static void setAttributePropertyBySQLTimestampList(Element element, String name, List values) {
4454         if (values == null) {
4455             return;
4456         }
4457         element.setAttribute(name, getString(values));
4458     }
4459 
4460     public static void setAttributePropertyByString(Element element, String name, String value) {
4461         if (value == null) {    // by horst.fiedler@tifff.com
4462             if (getAttribute(element, name) != null) {
4463                 element.removeAttribute(name);
4464             }
4465         } else {
4466             element.setAttribute(name, value);
4467         }
4468     }
4469 
4470     public static void setAttributePropertyByStringList(Element element, String name, List values) {
4471         StringBuffer buffer = new StringBuffer();
4472         int size = values.size();
4473         if (size > 0) {
4474             buffer.append(values.get(0).toString());
4475             for (int i = 1; i < size; i++) {
4476                 buffer.append(" ");
4477                 buffer.append(values.get(i).toString());
4478             }
4479         }
4480         element.setAttribute(name, new String(buffer));
4481     }
4482 
4483     public static void setAttributePropertyByURL(Element element, String name, URL value) {
4484         if (value != null) {
4485             element.setAttribute(name, value.toString());
4486         }
4487     }
4488 
4489     public static void setAttributePropertyByURLList(Element element, String name, List values) {
4490         if (values == null) {
4491             return;
4492         }
4493         StringBuffer buffer = new StringBuffer();
4494         int size = values.size();
4495         if (size > 0) {
4496             buffer.append(values.get(0).toString());
4497             for (int i = 1; i < size; i++) {
4498                 buffer.append(" ");
4499                 buffer.append(values.get(i).toString());
4500             }
4501         }
4502         element.setAttribute(name, new String(buffer));
4503     }
4504 
4505     public static void setAutoIDHandler(Object handler) {
4506         autoIDHandler__ = handler;
4507     }
4508 
4509     public static void setAutoIDPrefix(String prefix) {
4510         autoIDPrefix__ = prefix;
4511     }
4512 
4513     public static void setAutoIDThreadGroupSingle(Boolean threadGroupSingle) {
4514         autoIDThreadGroupSingle__ = threadGroupSingle;
4515     }
4516 
4517     public static void setAutoIDThreadSingle(Boolean threadSingle) {
4518         autoIDThreadSingle__ = threadSingle;
4519     }
4520 
4521     public static void setElementPropertyByBigDecimal(Element element, BigDecimal value) {
4522         if (value == null) {
4523             return;
4524         }
4525         Document doc = element.getOwnerDocument();
4526         Text text = doc.createTextNode(value.toString());
4527         element.appendChild(text);
4528     }
4529 
4530     public static void setElementPropertyByBigDecimal(Element element, String name, BigDecimal value) {
4531         if (value == null) {
4532             return;
4533         }
4534         Document doc = element.getOwnerDocument();
4535         Element property = doc.createElement(name);
4536         Text text = doc.createTextNode(value.toString());
4537         property.appendChild(text);
4538         element.appendChild(property);
4539     }
4540 
4541     // s3
4542     public static void setElementPropertyByBigDecimalDataList(Element element, List values) {
4543         if (values == null) {
4544             return;
4545         }
4546         Document doc = element.getOwnerDocument();
4547         Text text = doc.createTextNode(getString(values));
4548         element.appendChild(text);
4549     }
4550 
4551     // s1a
4552     public static void setElementPropertyByBigDecimalDataList(Element element, String name, List values) {
4553         Document doc = element.getOwnerDocument();
4554         String value = getString(values);
4555         Element property = doc.createElement(name);
4556         if (value != null) {
4557             Text text = doc.createTextNode(value);
4558             property.appendChild(text);
4559         }
4560         element.appendChild(property);
4561     }
4562 
4563     public static void setElementPropertyByBigDecimalList(Element element, String name, List values) {
4564         Document doc = element.getOwnerDocument();
4565         int size = values.size();
4566         for (int i = 0; i < size; i++) {
4567             Element property = doc.createElement(name);
4568             Text text = doc.createTextNode(values.get(i).toString());
4569             property.appendChild(text);
4570             element.appendChild(property);
4571         }
4572     }
4573 
4574     // s2
4575     public static void setElementPropertyByBigDecimalListDataList(Element element, String name, List values) {
4576         Document doc = element.getOwnerDocument();
4577         int size = values.size();
4578         for (int i = 0; i < size; i++) {
4579             Element property = doc.createElement(name);
4580             Text text = doc.createTextNode(values.get(i).toString());
4581             property.appendChild(text);
4582             element.appendChild(property);
4583         }
4584     }
4585 
4586     public static void setElementPropertyByBigInteger(Element element, BigInteger value) {
4587         if (value == null) {
4588             return;
4589         }
4590         Document doc = element.getOwnerDocument();
4591         Text text = doc.createTextNode(value.toString());
4592         element.appendChild(text);
4593     }
4594 
4595     public static void setElementPropertyByBigInteger(Element element, String name, BigInteger value) {
4596         if (value == null) {
4597             return;
4598         }
4599         Document doc = element.getOwnerDocument();
4600         Element property = doc.createElement(name);
4601         Text text = doc.createTextNode(value.toString());
4602         property.appendChild(text);
4603         element.appendChild(property);
4604     }
4605 
4606     // s3u
4607     public static void setElementPropertyByBigIntegerDataList(Element element, List values) {
4608         Document doc = element.getOwnerDocument();
4609         Text text = doc.createTextNode(getString(values));
4610         element.appendChild(text);
4611     }
4612 
4613     // s1a
4614     public static void setElementPropertyByBigIntegerDataList(Element element, String name, List values) {
4615         Document doc = element.getOwnerDocument();
4616         String value = getString(values);
4617         Element property = doc.createElement(name);
4618         if (value != null) {
4619             Text text = doc.createTextNode(value);
4620             property.appendChild(text);
4621         }
4622         element.appendChild(property);
4623     }
4624 
4625     public static void setElementPropertyByBigIntegerList(Element element, String name, List values) {
4626         Document doc = element.getOwnerDocument();
4627         int size = values.size();
4628         for (int i = 0; i < size; i++) {
4629             Element property = doc.createElement(name);
4630             Text text = doc.createTextNode(values.get(i).toString());
4631             property.appendChild(text);
4632             element.appendChild(property);
4633         }
4634     }
4635 
4636     // s2
4637     public static void setElementPropertyByBigIntegerListDataList(Element element, String name, List values) {
4638         Document doc = element.getOwnerDocument();
4639         int size = values.size();
4640         for (int i = 0; i < size; i++) {
4641             Element property = doc.createElement(name);
4642             Text text = doc.createTextNode(values.get(i).toString());
4643             property.appendChild(text);
4644             element.appendChild(property);
4645         }
4646     }
4647 
4648     public static void setElementPropertyByBinaryBASE64(Element element, byte[] value) {
4649         if (value == null) {
4650             return;
4651         }
4652         Document doc = element.getOwnerDocument();
4653         Text text = doc.createTextNode(makeStringAsBASE64(value));
4654         element.appendChild(text);
4655     }
4656 
4657     public static void setElementPropertyByBinaryBASE64(Element element, String name, byte[] value) {
4658         if (value == null) {
4659             return;
4660         }
4661         Document doc = element.getOwnerDocument();
4662         Element property = doc.createElement(name);
4663         Text text = doc.createTextNode(makeStringAsBASE64(value));
4664         property.appendChild(text);
4665         element.appendChild(property);
4666     }
4667 
4668     // s3u
4669     public static void setElementPropertyByBinaryBASE64DataList(Element element, List values) {
4670         Document doc = element.getOwnerDocument();
4671         Text text = doc.createTextNode(getString(values));
4672         element.appendChild(text);
4673     }
4674 
4675     // s1a
4676     public static void setElementPropertyByBinaryBASE64DataList(Element element, String name, List values) {
4677         Document doc = element.getOwnerDocument();
4678         String value = getString(values);
4679         Element property = doc.createElement(name);
4680         if (value != null) {
4681             Text text = doc.createTextNode(value);
4682             property.appendChild(text);
4683         }
4684         element.appendChild(property);
4685     }
4686 
4687     // s2
4688     public static void setElementPropertyByBinaryBASE64ListDataList(Element element, String name, List values) {
4689         Document doc = element.getOwnerDocument();
4690         int size = values.size();
4691         for (int i = 0; i < size; i++) {
4692             Element property = doc.createElement(name);
4693             Text text = doc.createTextNode(values.get(i).toString());
4694             property.appendChild(text);
4695             element.appendChild(property);
4696         }
4697     }
4698 
4699     public static void setElementPropertyByBinaryHEX(Element element, byte[] value) {
4700         if (value == null) {
4701             return;
4702         }
4703         Document doc = element.getOwnerDocument();
4704         Text text = doc.createTextNode(makeStringAsHEX(value));
4705         element.appendChild(text);
4706     }
4707 
4708     public static void setElementPropertyByBinaryHEX(Element element, String name, byte[] value) {
4709         if (value == null) {
4710             return;
4711         }
4712         Document doc = element.getOwnerDocument();
4713         Element property = doc.createElement(name);
4714         Text text = doc.createTextNode(makeStringAsHEX(value));
4715         property.appendChild(text);
4716         element.appendChild(property);
4717     }
4718 
4719     // s3u
4720     public static void setElementPropertyByBinaryHEXDataList(Element element, List values) {
4721         Document doc = element.getOwnerDocument();
4722         Text text = doc.createTextNode(getString(values));
4723         element.appendChild(text);
4724     }
4725 
4726     // s1a
4727     public static void setElementPropertyByBinaryHEXDataList(Element element, String name, List values) {
4728         Document doc = element.getOwnerDocument();
4729         String value = getString(values);
4730         Element property = doc.createElement(name);
4731         if (value != null) {
4732             Text text = doc.createTextNode(value);
4733             property.appendChild(text);
4734         }
4735         element.appendChild(property);
4736     }
4737 
4738     // s2
4739     public static void setElementPropertyByBinaryHEXListDataList(Element element, String name, List values) {
4740         Document doc = element.getOwnerDocument();
4741         int size = values.size();
4742         for (int i = 0; i < size; i++) {
4743             Element property = doc.createElement(name);
4744             Text text = doc.createTextNode(values.get(i).toString());
4745             property.appendChild(text);
4746             element.appendChild(property);
4747         }
4748     }
4749 
4750     public static void setElementPropertyByBinaryListBASE64(Element element, String name, List values) {
4751         Document doc = element.getOwnerDocument();
4752         int size = values.size();
4753         for (int i = 0; i < size; i++) {
4754             Element property = doc.createElement(name);
4755             Text text = doc.createTextNode(makeStringAsBASE64((byte[])values.get(i)));
4756             property.appendChild(text);
4757             element.appendChild(property);
4758         }
4759     }
4760 
4761     public static void setElementPropertyByBinaryListHEX(Element element, String name, List values) {
4762         Document doc = element.getOwnerDocument();
4763         int size = values.size();
4764         for (int i = 0; i < size; i++) {
4765             Element property = doc.createElement(name);
4766             Text text = doc.createTextNode(makeStringAsHEX((byte[])values.get(i)));
4767             property.appendChild(text);
4768             element.appendChild(property);
4769         }
4770     }
4771 
4772     public static void setElementPropertyByBoolean(Element element, boolean value) {
4773         Document doc = element.getOwnerDocument();
4774         Text text = doc.createTextNode(getString(value));
4775         element.appendChild(text);
4776     }
4777 
4778     public static void setElementPropertyByBoolean(Element element, Boolean value) {
4779         if (value == null) {
4780             return;
4781         }
4782         Document doc = element.getOwnerDocument();
4783         Text text = doc.createTextNode(getString(value));
4784         element.appendChild(text);
4785     }
4786 
4787     public static void setElementPropertyByBoolean(Element element, String name, boolean value) {
4788         Document doc = element.getOwnerDocument();
4789         Element property = doc.createElement(name);
4790         Text text = doc.createTextNode(getString(value));
4791         property.appendChild(text);
4792         element.appendChild(property);
4793     }
4794 
4795     public static void setElementPropertyByBoolean(Element element, String name, Boolean value) {
4796         if (value == null) {
4797             return;
4798         }
4799         Document doc = element.getOwnerDocument();
4800         Element property = doc.createElement(name);
4801         Text text = doc.createTextNode(value.toString());
4802         property.appendChild(text);
4803         element.appendChild(property);
4804     }
4805 
4806     // s3
4807     public static void setElementPropertyByBooleanDataList(Element element, List values) {
4808         if (values == null) {
4809             return;
4810         }
4811         Document doc = element.getOwnerDocument();
4812         Text text = doc.createTextNode(getString(values));
4813         element.appendChild(text);
4814     }
4815 
4816     // s1
4817     public static void setElementPropertyByBooleanDataList(Element element, String name, List values) {
4818         Document doc = element.getOwnerDocument();
4819         String value = getString(values);
4820         Element property = doc.createElement(name);
4821         if (value != null) {
4822             Text text = doc.createTextNode(value);
4823             property.appendChild(text);
4824         }
4825         element.appendChild(property);
4826     }
4827 
4828     public static void setElementPropertyByBooleanList(Element element, String name, List values) {
4829         Document doc = element.getOwnerDocument();
4830         int size = values.size();
4831         for (int i = 0; i < size; i++) {
4832             Element property = doc.createElement(name);
4833             Text text = doc.createTextNode(values.get(i).toString());
4834             property.appendChild(text);
4835             element.appendChild(property);
4836         }
4837     }
4838 
4839     // s2
4840     public static void setElementPropertyByBooleanListDataList(Element element, String name, List values) {
4841         Document doc = element.getOwnerDocument();
4842         int size = values.size();
4843         for (int i = 0; i < size; i++) {
4844             Element property = doc.createElement(name);
4845             Text text = doc.createTextNode(values.get(i).toString());    
4846             property.appendChild(text);
4847             element.appendChild(property);
4848         }
4849     }
4850 
4851     public static void setElementPropertyByByte(Element element, byte value) {
4852         Document doc = element.getOwnerDocument();
4853         Text text = doc.createTextNode(Byte.toString(value));
4854         element.appendChild(text);
4855     }
4856 
4857     public static void setElementPropertyByByte(Element element, Byte value) {
4858         if (value == null) {
4859             return;
4860         }
4861         Document doc = element.getOwnerDocument();
4862         Text text = doc.createTextNode(value.toString());
4863         element.appendChild(text);
4864     }
4865 
4866     public static void setElementPropertyByByte(Element element, String name, byte value) {
4867         Document doc = element.getOwnerDocument();
4868         Element property = doc.createElement(name);
4869         Text text = doc.createTextNode(Byte.toString(value));
4870         property.appendChild(text);
4871         element.appendChild(property);
4872     }
4873 
4874     public static void setElementPropertyByByte(Element element, String name, Byte value) {
4875         if (value == null) {
4876             return;
4877         }
4878         Document doc = element.getOwnerDocument();
4879         Element property = doc.createElement(name);
4880         Text text = doc.createTextNode(value.toString());
4881         property.appendChild(text);
4882         element.appendChild(property);
4883     }
4884 
4885     // s3
4886     public static void setElementPropertyByByteDataList(Element element, List values) {
4887         if (values == null) {
4888             return;
4889         }
4890         Document doc = element.getOwnerDocument();
4891         Text text = doc.createTextNode(getString(values));
4892         element.appendChild(text);
4893     }
4894 
4895     // s1a
4896     public static void setElementPropertyByByteDataList(Element element, String name, List values) {
4897         Document doc = element.getOwnerDocument();
4898         String value = getString(values);
4899         Element property = doc.createElement(name);
4900         if (value != null) {
4901             Text text = doc.createTextNode(value);
4902             property.appendChild(text);
4903         }
4904         element.appendChild(property);
4905     }
4906 
4907     public static void setElementPropertyByByteList(Element element, String name, List values) {
4908         Document doc = element.getOwnerDocument();
4909         int size = values.size();
4910         for (int i = 0; i < size; i++) {
4911             Element property = doc.createElement(name);
4912             Text text = doc.createTextNode(values.get(i).toString());
4913             property.appendChild(text);
4914             element.appendChild(property);
4915         }
4916     }
4917 
4918     // s2
4919     public static void setElementPropertyByByteListDataList(Element element, String name, List values) {
4920         Document doc = element.getOwnerDocument();
4921         int size = values.size();
4922         for (int i = 0; i < size; i++) {
4923             Element property = doc.createElement(name);
4924             Text text = doc.createTextNode(values.get(i).toString());
4925             property.appendChild(text);
4926             element.appendChild(property);
4927         }
4928     }
4929 
4930     public static void setElementPropertyByDate(Element element, Date value) {
4931         if (value == null) {
4932             return;
4933         }
4934         Document doc = element.getOwnerDocument();
4935         DateFormat df = DateFormat.getDateInstance();
4936         Text text = doc.createTextNode(df.format(value));
4937         element.appendChild(text);
4938     }
4939 
4940     public static void setElementPropertyByDate(Element element, String name, Date value) {
4941         if (value == null) {
4942             return;
4943         }
4944         Document doc = element.getOwnerDocument();
4945         Element property = doc.createElement(name);
4946         DateFormat df = DateFormat.getDateInstance();
4947         Text text = doc.createTextNode(df.format(value));
4948         property.appendChild(text);
4949         element.appendChild(property);
4950     }
4951 
4952     // s3u
4953     public static void setElementPropertyByDateDataList(Element element, List values) {
4954         Document doc = element.getOwnerDocument();
4955         Text text = doc.createTextNode(getString(values));
4956         element.appendChild(text);
4957     }
4958 
4959     // s1a
4960     public static void setElementPropertyByDateDataList(Element element, String name, List values) {
4961         Document doc = element.getOwnerDocument();
4962         String value = getString(values);
4963         Element property = doc.createElement(name);
4964         if (value != null) {
4965             Text text = doc.createTextNode(value);
4966             property.appendChild(text);
4967         }
4968         element.appendChild(property);
4969     }
4970 
4971     public static void setElementPropertyByDateList(Element element, String name, List values) {
4972         Document doc = element.getOwnerDocument();
4973         int size = values.size();
4974         for (int i = 0; i < size; i++) {
4975             Element property = doc.createElement(name);
4976             Text text = doc.createTextNode(values.get(i).toString());
4977             property.appendChild(text);
4978             element.appendChild(property);
4979         }
4980     }
4981 
4982     // s2
4983     public static void setElementPropertyByDateListDataList(Element element, String name, List values) {
4984         Document doc = element.getOwnerDocument();
4985         int size = values.size();
4986         for (int i = 0; i < size; i++) {
4987             Element property = doc.createElement(name);
4988             Text text = doc.createTextNode(values.get(i).toString());
4989             property.appendChild(text);
4990             element.appendChild(property);
4991         }
4992     }
4993 
4994     public static void setElementPropertyByDouble(Element element, double value) {
4995         Document doc = element.getOwnerDocument();
4996         Text text = doc.createTextNode(Double.toString(value));
4997         element.appendChild(text);
4998     }
4999 
5000     public static void setElementPropertyByDouble(Element element, Double value) {
5001         if (value == null) {
5002             return;
5003         }
5004         Document doc = element.getOwnerDocument();
5005         Text text = doc.createTextNode(value.toString());
5006         element.appendChild(text);
5007     }
5008 
5009     public static void setElementPropertyByDouble(Element element, String name, double value) {
5010         Document doc = element.getOwnerDocument();
5011         Element property = doc.createElement(name);
5012         Text text = doc.createTextNode(Double.toString(value));
5013         property.appendChild(text);
5014         element.appendChild(property);
5015     }
5016 
5017     public static void setElementPropertyByDouble(Element element, String name, Double value) {
5018         if (value == null) {
5019             return;
5020         }
5021         Document doc = element.getOwnerDocument();
5022         Element property = doc.createElement(name);
5023         Text text = doc.createTextNode(value.toString());
5024         property.appendChild(text);
5025         element.appendChild(property);
5026     }
5027 
5028     // s3
5029     public static void setElementPropertyByDoubleDataList(Element element, List values) {
5030         if (values == null) {
5031             return;
5032         }
5033         Document doc = element.getOwnerDocument();
5034         Text text = doc.createTextNode(getString(values));
5035         element.appendChild(text);
5036     }
5037 
5038     // s1a
5039     public static void setElementPropertyByDoubleDataList(Element element, String name, List values) {
5040         Document doc = element.getOwnerDocument();
5041         String value = getString(values);
5042         Element property = doc.createElement(name);
5043         if (value != null) {
5044             Text text = doc.createTextNode(value);
5045             property.appendChild(text);
5046         }
5047         element.appendChild(property);
5048     }
5049 
5050     public static void setElementPropertyByDoubleList(Element element, List values) {
5051         Document doc = element.getOwnerDocument();
5052         Text text = doc.createTextNode(getString(values));
5053         element.appendChild(text);
5054     }
5055 
5056     public static void setElementPropertyByDoubleList(Element element, String name, List values) {
5057         Document doc = element.getOwnerDocument();
5058         int size = values.size();
5059         for (int i = 0; i < size; i++) {
5060             Element property = doc.createElement(name);
5061             Text text = doc.createTextNode(values.get(i).toString());
5062             property.appendChild(text);
5063             element.appendChild(property);
5064         }
5065     }
5066 
5067     // s2
5068     public static void setElementPropertyByDoubleListDataList(Element element, String name, List values) {
5069         Document doc = element.getOwnerDocument();
5070         int size = values.size();
5071         for (int i = 0; i < size; i++) {
5072             Element property = doc.createElement(name);
5073             Text text = doc.createTextNode(values.get(i).toString());
5074             property.appendChild(text);
5075             element.appendChild(property);
5076         }
5077     }
5078 
5079     public static void setElementPropertyByFloat(Element element, float value) {
5080         Document doc = element.getOwnerDocument();
5081         Text text = doc.createTextNode(Float.toString(value));
5082         element.appendChild(text);
5083     }
5084 
5085     public static void setElementPropertyByFloat(Element element, Float value) {
5086         if (value == null) {
5087             return;
5088         }
5089         Document doc = element.getOwnerDocument();
5090         Text text = doc.createTextNode(value.toString());
5091         element.appendChild(text);
5092     }
5093 
5094     public static void setElementPropertyByFloat(Element element, String name, float value) {
5095         Document doc = element.getOwnerDocument();
5096         Element property = doc.createElement(name);
5097         Text text = doc.createTextNode(Float.toString(value));
5098         property.appendChild(text);
5099         element.appendChild(property);
5100     }
5101 
5102     public static void setElementPropertyByFloat(Element element, String name, Float value) {
5103         if (value == null) {
5104             return;
5105         }
5106         Document doc = element.getOwnerDocument();
5107         Element property = doc.createElement(name);
5108         Text text = doc.createTextNode(value.toString());
5109         property.appendChild(text);
5110         element.appendChild(property);
5111     }
5112 
5113     // s3
5114     public static void setElementPropertyByFloatDataList(Element element, List values) {
5115         if (values == null) {
5116             return;
5117         }
5118         Document doc = element.getOwnerDocument();
5119         Text text = doc.createTextNode(getString(values));
5120         element.appendChild(text);
5121     }
5122 
5123     // s1a
5124     public static void setElementPropertyByFloatDataList(Element element, String name, List values) {
5125         Document doc = element.getOwnerDocument();
5126         String value = getString(values);
5127         Element property = doc.createElement(name);
5128         if (value != null) {
5129             Text text = doc.createTextNode(value);
5130             property.appendChild(text);
5131         }
5132         element.appendChild(property);
5133     }
5134 
5135     public static void setElementPropertyByFloatList(Element element, List values) {
5136         Document doc = element.getOwnerDocument();
5137         Text text = doc.createTextNode(getString(values));
5138         element.appendChild(text);
5139     }
5140 
5141     public static void setElementPropertyByFloatList(Element element, String name, List values) {
5142         Document doc = element.getOwnerDocument();
5143         int size = values.size();
5144         for (int i = 0; i < size; i++) {
5145             Element property = doc.createElement(name);
5146             Text text = doc.createTextNode(values.get(i).toString());
5147             property.appendChild(text);
5148             element.appendChild(property);
5149         }
5150     }
5151 
5152     // s2
5153     public static void setElementPropertyByFloatListDataList(Element element, String name, List values) {
5154         Document doc = element.getOwnerDocument();
5155         int size = values.size();
5156         for (int i = 0; i < size; i++) {
5157             Element property = doc.createElement(name);
5158             Text text = doc.createTextNode(values.get(i).toString());
5159             property.appendChild(text);
5160             element.appendChild(property);
5161         }
5162     }
5163 
5164     public static void setElementPropertyByInt(Element element, int value) {
5165         Document doc = element.getOwnerDocument();
5166         Text text = doc.createTextNode(Integer.toString(value));
5167         element.appendChild(text);
5168     }
5169 
5170     public static void setElementPropertyByInt(Element element, Integer value) {
5171         if (value == null) {
5172             return;
5173         }
5174         Document doc = element.getOwnerDocument();
5175         Text text = doc.createTextNode(value.toString());
5176         element.appendChild(text);
5177     }
5178 
5179     public static void setElementPropertyByInt(Element element, String name, int value) {
5180         Document doc = element.getOwnerDocument();
5181         Element property = doc.createElement(name);
5182         Text text = doc.createTextNode(Integer.toString(value));
5183         property.appendChild(text);
5184         element.appendChild(property);
5185     }
5186 
5187     public static void setElementPropertyByInt(Element element, String name, Integer value) {
5188         if (value == null) {
5189             return;
5190         }
5191         Document doc = element.getOwnerDocument();
5192         Element property = doc.createElement(name);
5193         Text text = doc.createTextNode(value.toString());
5194         property.appendChild(text);
5195         element.appendChild(property);
5196     }
5197 
5198     // s3u
5199     public static void setElementPropertyByIntDataList(Element element, List values) {
5200         if (values == null) {
5201             return;
5202         }
5203         Document doc = element.getOwnerDocument();
5204         Text text = doc.createTextNode(getString(values));
5205         element.appendChild(text);
5206     }
5207 
5208     // s1u
5209     public static void setElementPropertyByIntDataList(Element element, String name, List values) {
5210         Document doc = element.getOwnerDocument();
5211         String value = getString(values);
5212         Element property = doc.createElement(name);
5213         if (value != null) {
5214             Text text = doc.createTextNode(value);
5215             property.appendChild(text);
5216         }
5217         element.appendChild(property);
5218     }
5219 
5220     public static void setElementPropertyByIntList(Element element, String name, List values) {
5221         Document doc = element.getOwnerDocument();
5222         int size = values.size();
5223         for (int i = 0; i < size; i++) {
5224             Element property = doc.createElement(name);
5225             Text text = doc.createTextNode(values.get(i).toString());
5226             property.appendChild(text);
5227             element.appendChild(property);
5228         }
5229     }
5230 
5231     // s2
5232     public static void setElementPropertyByIntListDataList(Element element, String name, List values) {
5233         Document doc = element.getOwnerDocument();
5234         int size = values.size();
5235         for (int i = 0; i < size; i++) {
5236             Element property = doc.createElement(name);
5237             Text text = doc.createTextNode(values.get(i).toString());
5238             property.appendChild(text);
5239             element.appendChild(property);
5240         }
5241     }
5242 
5243     public static void setElementPropertyByLocale(Element element, Locale value) {
5244         if (value == null) {
5245             return;
5246         }
5247         Document doc = element.getOwnerDocument();
5248         Text text = doc.createTextNode(value.toString());
5249         element.appendChild(text);
5250     }
5251 
5252     public static void setElementPropertyByLocale(Element element, String name, Locale value) {
5253         if (value == null) {
5254             return;
5255         }
5256         Document doc = element.getOwnerDocument();
5257         Element property = doc.createElement(name);
5258         Text text = doc.createTextNode(value.toString());
5259         property.appendChild(text);
5260         element.appendChild(property);
5261     }
5262 
5263     // s3u
5264     public static void setElementPropertyByLocaleDataList(Element element, List values) {
5265         Document doc = element.getOwnerDocument();
5266         Text text = doc.createTextNode(getString(values));
5267         element.appendChild(text);
5268     }
5269 
5270     // s1a
5271     public static void setElementPropertyByLocaleDataList(Element element, String name, List values) {
5272         Document doc = element.getOwnerDocument();
5273         String value = getString(values);
5274         Element property = doc.createElement(name);
5275         if (value != null) {
5276             Text text = doc.createTextNode(value);
5277             property.appendChild(text);
5278         }
5279         element.appendChild(property);
5280     }
5281 
5282     public static void setElementPropertyByLocaleList(Element element, String name, List values) {
5283         Document doc = element.getOwnerDocument();
5284         int size = values.size();
5285         for (int i = 0; i < size; i++) {
5286             Element property = doc.createElement(name);
5287             Text text = doc.createTextNode(values.get(i).toString());
5288             property.appendChild(text);
5289             element.appendChild(property);
5290         }
5291     }
5292 
5293     // s2
5294     public static void setElementPropertyByLocaleListDataList(Element element, String name, List values) {
5295         Document doc = element.getOwnerDocument();
5296         int size = values.size();
5297         for (int i = 0; i < size; i++) {
5298             Element property = doc.createElement(name);
5299             Text text = doc.createTextNode(values.get(i).toString());
5300             property.appendChild(text);
5301             element.appendChild(property);
5302         }
5303     }
5304 
5305     public static void setElementPropertyByLong(Element element, long value) {
5306         Document doc = element.getOwnerDocument();
5307         Text text = doc.createTextNode(Long.toString(value));
5308         element.appendChild(text);
5309     }
5310 
5311     public static void setElementPropertyByLong(Element element, Long value) {
5312         if (value == null) {
5313             return;
5314         }
5315         Document doc = element.getOwnerDocument();
5316         Text text = doc.createTextNode(value.toString());
5317         element.appendChild(text);
5318     }
5319 
5320     public static void setElementPropertyByLong(Element element, String name, long value) {
5321         Document doc = element.getOwnerDocument();
5322         Element property = doc.createElement(name);
5323         Text text = doc.createTextNode(Long.toString(value));
5324         property.appendChild(text);
5325         element.appendChild(property);
5326     }
5327 
5328     public static void setElementPropertyByLong(Element element, String name, Long value) {
5329         if (value == null) {
5330             return;
5331         }
5332         Document doc = element.getOwnerDocument();
5333         Element property = doc.createElement(name);
5334         Text text = doc.createTextNode(value.toString());
5335         property.appendChild(text);
5336         element.appendChild(property);
5337     }
5338 
5339     // s3
5340     public static void setElementPropertyByLongDataList(Element element, List values) {
5341         if (values == null) {
5342             return;
5343         }
5344         Document doc = element.getOwnerDocument();
5345         Text text = doc.createTextNode(getString(values));
5346         element.appendChild(text);
5347     }
5348 
5349     // s1a
5350     public static void setElementPropertyByLongDataList(Element element, String name, List values) {
5351         Document doc = element.getOwnerDocument();
5352         String value = getString(values);
5353         Element property = doc.createElement(name);
5354         if (value != null) {
5355             Text text = doc.createTextNode(value);
5356             property.appendChild(text);
5357         }
5358         element.appendChild(property);
5359     }
5360 
5361     public static void setElementPropertyByLongList(Element element, List values) {
5362         Document doc = element.getOwnerDocument();
5363         Text text = doc.createTextNode(getString(values));
5364         element.appendChild(text);
5365     }
5366 
5367     public static void setElementPropertyByLongList(Element element, String name, List values) {
5368         Document doc = element.getOwnerDocument();
5369         int size = values.size();
5370         for (int i = 0; i < size; i++) {
5371             Element property = doc.createElement(name);
5372             Text text = doc.createTextNode(values.get(i).toString());
5373             property.appendChild(text);
5374             element.appendChild(property);
5375         }
5376     }
5377 
5378     // s2
5379     public static void setElementPropertyByLongListDataList(Element element, String name, List values) {
5380         Document doc = element.getOwnerDocument();
5381         int size = values.size();
5382         for (int i = 0; i < size; i++) {
5383             Element property = doc.createElement(name);
5384             Text text = doc.createTextNode(values.get(i).toString());
5385             property.appendChild(text);
5386             element.appendChild(property);
5387         }
5388     }
5389 
5390     public static void setElementPropertyByShort(Element element, short value) {
5391         Document doc = element.getOwnerDocument();
5392         Text text = doc.createTextNode(Short.toString(value));
5393         element.appendChild(text);
5394     }
5395 
5396     public static void setElementPropertyByShort(Element element, Short value) {
5397         if (value == null) {
5398             return;
5399         }
5400         Document doc = element.getOwnerDocument();
5401         Text text = doc.createTextNode(value.toString());
5402         element.appendChild(text);
5403     }
5404 
5405     public static void setElementPropertyByShort(Element element, String name, short value) {
5406         Document doc = element.getOwnerDocument();
5407         Element property = doc.createElement(name);
5408         Text text = doc.createTextNode(Short.toString(value));
5409         property.appendChild(text);
5410         element.appendChild(property);
5411     }
5412 
5413     public static void setElementPropertyByShort(Element element, String name, Short value) {
5414         if (value == null) {
5415             return;
5416         }
5417         Document doc = element.getOwnerDocument();
5418         Element property = doc.createElement(name);
5419         Text text = doc.createTextNode(value.toString());
5420         property.appendChild(text);
5421         element.appendChild(property);
5422     }
5423 
5424     // s3u
5425     public static void setElementPropertyByShortDataList(Element element, List values) {
5426         if (values == null) {
5427             return;
5428         }
5429         Document doc = element.getOwnerDocument();
5430         Text text = doc.createTextNode(getString(values));
5431         element.appendChild(text);
5432     }
5433 
5434     // s1a
5435     public static void setElementPropertyByShortDataList(Element element, String name, List values) {
5436         Document doc = element.getOwnerDocument();
5437         String value = getString(values);
5438         Element property = doc.createElement(name);
5439         if (value != null) {
5440             Text text = doc.createTextNode(value);
5441             property.appendChild(text);
5442         }
5443         element.appendChild(property);
5444     }
5445 
5446     public static void setElementPropertyByShortList(Element element, String name, List values) {
5447         Document doc = element.getOwnerDocument();
5448         int size = values.size();
5449         for (int i = 0; i < size; i++) {
5450             Element property = doc.createElement(name);
5451             Text text = doc.createTextNode(values.get(i).toString());
5452             property.appendChild(text);
5453             element.appendChild(property);
5454         }
5455     }
5456 
5457     // s2
5458     public static void setElementPropertyByShortListDataList(Element element, String name, List values) {
5459         Document doc = element.getOwnerDocument();
5460         int size = values.size();
5461         for (int i = 0; i < size; i++) {
5462             Element property = doc.createElement(name);
5463             Text text = doc.createTextNode(values.get(i).toString());
5464             property.appendChild(text);
5465             element.appendChild(property);
5466         }
5467     }
5468 
5469     public static void setElementPropertyBySQLDate(Element element, java.sql.Date value) {
5470         if (value == null) {
5471             return;
5472         }
5473         Document doc = element.getOwnerDocument();
5474         Text text = doc.createTextNode(value.toString());
5475         element.appendChild(text);
5476     }
5477 
5478     public static void setElementPropertyBySQLDate(Element element, String name, java.sql.Date value) {
5479         if (value == null) {
5480             return;
5481         }
5482         Document doc = element.getOwnerDocument();
5483         Element property = doc.createElement(name);
5484         Text text = doc.createTextNode(value.toString());
5485         property.appendChild(text);
5486         element.appendChild(property);
5487     }
5488 
5489     // s3u
5490     public static void setElementPropertyBySQLDateDataList(Element element, List values) {
5491         Document doc = element.getOwnerDocument();
5492         Text text = doc.createTextNode(getString(values));
5493         element.appendChild(text);
5494     }
5495 
5496     // s1a
5497     public static void setElementPropertyBySQLDateDataList(Element element, String name, List values) {
5498         Document doc = element.getOwnerDocument();
5499         String value = getString(values);
5500         Element property = doc.createElement(name);
5501         if (value != null) {
5502             Text text = doc.createTextNode(value);
5503             property.appendChild(text);
5504         }
5505         element.appendChild(property);
5506     }
5507 
5508     public static void setElementPropertyBySQLDateList(Element element, String name, List values) {
5509         Document doc = element.getOwnerDocument();
5510         int size = values.size();
5511         for (int i = 0; i < size; i++) {
5512             Element property = doc.createElement(name);
5513             Text text = doc.createTextNode(values.get(i).toString());
5514             property.appendChild(text);
5515             element.appendChild(property);
5516         }
5517     }
5518 
5519     // s2
5520     public static void setElementPropertyBySQLDateListDataList(Element element, String name, List values) {
5521         Document doc = element.getOwnerDocument();
5522         int size = values.size();
5523         for (int i = 0; i < size; i++) {
5524             Element property = doc.createElement(name);
5525             Text text = doc.createTextNode(values.get(i).toString());
5526             property.appendChild(text);
5527             element.appendChild(property);
5528         }
5529     }
5530 
5531     public static void setElementPropertyBySQLTime(Element element, java.sql.Time value) {
5532         if (value == null) {
5533             return;
5534         }
5535         Document doc = element.getOwnerDocument();
5536         Text text = doc.createTextNode(value.toString());
5537         element.appendChild(text);
5538     }
5539 
5540     public static void setElementPropertyBySQLTime(Element element, String name, java.sql.Time value) {
5541         if (value == null) {
5542             return;
5543         }
5544         Document doc = element.getOwnerDocument();
5545         Element property = doc.createElement(name);
5546         Text text = doc.createTextNode(value.toString());
5547         property.appendChild(text);
5548         element.appendChild(property);
5549     }
5550 
5551     // s3u
5552     public static void setElementPropertyBySQLTimeDataList(Element element, List values) {
5553         Document doc = element.getOwnerDocument();
5554         Text text = doc.createTextNode(getString(values));
5555         element.appendChild(text);
5556     }
5557 
5558     // s1a
5559     public static void setElementPropertyBySQLTimeDataList(Element element, String name, List values) {
5560         Document doc = element.getOwnerDocument();
5561         String value = getString(values);
5562         Element property = doc.createElement(name);
5563         if (value != null) {
5564             Text text = doc.createTextNode(value);
5565             property.appendChild(text);
5566         }
5567         element.appendChild(property);
5568     }
5569 
5570     public static void setElementPropertyBySQLTimeList(Element element, String name, List values) {
5571         Document doc = element.getOwnerDocument();
5572         int size = values.size();
5573         for (int i = 0; i < size; i++) {
5574             Element property = doc.createElement(name);
5575             Text text = doc.createTextNode(values.get(i).toString());
5576             property.appendChild(text);
5577             element.appendChild(property);
5578         }
5579     }
5580 
5581     // s2
5582     public static void setElementPropertyBySQLTimeListDataList(Element element, String name, List values) {
5583         Document doc = element.getOwnerDocument();
5584         int size = values.size();
5585         for (int i = 0; i < size; i++) {
5586             Element property = doc.createElement(name);
5587             Text text = doc.createTextNode(values.get(i).toString());
5588             property.appendChild(text);
5589             element.appendChild(property);
5590         }
5591     }
5592 
5593     public static void setElementPropertyBySQLTimestamp(Element element, java.sql.Timestamp value) {
5594         if (value == null) {
5595             return;
5596         }
5597         Document doc = element.getOwnerDocument();
5598         Text text = doc.createTextNode(getString(value));
5599         element.appendChild(text);
5600     }
5601 
5602     public static void setElementPropertyBySQLTimestamp(Element element, String name, java.sql.Timestamp value) {
5603         if (value == null) {
5604             return;
5605         }
5606         Document doc = element.getOwnerDocument();
5607         Element property = doc.createElement(name);
5608         Text text = doc.createTextNode(getString(value));
5609         property.appendChild(text);
5610         element.appendChild(property);
5611     }
5612 
5613     // s3u
5614     public static void setElementPropertyBySQLTimestampDataList(Element element, List values) {
5615         Document doc = element.getOwnerDocument();
5616         Text text = doc.createTextNode(getString(values));
5617         element.appendChild(text);
5618     }
5619 
5620     // s1a
5621     public static void setElementPropertyBySQLTimestampDataList(Element element, String name, List values) {
5622         Document doc = element.getOwnerDocument();
5623         String value = getString(values);
5624         Element property = doc.createElement(name);
5625         if (value != null) {
5626             Text text = doc.createTextNode(value);
5627             property.appendChild(text);
5628         }
5629         element.appendChild(property);
5630     }
5631 
5632     public static void setElementPropertyBySQLTimestampList(Element element, String name, List values) {
5633         Document doc = element.getOwnerDocument();
5634         int size = values.size();
5635         for (int i = 0; i < size; i++) {
5636             Element property = doc.createElement(name);
5637             Text text = doc.createTextNode(getString((java.sql.Timestamp)values.get(i)));
5638             property.appendChild(text);
5639             element.appendChild(property);
5640         }
5641     }
5642 
5643     // s2
5644     public static void setElementPropertyBySQLTimestampListDataList(Element element, String name, List values) {
5645         Document doc = element.getOwnerDocument();
5646         int size = values.size();
5647         for (int i = 0; i < size; i++) {
5648             Element property = doc.createElement(name);
5649             Text text = doc.createTextNode(values.get(i).toString());
5650             property.appendChild(text);
5651             element.appendChild(property);
5652         }
5653     }
5654 
5655     public static void setElementPropertyByString(Element element, String value) {
5656         Document doc = element.getOwnerDocument();
5657         if (value != null) {
5658             Text text = doc.createTextNode(value);
5659             element.appendChild(text);
5660         }
5661     }
5662 
5663     public static void setElementPropertyByString(Element element, String name, String value) {
5664         Document doc = element.getOwnerDocument();
5665         Element property = doc.createElement(name);
5666         if (value != null) {
5667             Text text = doc.createTextNode(value);
5668             property.appendChild(text);
5669         }
5670         element.appendChild(property);
5671     }
5672 
5673     public static void setElementPropertyByStringDataList(Element element, List values) {
5674         Document doc = element.getOwnerDocument();
5675         String value = getString(values);
5676         if (value != null) {
5677             Text text = doc.createTextNode(value);
5678             element.appendChild(text);
5679         }
5680     }
5681 
5682     public static void setElementPropertyByStringDataList(Element element, String name, List values) {
5683         Document doc = element.getOwnerDocument();
5684         String value = getString(values);
5685         Element property = doc.createElement(name);
5686         if (value != null) {
5687             Text text = doc.createTextNode(value);
5688             property.appendChild(text);
5689         }
5690         element.appendChild(property);
5691     }
5692 
5693     public static void setElementPropertyByStringList(Element element, String name, List values) {
5694         Document doc = element.getOwnerDocument();
5695         int size = values.size();
5696         for (int i = 0; i < size; i++) {
5697             Element property = doc.createElement(name);
5698             Text text = doc.createTextNode(values.get(i).toString());
5699             property.appendChild(text);
5700             element.appendChild(property);
5701         }
5702     }
5703 
5704     public static void setElementPropertyByStringListDataList(Element element, String name, List values) {
5705         Document doc = element.getOwnerDocument();
5706         int size = values.size();
5707         for (int i = 0; i < size; i++) {
5708             Element property = doc.createElement(name);
5709             Text text = doc.createTextNode(values.get(i).toString());
5710             property.appendChild(text);
5711             element.appendChild(property);
5712         }
5713     }
5714 
5715     public static void setElementPropertyByURL(Element element, URL value) {
5716         if (value == null) {
5717             return;
5718         }
5719         Document doc = element.getOwnerDocument();
5720         Text text = doc.createTextNode(value.toString());
5721         element.appendChild(text);
5722     }
5723 
5724     public static void setElementPropertyByURL(Element element, String name, URL value) {
5725         if (value == null) {
5726             return;
5727         }
5728         Document doc = element.getOwnerDocument();
5729         Element property = doc.createElement(name);
5730         Text text = doc.createTextNode(value.toString());
5731         property.appendChild(text);
5732         element.appendChild(property);
5733     }
5734 
5735     // s3u
5736     public static void setElementPropertyByURLDataList(Element element, List values) {
5737         Document doc = element.getOwnerDocument();
5738         Text text = doc.createTextNode(getString(values));
5739         element.appendChild(text);
5740     }
5741 
5742     // s1a
5743     public static void setElementPropertyByURLDataList(Element element, String name, List values) {
5744         Document doc = element.getOwnerDocument();
5745         String value = getString(values);
5746         Element property = doc.createElement(name);
5747         if (value != null) {
5748             Text text = doc.createTextNode(value);
5749             property.appendChild(text);
5750         }
5751         element.appendChild(property);
5752     }
5753 
5754     public static void setElementPropertyByURLList(Element element, String name, List values) {
5755         Document doc = element.getOwnerDocument();
5756         int size = values.size();
5757         for (int i = 0; i < size; i++) {
5758             Element property = doc.createElement(name);
5759             Text text = doc.createTextNode(values.get(i).toString());
5760             property.appendChild(text);
5761             element.appendChild(property);
5762         }
5763     }
5764 
5765     // s2
5766     public static void setElementPropertyByURLListDataList(Element element, String name, List values) {
5767         Document doc = element.getOwnerDocument();
5768         int size = values.size();
5769         for (int i = 0; i < size; i++) {
5770             Element property = doc.createElement(name);
5771             Text text = doc.createTextNode(values.get(i).toString());
5772             property.appendChild(text);
5773             element.appendChild(property);
5774         }
5775     }
5776 
5777     public static boolean isBlankText(Text text) {
5778         String data = text.getData();
5779         char[] chars = data.toCharArray();
5780         for (int i = 0; i < chars.length; i++) {
5781             if (!isSpace(chars[i])) {
5782                 return (false);
5783             }
5784         }
5785         return (true);
5786     }
5787 
5788     public static boolean isMatchDataComplex(Element element, String typeExpr) {
5789         String data = getElementPropertyAsValue(element, "string");
5790         return (isMatchDataComplex(data, typeExpr));
5791     }
5792 
5793     public static boolean isMatchDataComplex(String data, String typeExpr) {
5794         return (true);
5795     }
5796 
5797     public static boolean isMatchDataComplexAttr(Element element, String attrName, String typeExpr) {
5798         String data = getAttributePropertyAsValue(element, attrName, "string");
5799         if (data == null) {
5800             return (false);
5801         }
5802         return (isMatchDataComplex(data, typeExpr));
5803     }
5804 
5805     public static boolean isMatchDataComplexElement(Element element, String elementName, String typeExpr) {
5806         String data = getElementPropertyAsValue(element, elementName, "string");
5807         if (data == null) {
5808             return (false);
5809         }
5810         return (isMatchDataComplex(data, typeExpr));
5811     }
5812 
5813     public static boolean isMatchDataValues(Element element, String typeName, String value) {
5814         String data = getElementPropertyAsValue(element, typeName);
5815         return (isMatchDataValues(data, typeName, value));
5816     }
5817 
5818     public static boolean isMatchDataValues(Element element, String typeName, String[] values) {
5819         String data = getElementPropertyAsValue(element, typeName);
5820         return (isMatchDataValues(data, typeName, values));
5821     }
5822 
5823     public static boolean isMatchDataValues(String data, String typeName, String value) {
5824         return (value.equals(data));
5825     }
5826 
5827     public static boolean isMatchDataValues(String data, String typeName, String[] values) {
5828         for (int i = 0; i < values.length; i++) {
5829             if (values[i].equals(data)) {
5830                 return (true);
5831             }
5832         }
5833         return (false);
5834     }
5835 
5836     public static boolean isMatchDataValues(Element element, String typeName, String value1, String value2) {
5837         String data = getElementPropertyAsValue(element, typeName);
5838         return (isMatchDataValues(data, typeName, value1, value2));
5839     }
5840 
5841     public static boolean isMatchDataValues(String data, String typeName, String value1, String value2) {
5842         return (value1.equals(data) || value2.equals(data));
5843     }
5844 
5845     public static boolean isMatchDataValues(Element element,
5846                                             String typeName,
5847                                             String value1,
5848                                             String value2,
5849                                             String value3) {
5850         String data = getElementPropertyAsValue(element, typeName);
5851         return (isMatchDataValues(data, typeName, value1, value2, value3));
5852     }
5853 
5854     public static boolean isMatchDataValues(String data, String typeName, String value1, String value2, String value3) {
5855         return (value1.equals(data) || value2.equals(data) || value3.equals(data));
5856     }
5857 
5858     public static boolean isMatchDataValuesAttr(Element element, String attrName, String typeName, String value) {
5859         String data = getAttributePropertyAsValue(element, attrName, typeName);
5860         if (data == null) {
5861             return (false);
5862         }
5863         return (isMatchDataValues(data, typeName, value));
5864     }
5865 
5866     public static boolean isMatchDataValuesAttr(Element element, String attrName, String typeName, String[] values) {
5867         String data = getAttributePropertyAsValue(element, attrName, typeName);
5868         if (data == null) {
5869             return (false);
5870         }
5871         return (isMatchDataValues(data, typeName, values));
5872     }
5873 
5874     public static boolean isMatchDataValuesAttr(Element element,
5875                                                 String attrName,
5876                                                 String typeName,
5877                                                 String value1,
5878                                                 String value2) {
5879         String data = getAttributePropertyAsValue(element, attrName, typeName);
5880         if (data == null) {
5881             return (false);
5882         }
5883         return (isMatchDataValues(data, typeName, value1, value2));
5884     }
5885 
5886     public static boolean isMatchDataValuesAttr(Element element,
5887                                                 String attrName,
5888                                                 String typeName,
5889                                                 String value1,
5890                                                 String value2,
5891                                                 String value3) {
5892         String data = getAttributePropertyAsValue(element, attrName, typeName);
5893         if (data == null) {
5894             return (false);
5895         }
5896         return (isMatchDataValues(data, typeName, value1, value2, value3));
5897     }
5898 
5899     public static boolean isMatchDataValuesElement(Element element, String elementName, String typeName, String value) {
5900         String data = getElementPropertyAsValue(element, elementName, typeName);
5901         if (data == null) {
5902             return (false);
5903         }
5904         return (isMatchDataValues(data, typeName, value));
5905     }
5906 
5907     public static boolean isMatchDataValuesElement(Element element,
5908                                                    String elementName,
5909                                                    String typeName,
5910                                                    String[] values) {
5911         String data = getElementPropertyAsValue(element, elementName, typeName);
5912         if (data == null) {
5913             return (false);
5914         }
5915         return (isMatchDataValues(data, typeName, values));
5916     }
5917 
5918     public static boolean isMatchDataValuesElement(Element element,
5919                                                    String elementName,
5920                                                    String typeName,
5921                                                    String value1,
5922                                                    String value2) {
5923         String data = getElementPropertyAsValue(element, elementName, typeName);
5924         if (data == null) {
5925             return (false);
5926         }
5927         return (isMatchDataValues(data, typeName, value1, value2));
5928     }
5929 
5930     public static boolean isMatchDataValuesElement(Element element,
5931                                                    String elementName,
5932                                                    String typeName,
5933                                                    String value1,
5934                                                    String value2,
5935                                                    String value3) {
5936         String data = getElementPropertyAsValue(element, elementName, typeName);
5937         if (data == null) {
5938             return (false);
5939         }
5940         return (isMatchDataValues(data, typeName, value1, value2, value3));
5941     }
5942 
5943     public static boolean isSequence(RStack stack, String name) {
5944         Element[] elements = stack.peekElements();
5945         if (elements == null) {
5946             return (false);
5947         }
5948         if (elements.length != 1) {
5949             return (false);
5950         }
5951         return (name.equals(elements[0].getTagName()));
5952     }
5953 
5954     public static boolean isSequence(RStack stack, String[] names) {
5955         Element[] elements = stack.peekElements();
5956         if (elements == null) {
5957             return (false);
5958         }
5959         if (elements.length != names.length) {
5960             return (false);
5961         }
5962         for (int i = 0; i < names.length; i++) {
5963             if (!names[i].equals(elements[i].getTagName())) {
5964                 return (false);
5965             }
5966         }
5967         return (true);
5968     }
5969 
5970     public static boolean isSpace(char c) {
5971         switch (c) {
5972 
5973             case ' ':
5974             case '\t':
5975             case '\r':
5976             case '\n': {
5977                 return (true);
5978             }
5979             default:
5980             {
5981                 return (false);
5982             }
5983         }
5984     }
5985 
5986     //
5987     // matchers
5988     //
5989 
5990     public static boolean isTargetElement(Element element, String localName) {
5991         return (localName.equals(element.getTagName()));
5992     }
5993 
5994     public static String doc2String4Data(Document doc) {
5995         StringBuffer buffer = new StringBuffer();
5996         Element element = doc.getDocumentElement();
5997         buffer.append("<?xml version='1.0' ?>");
5998         _node2String4Data(element, buffer);
5999         return (new String(buffer));
6000     }
6001 
6002     // XML
6003 
6004     public static String doc2String4Print(Document doc) {
6005         StringBuffer buffer = new StringBuffer();
6006         Element element = doc.getDocumentElement();
6007         buffer.append("<?xml version='1.0' ?>\n");
6008         _node2String4Print(element, "", buffer);
6009         return (new String(buffer));
6010     }
6011 
6012     public static String doc2String4Print(Document doc, String encoding) {
6013         StringBuffer buffer = new StringBuffer();
6014         Element element = doc.getDocumentElement();
6015         buffer.append("<?xml version='1.0' encoding='");
6016         buffer.append(encoding);
6017         buffer.append("' ?>\n");
6018         _node2String4Print(element, "", buffer);
6019         return (new String(buffer));
6020     }
6021 
6022     public static String element2Data(Element element) {
6023         return (element2Text(element).trim());
6024     }
6025 
6026     public static String element2Text(Element element) {
6027         return (node2Text(element));
6028     }
6029 
6030     public static String escape(String string) {
6031         if ((string.indexOf('<') == -1) && (string.indexOf('>') == -1) && (string.indexOf('&') == -1)
6032             && (string.indexOf('"') == -1) && (string.indexOf('\'') == -1) && (string.indexOf('\r') == -1)) {
6033 
6034             return (string);
6035         }
6036         StringBuffer buffer = new StringBuffer();
6037         int size = string.length();
6038         for (int i = 0; i < size; i++) {
6039             char c = string.charAt(i);
6040             if (c == '<') {
6041                 buffer.append("&lt;");
6042             } else if (c == '>') {
6043                 buffer.append("&gt;");
6044             } else if (c == '&') {
6045                 buffer.append("&amp;");
6046             } else if (c == '"') {
6047                 buffer.append("&quot;");
6048             } else if (c == '\'') {
6049                 buffer.append("&apos;");
6050             } else if (c == '\r') {
6051                 buffer.append("&#xD;");
6052             } else {
6053                 buffer.append(c);
6054             }
6055         }
6056         return (new String(buffer));
6057     }
6058 
6059     public static String escapeAttrApos(String string) {
6060         if ((string.indexOf('<') == -1) && (string.indexOf('&') == -1) && (string.indexOf('\'') == -1)) {
6061 
6062             return (string);
6063         }
6064         StringBuffer buffer = new StringBuffer();
6065         int size = string.length();
6066         for (int i = 0; i < size; i++) {
6067             char c = string.charAt(i);
6068             if (c == '<') {
6069                 buffer.append("&lt;");
6070             } else if (c == '&') {
6071                 buffer.append("&amp;");
6072             } else if (c == '\'') {
6073                 buffer.append("&apos;");
6074             } else {
6075                 buffer.append(c);
6076             }
6077         }
6078         return (new String(buffer));
6079     }
6080 
6081     public static String escapeAttrQuot(String string) {
6082         if ((string.indexOf('<') == -1) && (string.indexOf('&') == -1) && (string.indexOf('"') == -1)) {
6083 
6084             return (string);
6085         }
6086         StringBuffer buffer = new StringBuffer();
6087         int size = string.length();
6088         for (int i = 0; i < size; i++) {
6089             char c = string.charAt(i);
6090             if (c == '<') {
6091                 buffer.append("&lt;");
6092             } else if (c == '&') {
6093                 buffer.append("&amp;");
6094             } else if (c == '"') {
6095                 buffer.append("&quot;");
6096             } else {
6097                 buffer.append(c);
6098             }
6099         }
6100         return (new String(buffer));
6101     }
6102 
6103     public static String escapeCharData(String string) {
6104         if (string == null) {
6105             return ("");
6106         }
6107         if ((string.indexOf('<') == -1) && (string.indexOf('&') == -1) && (string.indexOf('>') == -1)
6108             && (string.indexOf('\r') == -1)) {
6109 
6110             return (string);
6111         }
6112         StringBuffer buffer = new StringBuffer();
6113         int size = string.length();
6114         for (int i = 0; i < size; i++) {
6115             char c = string.charAt(i);
6116             if (c == '<') {
6117                 buffer.append("&lt;");
6118             } else if (c == '&') {
6119                 buffer.append("&amp;");
6120             } else if (c == '>') {
6121                 buffer.append("&gt;");
6122             } else if (c == '\r') {
6123                 buffer.append("&#xD;");
6124             } else {
6125                 buffer.append(c);
6126             }
6127         }
6128         return (new String(buffer));
6129     }
6130 
6131     public static String escapeEntityApos(String string) {
6132         if ((string.indexOf('%') == -1) && (string.indexOf('&') == -1) && (string.indexOf('\'') == -1)) {
6133 
6134             return (string);
6135         }
6136         StringBuffer buffer = new StringBuffer();
6137         int size = string.length();
6138         for (int i = 0; i < size; i++) {
6139             char c = string.charAt(i);
6140             if (c == '%') {
6141                 buffer.append("&#x25;");
6142             } else if (c == '&') {
6143                 buffer.append("&amp;");
6144             } else if (c == '\'') {
6145                 buffer.append("&apos;");
6146             } else {
6147                 buffer.append(c);
6148             }
6149         }
6150         return (new String(buffer));
6151     }
6152 
6153     public static String escapeEntityQuot(String string) {
6154         if ((string.indexOf('%') == -1) && (string.indexOf('&') == -1) && (string.indexOf('"') == -1)) {
6155 
6156             return (string);
6157         }
6158         StringBuffer buffer = new StringBuffer();
6159         int size = string.length();
6160         for (int i = 0; i < size; i++) {
6161             char c = string.charAt(i);
6162             if (c == '%') {
6163                 buffer.append("&---;");
6164             } else if (c == '&') {
6165                 buffer.append("&amp;");
6166             } else if (c == '"') {
6167                 buffer.append("&quot;");
6168             } else {
6169                 buffer.append(c);
6170             }
6171         }
6172         return (new String(buffer));
6173     }
6174 
6175     public static String escapeSystemApos(String string) {
6176         if (string.indexOf('\'') == -1) {
6177             return (string);
6178         }
6179         StringBuffer buffer = new StringBuffer();
6180         int size = string.length();
6181         for (int i = 0; i < size; i++) {
6182             char c = string.charAt(i);
6183             if (c == '\'') {
6184                 buffer.append("&apos;");
6185             } else {
6186                 buffer.append(c);
6187             }
6188         }
6189         return (new String(buffer));
6190     }
6191