001/* Properties.java -- a set of persistent properties 002 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 003 004This file is part of GNU Classpath. 005 006GNU Classpath is free software; you can redistribute it and/or modify 007it under the terms of the GNU General Public License as published by 008the Free Software Foundation; either version 2, or (at your option) 009any later version. 010 011GNU Classpath is distributed in the hope that it will be useful, but 012WITHOUT ANY WARRANTY; without even the implied warranty of 013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014General Public License for more details. 015 016You should have received a copy of the GNU General Public License 017along with GNU Classpath; see the file COPYING. If not, write to the 018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 01902110-1301 USA. 020 021Linking this library statically or dynamically with other modules is 022making a combined work based on this library. Thus, the terms and 023conditions of the GNU General Public License cover the whole 024combination. 025 026As a special exception, the copyright holders of this library give you 027permission to link this library with independent modules to produce an 028executable, regardless of the license terms of these independent 029modules, and to copy and distribute the resulting executable under 030terms of your choice, provided that you also meet, for each linked 031independent module, the terms and conditions of the license of that 032module. An independent module is a module which is not derived from 033or based on this library. If you modify this library, you may extend 034this exception to your version of the library, but you are not 035obligated to do so. If you do not wish to do so, delete this 036exception statement from your version. */ 037 038 039package java.util; 040 041import gnu.java.lang.CPStringBuilder; 042 043import java.io.BufferedReader; 044import java.io.IOException; 045import java.io.InputStream; 046import java.io.InputStreamReader; 047import java.io.OutputStream; 048import java.io.OutputStreamWriter; 049import java.io.PrintStream; 050import java.io.PrintWriter; 051import java.io.Reader; 052 053import javax.xml.stream.XMLInputFactory; 054import javax.xml.stream.XMLStreamConstants; 055import javax.xml.stream.XMLStreamException; 056import javax.xml.stream.XMLStreamReader; 057 058import org.w3c.dom.Document; 059import org.w3c.dom.DocumentType; 060import org.w3c.dom.DOMImplementation; 061import org.w3c.dom.Element; 062import org.w3c.dom.bootstrap.DOMImplementationRegistry; 063import org.w3c.dom.ls.DOMImplementationLS; 064import org.w3c.dom.ls.LSOutput; 065import org.w3c.dom.ls.LSSerializer; 066 067/** 068 * A set of persistent properties, which can be saved or loaded from a stream. 069 * A property list may also contain defaults, searched if the main list 070 * does not contain a property for a given key. 071 * 072 * An example of a properties file for the german language is given 073 * here. This extends the example given in ListResourceBundle. 074 * Create a file MyResource_de.properties with the following contents 075 * and put it in the CLASSPATH. (The character 076 * <code>\</code><code>u00e4</code> is the german umlaut) 077 * 078 * 079<pre>s1=3 080s2=MeineDisk 081s3=3. M\<code></code>u00e4rz 96 082s4=Die Diskette ''{1}'' enth\<code></code>u00e4lt {0} in {2}. 083s5=0 084s6=keine Dateien 085s7=1 086s8=eine Datei 087s9=2 088s10={0,number} Dateien 089s11=Das Formatieren schlug fehl mit folgender Exception: {0} 090s12=FEHLER 091s13=Ergebnis 092s14=Dialog 093s15=Auswahlkriterium 094s16=1,3</pre> 095 * 096 * <p>Although this is a sub class of a hash table, you should never 097 * insert anything other than strings to this property, or several 098 * methods, that need string keys and values, will fail. To ensure 099 * this, you should use the <code>get/setProperty</code> method instead 100 * of <code>get/put</code>. 101 * 102 * Properties are saved in ISO 8859-1 encoding, using Unicode escapes with 103 * a single <code>u</code> for any character which cannot be represented. 104 * 105 * @author Jochen Hoenicke 106 * @author Eric Blake (ebb9@email.byu.edu) 107 * @see PropertyResourceBundle 108 * @status updated to 1.4 109 */ 110public class Properties extends Hashtable<Object, Object> 111{ 112 // WARNING: Properties is a CORE class in the bootstrap cycle. See the 113 // comments in vm/reference/java/lang/Runtime for implications of this fact. 114 115 /** 116 * The property list that contains default values for any keys not 117 * in this property list. 118 * 119 * @serial the default properties 120 */ 121 protected Properties defaults; 122 123 /** 124 * Compatible with JDK 1.0+. 125 */ 126 private static final long serialVersionUID = 4112578634029874840L; 127 128 /** 129 * Creates a new empty property list with no default values. 130 */ 131 public Properties() 132 { 133 } 134 135 /** 136 * Create a new empty property list with the specified default values. 137 * 138 * @param defaults a Properties object containing the default values 139 */ 140 public Properties(Properties defaults) 141 { 142 this.defaults = defaults; 143 } 144 145 /** 146 * Adds the given key/value pair to this properties. This calls 147 * the hashtable method put. 148 * 149 * @param key the key for this property 150 * @param value the value for this property 151 * @return The old value for the given key 152 * @see #getProperty(String) 153 * @since 1.2 154 */ 155 public Object setProperty(String key, String value) 156 { 157 return put(key, value); 158 } 159 160 /** 161 * Reads a property list from a character stream. The stream should 162 * have the following format: <br> 163 * 164 * An empty line or a line starting with <code>#</code> or 165 * <code>!</code> is ignored. An backslash (<code>\</code>) at the 166 * end of the line makes the line continueing on the next line 167 * (but make sure there is no whitespace after the backslash). 168 * Otherwise, each line describes a key/value pair. <br> 169 * 170 * The chars up to the first whitespace, = or : are the key. You 171 * can include this caracters in the key, if you precede them with 172 * a backslash (<code>\</code>). The key is followed by optional 173 * whitespaces, optionally one <code>=</code> or <code>:</code>, 174 * and optionally some more whitespaces. The rest of the line is 175 * the resource belonging to the key. <br> 176 * 177 * Escape sequences <code>\t, \n, \r, \\, \", \', \!, \#, \ </code>(a 178 * space), and unicode characters with the 179 * <code>\\u</code><em>xxxx</em> notation are detected, and 180 * converted to the corresponding single character. <br> 181 * 182 * 183<pre># This is a comment 184key = value 185k\:5 \ a string starting with space and ending with newline\n 186# This is a multiline specification; note that the value contains 187# no white space. 188weekdays: Sunday,Monday,Tuesday,Wednesday,\\ 189 Thursday,Friday,Saturday 190# The safest way to include a space at the end of a value: 191label = Name:\\u0020</pre> 192 * 193 * @param inReader the input {@link java.io.Reader}. 194 * @throws IOException if an error occurred when reading the input 195 * @throws NullPointerException if in is null 196 * @since 1.6 197 */ 198 public void load(Reader inReader) throws IOException 199 { 200 BufferedReader reader = new BufferedReader(inReader); 201 String line; 202 203 while ((line = reader.readLine()) != null) 204 { 205 char c = 0; 206 int pos = 0; 207 // Leading whitespaces must be deleted first. 208 while (pos < line.length() 209 && Character.isWhitespace(c = line.charAt(pos))) 210 pos++; 211 212 // If empty line or begins with a comment character, skip this line. 213 if ((line.length() - pos) == 0 214 || line.charAt(pos) == '#' || line.charAt(pos) == '!') 215 continue; 216 217 // The characters up to the next Whitespace, ':', or '=' 218 // describe the key. But look for escape sequences. 219 // Try to short-circuit when there is no escape char. 220 int start = pos; 221 boolean needsEscape = line.indexOf('\\', pos) != -1; 222 CPStringBuilder key = needsEscape ? new CPStringBuilder() : null; 223 while (pos < line.length() 224 && ! Character.isWhitespace(c = line.charAt(pos++)) 225 && c != '=' && c != ':') 226 { 227 if (needsEscape && c == '\\') 228 { 229 if (pos == line.length()) 230 { 231 // The line continues on the next line. If there 232 // is no next line, just treat it as a key with an 233 // empty value. 234 line = reader.readLine(); 235 if (line == null) 236 line = ""; 237 pos = 0; 238 while (pos < line.length() 239 && Character.isWhitespace(c = line.charAt(pos))) 240 pos++; 241 } 242 else 243 { 244 c = line.charAt(pos++); 245 switch (c) 246 { 247 case 'n': 248 key.append('\n'); 249 break; 250 case 't': 251 key.append('\t'); 252 break; 253 case 'r': 254 key.append('\r'); 255 break; 256 case 'u': 257 if (pos + 4 <= line.length()) 258 { 259 char uni = (char) Integer.parseInt 260 (line.substring(pos, pos + 4), 16); 261 key.append(uni); 262 pos += 4; 263 } // else throw exception? 264 break; 265 default: 266 key.append(c); 267 break; 268 } 269 } 270 } 271 else if (needsEscape) 272 key.append(c); 273 } 274 275 boolean isDelim = (c == ':' || c == '='); 276 277 String keyString; 278 if (needsEscape) 279 keyString = key.toString(); 280 else if (isDelim || Character.isWhitespace(c)) 281 keyString = line.substring(start, pos - 1); 282 else 283 keyString = line.substring(start, pos); 284 285 while (pos < line.length() 286 && Character.isWhitespace(c = line.charAt(pos))) 287 pos++; 288 289 if (! isDelim && (c == ':' || c == '=')) 290 { 291 pos++; 292 while (pos < line.length() 293 && Character.isWhitespace(c = line.charAt(pos))) 294 pos++; 295 } 296 297 // Short-circuit if no escape chars found. 298 if (!needsEscape) 299 { 300 put(keyString, line.substring(pos)); 301 continue; 302 } 303 304 // Escape char found so iterate through the rest of the line. 305 StringBuilder element = new StringBuilder(line.length() - pos); 306 while (pos < line.length()) 307 { 308 c = line.charAt(pos++); 309 if (c == '\\') 310 { 311 if (pos == line.length()) 312 { 313 // The line continues on the next line. 314 line = reader.readLine(); 315 316 // We might have seen a backslash at the end of 317 // the file. The JDK ignores the backslash in 318 // this case, so we follow for compatibility. 319 if (line == null) 320 break; 321 322 pos = 0; 323 while (pos < line.length() 324 && Character.isWhitespace(c = line.charAt(pos))) 325 pos++; 326 element.ensureCapacity(line.length() - pos + 327 element.length()); 328 } 329 else 330 { 331 c = line.charAt(pos++); 332 switch (c) 333 { 334 case 'n': 335 element.append('\n'); 336 break; 337 case 't': 338 element.append('\t'); 339 break; 340 case 'r': 341 element.append('\r'); 342 break; 343 case 'u': 344 if (pos + 4 <= line.length()) 345 { 346 char uni = (char) Integer.parseInt 347 (line.substring(pos, pos + 4), 16); 348 element.append(uni); 349 pos += 4; 350 } // else throw exception? 351 break; 352 default: 353 element.append(c); 354 break; 355 } 356 } 357 } 358 else 359 element.append(c); 360 } 361 put(keyString, element.toString()); 362 } 363 } 364 365 /** 366 * Reads a property list from the supplied input stream. 367 * This method has the same functionality as {@link #load(Reader)} 368 * but the character encoding is assumed to be ISO-8859-1. 369 * Unicode characters not within the Latin1 set supplied by 370 * ISO-8859-1 should be escaped using '\\uXXXX' where XXXX 371 * is the UTF-16 code unit in hexadecimal. 372 * 373 * @param inStream the byte stream to read the property list from. 374 * @throws IOException if an I/O error occurs. 375 * @see #load(Reader) 376 * @since 1.2 377 */ 378 public void load(InputStream inStream) throws IOException 379 { 380 load(new InputStreamReader(inStream, "ISO-8859-1")); 381 } 382 383 /** 384 * Calls <code>store(OutputStream out, String header)</code> and 385 * ignores the IOException that may be thrown. 386 * 387 * @param out the stream to write to 388 * @param header a description of the property list 389 * @throws ClassCastException if this property contains any key or 390 * value that are not strings 391 * @deprecated use {@link #store(OutputStream, String)} instead 392 */ 393 @Deprecated 394 public void save(OutputStream out, String header) 395 { 396 try 397 { 398 store(out, header); 399 } 400 catch (IOException ex) 401 { 402 } 403 } 404 405 /** 406 * Writes the key/value pairs to the given output stream, in a format 407 * suitable for <code>load</code>.<br> 408 * 409 * If header is not null, this method writes a comment containing 410 * the header as first line to the stream. The next line (or first 411 * line if header is null) contains a comment with the current date. 412 * Afterwards the key/value pairs are written to the stream in the 413 * following format.<br> 414 * 415 * Each line has the form <code>key = value</code>. Newlines, 416 * Returns and tabs are written as <code>\n,\t,\r</code> resp. 417 * The characters <code>\, !, #, =</code> and <code>:</code> are 418 * preceeded by a backslash. Spaces are preceded with a backslash, 419 * if and only if they are at the beginning of the key. Characters 420 * that are not in the ascii range 33 to 127 are written in the 421 * <code>\</code><code>u</code>xxxx Form.<br> 422 * 423 * Following the listing, the output stream is flushed but left open. 424 * 425 * @param out the output stream 426 * @param header the header written in the first line, may be null 427 * @throws ClassCastException if this property contains any key or 428 * value that isn't a string 429 * @throws IOException if writing to the stream fails 430 * @throws NullPointerException if out is null 431 * @since 1.2 432 */ 433 public void store(OutputStream out, String header) throws IOException 434 { 435 // The spec says that the file must be encoded using ISO-8859-1. 436 PrintWriter writer 437 = new PrintWriter(new OutputStreamWriter(out, "ISO-8859-1")); 438 if (header != null) 439 writer.println("#" + header); 440 writer.println ("#" + Calendar.getInstance ().getTime ()); 441 442 Iterator iter = entrySet ().iterator (); 443 int i = size (); 444 CPStringBuilder s = new CPStringBuilder (); // Reuse the same buffer. 445 while (--i >= 0) 446 { 447 Map.Entry entry = (Map.Entry) iter.next (); 448 formatForOutput ((String) entry.getKey (), s, true); 449 s.append ('='); 450 formatForOutput ((String) entry.getValue (), s, false); 451 writer.println (s); 452 } 453 454 writer.flush (); 455 } 456 457 /** 458 * Gets the property with the specified key in this property list. 459 * If the key is not found, the default property list is searched. 460 * If the property is not found in the default, null is returned. 461 * 462 * @param key The key for this property 463 * @return the value for the given key, or null if not found 464 * @throws ClassCastException if this property contains any key or 465 * value that isn't a string 466 * @see #defaults 467 * @see #setProperty(String, String) 468 * @see #getProperty(String, String) 469 */ 470 public String getProperty(String key) 471 { 472 Properties prop = this; 473 // Eliminate tail recursion. 474 do 475 { 476 String value = (String) prop.get(key); 477 if (value != null) 478 return value; 479 prop = prop.defaults; 480 } 481 while (prop != null); 482 return null; 483 } 484 485 /** 486 * Gets the property with the specified key in this property list. If 487 * the key is not found, the default property list is searched. If the 488 * property is not found in the default, the specified defaultValue is 489 * returned. 490 * 491 * @param key The key for this property 492 * @param defaultValue A default value 493 * @return The value for the given key 494 * @throws ClassCastException if this property contains any key or 495 * value that isn't a string 496 * @see #defaults 497 * @see #setProperty(String, String) 498 */ 499 public String getProperty(String key, String defaultValue) 500 { 501 String prop = getProperty(key); 502 if (prop == null) 503 prop = defaultValue; 504 return prop; 505 } 506 507 /** 508 * Returns an enumeration of all keys in this property list, including 509 * the keys in the default property list. 510 * 511 * @return an Enumeration of all defined keys 512 */ 513 public Enumeration<?> propertyNames() 514 { 515 // We make a new Set that holds all the keys, then return an enumeration 516 // for that. This prevents modifications from ruining the enumeration, 517 // as well as ignoring duplicates. 518 Properties prop = this; 519 Set s = new HashSet(); 520 // Eliminate tail recursion. 521 do 522 { 523 s.addAll(prop.keySet()); 524 prop = prop.defaults; 525 } 526 while (prop != null); 527 return Collections.enumeration(s); 528 } 529 530 /** 531 * Prints the key/value pairs to the given print stream. This is 532 * mainly useful for debugging purposes. 533 * 534 * @param out the print stream, where the key/value pairs are written to 535 * @throws ClassCastException if this property contains a key or a 536 * value that isn't a string 537 * @see #list(PrintWriter) 538 */ 539 public void list(PrintStream out) 540 { 541 PrintWriter writer = new PrintWriter (out); 542 list (writer); 543 } 544 545 /** 546 * Prints the key/value pairs to the given print writer. This is 547 * mainly useful for debugging purposes. 548 * 549 * @param out the print writer where the key/value pairs are written to 550 * @throws ClassCastException if this property contains a key or a 551 * value that isn't a string 552 * @see #list(PrintStream) 553 * @since 1.1 554 */ 555 public void list(PrintWriter out) 556 { 557 out.println ("-- listing properties --"); 558 559 Iterator iter = entrySet ().iterator (); 560 int i = size (); 561 while (--i >= 0) 562 { 563 Map.Entry entry = (Map.Entry) iter.next (); 564 out.print ((String) entry.getKey () + "="); 565 566 // JDK 1.3/1.4 restrict the printed value, but not the key, 567 // to 40 characters, including the truncating ellipsis. 568 String s = (String ) entry.getValue (); 569 if (s != null && s.length () > 40) 570 out.println (s.substring (0, 37) + "..."); 571 else 572 out.println (s); 573 } 574 out.flush (); 575 } 576 577 /** 578 * Formats a key or value for output in a properties file. 579 * See store for a description of the format. 580 * 581 * @param str the string to format 582 * @param buffer the buffer to add it to 583 * @param key true if all ' ' must be escaped for the key, false if only 584 * leading spaces must be escaped for the value 585 * @see #store(OutputStream, String) 586 */ 587 private void formatForOutput(String str, CPStringBuilder buffer, boolean key) 588 { 589 if (key) 590 { 591 buffer.setLength(0); 592 buffer.ensureCapacity(str.length()); 593 } 594 else 595 buffer.ensureCapacity(buffer.length() + str.length()); 596 boolean head = true; 597 int size = str.length(); 598 for (int i = 0; i < size; i++) 599 { 600 char c = str.charAt(i); 601 switch (c) 602 { 603 case '\n': 604 buffer.append("\\n"); 605 break; 606 case '\r': 607 buffer.append("\\r"); 608 break; 609 case '\t': 610 buffer.append("\\t"); 611 break; 612 case ' ': 613 buffer.append(head ? "\\ " : " "); 614 break; 615 case '\\': 616 case '!': 617 case '#': 618 case '=': 619 case ':': 620 buffer.append('\\').append(c); 621 break; 622 default: 623 if (c < ' ' || c > '~') 624 { 625 String hex = Integer.toHexString(c); 626 buffer.append("\\u0000".substring(0, 6 - hex.length())); 627 buffer.append(hex); 628 } 629 else 630 buffer.append(c); 631 } 632 if (c != ' ') 633 head = key; 634 } 635 } 636 637 /** 638 * <p> 639 * Encodes the properties as an XML file using the UTF-8 encoding. 640 * The format of the XML file matches the DTD 641 * <a href="http://java.sun.com/dtd/properties.dtd"> 642 * http://java.sun.com/dtd/properties.dtd</a>. 643 * </p> 644 * <p> 645 * Invoking this method provides the same behaviour as invoking 646 * <code>storeToXML(os, comment, "UTF-8")</code>. 647 * </p> 648 * 649 * @param os the stream to output to. 650 * @param comment a comment to include at the top of the XML file, or 651 * <code>null</code> if one is not required. 652 * @throws IOException if the serialization fails. 653 * @throws NullPointerException if <code>os</code> is null. 654 * @since 1.5 655 */ 656 public void storeToXML(OutputStream os, String comment) 657 throws IOException 658 { 659 storeToXML(os, comment, "UTF-8"); 660 } 661 662 /** 663 * <p> 664 * Encodes the properties as an XML file using the supplied encoding. 665 * The format of the XML file matches the DTD 666 * <a href="http://java.sun.com/dtd/properties.dtd"> 667 * http://java.sun.com/dtd/properties.dtd</a>. 668 * </p> 669 * 670 * @param os the stream to output to. 671 * @param comment a comment to include at the top of the XML file, or 672 * <code>null</code> if one is not required. 673 * @param encoding the encoding to use for the XML output. 674 * @throws IOException if the serialization fails. 675 * @throws NullPointerException if <code>os</code> or <code>encoding</code> 676 * is null. 677 * @since 1.5 678 */ 679 public void storeToXML(OutputStream os, String comment, String encoding) 680 throws IOException 681 { 682 if (os == null) 683 throw new NullPointerException("Null output stream supplied."); 684 if (encoding == null) 685 throw new NullPointerException("Null encoding supplied."); 686 try 687 { 688 DOMImplementationRegistry registry = 689 DOMImplementationRegistry.newInstance(); 690 DOMImplementation domImpl = registry.getDOMImplementation("LS 3.0"); 691 DocumentType doctype = 692 domImpl.createDocumentType("properties", null, 693 "http://java.sun.com/dtd/properties.dtd"); 694 Document doc = domImpl.createDocument(null, "properties", doctype); 695 Element root = doc.getDocumentElement(); 696 if (comment != null) 697 { 698 Element commentElement = doc.createElement("comment"); 699 commentElement.appendChild(doc.createTextNode(comment)); 700 root.appendChild(commentElement); 701 } 702 Iterator iterator = entrySet().iterator(); 703 while (iterator.hasNext()) 704 { 705 Map.Entry entry = (Map.Entry) iterator.next(); 706 Element entryElement = doc.createElement("entry"); 707 entryElement.setAttribute("key", (String) entry.getKey()); 708 entryElement.appendChild(doc.createTextNode((String) 709 entry.getValue())); 710 root.appendChild(entryElement); 711 } 712 DOMImplementationLS loadAndSave = (DOMImplementationLS) domImpl; 713 LSSerializer serializer = loadAndSave.createLSSerializer(); 714 LSOutput output = loadAndSave.createLSOutput(); 715 output.setByteStream(os); 716 output.setEncoding(encoding); 717 serializer.write(doc, output); 718 } 719 catch (ClassNotFoundException e) 720 { 721 throw (IOException) 722 new IOException("The XML classes could not be found.").initCause(e); 723 } 724 catch (InstantiationException e) 725 { 726 throw (IOException) 727 new IOException("The XML classes could not be instantiated.") 728 .initCause(e); 729 } 730 catch (IllegalAccessException e) 731 { 732 throw (IOException) 733 new IOException("The XML classes could not be accessed.") 734 .initCause(e); 735 } 736 } 737 738 /** 739 * <p> 740 * Decodes the contents of the supplied <code>InputStream</code> as 741 * an XML file, which represents a set of properties. The format of 742 * the XML file must match the DTD 743 * <a href="http://java.sun.com/dtd/properties.dtd"> 744 * http://java.sun.com/dtd/properties.dtd</a>. 745 * </p> 746 * 747 * @param in the input stream from which to receive the XML data. 748 * @throws IOException if an I/O error occurs in reading the input data. 749 * @throws InvalidPropertiesFormatException if the input data does not 750 * constitute an XML properties 751 * file. 752 * @throws NullPointerException if <code>in</code> is null. 753 * @since 1.5 754 */ 755 public void loadFromXML(InputStream in) 756 throws IOException, InvalidPropertiesFormatException 757 { 758 if (in == null) 759 throw new NullPointerException("Null input stream supplied."); 760 try 761 { 762 XMLInputFactory factory = XMLInputFactory.newInstance(); 763 // Don't resolve external entity references 764 factory.setProperty("javax.xml.stream.isSupportingExternalEntities", 765 Boolean.FALSE); 766 XMLStreamReader reader = factory.createXMLStreamReader(in); 767 String name, key = null; 768 CPStringBuilder buf = null; 769 while (reader.hasNext()) 770 { 771 switch (reader.next()) 772 { 773 case XMLStreamConstants.START_ELEMENT: 774 name = reader.getLocalName(); 775 if (buf == null && "entry".equals(name)) 776 { 777 key = reader.getAttributeValue(null, "key"); 778 if (key == null) 779 { 780 String msg = "missing 'key' attribute"; 781 throw new InvalidPropertiesFormatException(msg); 782 } 783 buf = new CPStringBuilder(); 784 } 785 else if (!"properties".equals(name) && !"comment".equals(name)) 786 { 787 String msg = "unexpected element name '" + name + "'"; 788 throw new InvalidPropertiesFormatException(msg); 789 } 790 break; 791 case XMLStreamConstants.END_ELEMENT: 792 name = reader.getLocalName(); 793 if (buf != null && "entry".equals(name)) 794 { 795 put(key, buf.toString()); 796 buf = null; 797 } 798 else if (!"properties".equals(name) && !"comment".equals(name)) 799 { 800 String msg = "unexpected element name '" + name + "'"; 801 throw new InvalidPropertiesFormatException(msg); 802 } 803 break; 804 case XMLStreamConstants.CHARACTERS: 805 case XMLStreamConstants.SPACE: 806 case XMLStreamConstants.CDATA: 807 if (buf != null) 808 buf.append(reader.getText()); 809 break; 810 } 811 } 812 reader.close(); 813 } 814 catch (XMLStreamException e) 815 { 816 throw (InvalidPropertiesFormatException) 817 new InvalidPropertiesFormatException("Error in parsing XML."). 818 initCause(e); 819 } 820 } 821 822} // class Properties