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
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
77
78
79
80
81
82
83
84
85
86
87
88
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
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
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
931 public static List getElementPropertyAsBigDecimalDataList(Element element, String name) {
932 Element property = getOnlyElement(element, name);
933 return (getElementPropertyAsBigDecimalDataList(property));
934 }
935
936
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
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
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
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
1058 public static List getElementPropertyAsBigIntegerDataList(Element element, String name) {
1059 Element property = getOnlyElement(element, name);
1060 return (getElementPropertyAsBigIntegerDataList(property));
1061 }
1062
1063
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
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
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
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
1177 public static List getElementPropertyAsBinaryBASE64DataList(Element element, String name) {
1178 Element property = getOnlyElement(element, name);
1179 return (getElementPropertyAsBinaryBASE64DataList(property));
1180 }
1181
1182
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
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
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
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
1263 public static List getElementPropertyAsBinaryHEXDataList(Element element, String name) {
1264 Element property = getOnlyElement(element, name);
1265 return (getElementPropertyAsBinaryHEXDataList(property));
1266 }
1267
1268
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
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
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
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
1410 public static List getElementPropertyAsBooleanDataList(Element element, String name) {
1411 Element property = getOnlyElement(element, name);
1412 return (getElementPropertyAsBooleanDataList(property));
1413 }
1414
1415
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
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
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
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
1540 public static List getElementPropertyAsByteDataList(Element element, String name) {
1541 Element property = getOnlyElement(element, name);
1542 return (getElementPropertyAsByteDataList(property));
1543 }
1544
1545
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
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
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
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
1672 public static List getElementPropertyAsDateDataList(Element element, String name) {
1673 Element property = getOnlyElement(element, name);
1674 return (getElementPropertyAsDateDataList(property));
1675 }
1676
1677
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
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
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
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
1802 public static List getElementPropertyAsDoubleDataList(Element element, String name) {
1803 Element property = getOnlyElement(element, name);
1804 return (getElementPropertyAsDoubleDataList(property));
1805 }
1806
1807
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
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
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
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
1942 public static List getElementPropertyAsFloatDataList(Element element, String name) {
1943 Element property = getOnlyElement(element, name);
1944 return (getElementPropertyAsFloatDataList(property));
1945 }
1946
1947
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
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
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
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
2072 public static List getElementPropertyAsIntDataList(Element element, String name) {
2073 Element property = getOnlyElement(element, name);
2074 return (getElementPropertyAsIntDataList(property));
2075 }
2076
2077
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
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
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
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
2194 public static List getElementPropertyAsLocaleDataList(Element element, String name) {
2195 Element property = getOnlyElement(element, name);
2196 return (getElementPropertyAsLocaleDataList(property));
2197 }
2198
2199
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
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
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
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
2323 public static List getElementPropertyAsLongDataList(Element element, String name) {
2324 Element property = getOnlyElement(element, name);
2325 return (getElementPropertyAsLongDataList(property));
2326 }
2327
2328
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
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
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
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
2453 public static List getElementPropertyAsShortDataList(Element element, String name) {
2454 Element property = getOnlyElement(element, name);
2455 return (getElementPropertyAsShortDataList(property));
2456 }
2457
2458
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
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
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
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
2575 public static List getElementPropertyAsSQLDateDataList(Element element, String name) {
2576 Element property = getOnlyElement(element, name);
2577 return (getElementPropertyAsSQLDateDataList(property));
2578 }
2579
2580
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
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
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
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
2692 public static List getElementPropertyAsSQLTimeDataList(Element element, String name) {
2693 Element property = getOnlyElement(element, name);
2694 return (getElementPropertyAsSQLTimeDataList(property));
2695 }
2696
2697
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
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
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
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
2809 public static List getElementPropertyAsSQLTimestampDataList(Element element, String name) {
2810 Element property = getOnlyElement(element, name);
2811 return (getElementPropertyAsSQLTimestampDataList(property));
2812 }
2813
2814
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
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
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
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
3020 public static List getElementPropertyAsURLDataList(Element element, String name) {
3021 Element property = getOnlyElement(element, name);
3022 return (getElementPropertyAsURLDataList(property));
3023 }
3024
3025
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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) {
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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("<");
6042 } else if (c == '>') {
6043 buffer.append(">");
6044 } else if (c == '&') {
6045 buffer.append("&");
6046 } else if (c == '"') {
6047 buffer.append(""");
6048 } else if (c == '\'') {
6049 buffer.append("'");
6050 } else if (c == '\r') {
6051 buffer.append("
");
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("<");
6070 } else if (c == '&') {
6071 buffer.append("&");
6072 } else if (c == '\'') {
6073 buffer.append("'");
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("<");
6092 } else if (c == '&') {
6093 buffer.append("&");
6094 } else if (c == '"') {
6095 buffer.append(""");
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("<");
6118 } else if (c == '&') {
6119 buffer.append("&");
6120 } else if (c == '>') {
6121 buffer.append(">");
6122 } else if (c == '\r') {
6123 buffer.append("
");
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("%");
6142 } else if (c == '&') {
6143 buffer.append("&");
6144 } else if (c == '\'') {
6145 buffer.append("'");
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("&");
6166 } else if (c == '"') {
6167 buffer.append(""");
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("'");
6185 } else {
6186 buffer.append(c);
6187 }
6188 }
6189 return (new String(buffer));
6190 }
6191