- Timestamp:
- 2004-02-20T11:58:12+13:00 (20 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/gli/src/org/greenstone/gatherer/cdm/CollectionConfiguration.java
r6770 r6852 53 53 static public Document document; 54 54 55 55 static public void main(String[] args) { 56 56 if(args.length >= 1) { 57 58 59 60 61 57 File file = new File(args[0]); 58 CollectionConfiguration collect_cfg = new CollectionConfiguration(file); 59 collect_cfg.save(true); 60 collect_cfg.save(false); 61 collect_cfg = null; 62 62 } 63 63 else { 64 65 } 66 67 68 69 70 71 72 64 System.out.println("Usage: CollectionConfiguration <filename>"); 65 } 66 } 67 68 /** Find the best insertion position for the given DOM Element. This should try to match command tag, and if found should then try to group by name or type (eg CollectionMeta), or append to end is no such grouping exists (eg PlugIns). Failing a command match it will check against the command order for the best insertion location. 69 * @param target_element the command Element to be inserted 70 * @return the Element which the given command should be inserted before, or null to append to end of list 71 */ 72 static public Node findInsertionPoint(Element target_element) { 73 73 ///ystem.err.println("Find insertion point: " + target_element.getNodeName()); 74 74 String target_element_name = target_element.getNodeName(); … … 78 78 // If we found matching elements, then we have our most likely insertion location, so check within for groupings 79 79 if(matching_elements.getLength() != 0) { 80 81 82 80 ///ystem.err.println("Found matching elements."); 81 // Only CollectionMeta are grouped. 82 if(target_element_name.equals(COLLECTIONMETADATA_ELEMENT)) { 83 83 ///ystem.err.println("Dealing with collection metadata"); 84 84 // Special case: CollectionMeta can be added at either the start or end of a collection configuration file. However the start position is reserved for special metadata, so if no non-special metadata can be found we must append to the end. 85 85 // So if the command to be added is special add it immediately after any other special command 86 86 if(target_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) { 87 88 89 90 87 int index = 0; 88 Element matched_element = (Element) matching_elements.item(index); 89 Element sibling_element = (Element) matched_element.getNextSibling(); 90 while(sibling_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) { 91 91 index++; 92 92 matched_element = (Element) matching_elements.item(index); 93 93 sibling_element = (Element) matched_element.getNextSibling(); 94 95 94 } 95 if(sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) { 96 96 Element newline_element = document.createElement(NEWLINE_ELEMENT); 97 97 document_element.insertBefore(newline_element, sibling_element); 98 99 98 } 99 return sibling_element; 100 100 } 101 101 // Otherwise try to find a matching 'name' and add after the last one in that group. 102 102 else { 103 104 105 106 107 108 103 int index = 0; 104 target_element_name = target_element.getAttribute(NAME_ATTRIBUTE); 105 boolean found = false; 106 // Skip all of the special metadata 107 Element matched_element = (Element) matching_elements.item(index); 108 while(matched_element.getAttribute(SPECIAL_ATTRIBUTE).equals(TRUE_STR)) { 109 109 index++; 110 110 matched_element = (Element) matching_elements.item(index); 111 112 113 111 } 112 // Begin search 113 while(!found && matched_element != null) { 114 114 if(matched_element.getAttribute(NAME_ATTRIBUTE).equals(target_element_name)) { 115 115 found = true; 116 116 } 117 117 else { 118 119 118 index++; 119 matched_element = (Element) matching_elements.item(index); 120 120 } 121 122 123 121 } 122 // If we found a match, we need to continue checking until we find the last name match. 123 if(found) { 124 124 index++; 125 125 Element previous_sibling = matched_element; 126 126 Element sibling_element = (Element) matching_elements.item(index); 127 127 while(sibling_element != null && sibling_element.getAttribute(NAME_ATTRIBUTE).equals(target_element_name)) { 128 129 130 128 previous_sibling = sibling_element; 129 index++; 130 sibling_element = (Element) matching_elements.item(index); 131 131 } 132 132 // Previous sibling now holds the command immediately before where we want to add, so find its next sibling and add to that. In this one case we can ignore new lines! 133 133 return previous_sibling.getNextSibling(); 134 135 136 134 } 135 // If not found we just add after last metadata element 136 else { 137 137 Element last_element = (Element) matching_elements.item(matching_elements.getLength() - 1); 138 138 return last_element.getNextSibling(); 139 140 } 141 142 143 139 } 140 } 141 142 } 143 else { 144 144 ///ystem.err.println("Not dealing with collection meta."); 145 145 Element matched_element = (Element) matching_elements.item(matching_elements.getLength() - 1); … … 147 147 Node sibling_element = matched_element.getNextSibling(); 148 148 if(sibling_element != null && sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) { 149 150 149 Element newline_element = document.createElement(NEWLINE_ELEMENT); 150 document_element.insertBefore(newline_element, sibling_element); 151 151 } 152 152 return sibling_element; // Note that this may be null 153 153 } 154 154 } 155 155 ///ystem.err.println("No matching elements found."); … … 157 157 int command_index = -1; 158 158 for(int i = 0; command_index == -1 && i < COMMAND_ORDER.length; i++) { 159 159 if(COMMAND_ORDER[i].equals(target_element_name)) { 160 160 command_index = i; 161 161 } 162 162 } 163 163 ///ystem.err.println("Command index is: " + command_index); … … 166 166 ///ystem.err.println("Searching before the target command."); 167 167 while(preceeding_index >= 0) { 168 169 170 168 matching_elements = document_element.getElementsByTagName(COMMAND_ORDER[preceeding_index]); 169 // If we've found a match 170 if(matching_elements.getLength() > 0) { 171 171 // We add after the last element 172 172 Element matched_element = (Element) matching_elements.item(matching_elements.getLength() - 1); … … 174 174 Node sibling_element = matched_element.getNextSibling(); 175 175 if(sibling_element != null && sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) { 176 177 176 Element newline_element = document.createElement(NEWLINE_ELEMENT); 177 document_element.insertBefore(newline_element, sibling_element); 178 178 } 179 179 return sibling_element; // Note that this may be null 180 181 180 } 181 preceeding_index--; 182 182 } 183 183 // If all that fails, we now move backwards through the commands … … 185 185 ///ystem.err.println("Searching after the target command."); 186 186 while(susceeding_index < COMMAND_ORDER.length) { 187 188 189 187 matching_elements = document_element.getElementsByTagName(COMMAND_ORDER[susceeding_index]); 188 // If we've found a match 189 if(matching_elements.getLength() > 0) { 190 190 // We add before the first element 191 191 Element matched_element = (Element) matching_elements.item(0); … … 193 193 Node sibling_element = matched_element.getPreviousSibling(); 194 194 if(sibling_element != null && sibling_element.getNodeName().equals(NEWLINE_ELEMENT)) { 195 196 195 Element newline_element = document.createElement(NEWLINE_ELEMENT); 196 document_element.insertBefore(newline_element, sibling_element); 197 197 } 198 198 return sibling_element; // Note that this may be null 199 200 199 } 200 susceeding_index++; 201 201 } 202 202 // Well. Apparently there are no other commands in this collection configuration. So append away... 203 203 return null; 204 205 206 204 } 205 206 static public String toString(Element command_element, boolean show_extracted_namespace) { 207 207 String command_element_name = command_element.getNodeName(); 208 208 if(command_element_name.equals(CLASSIFY_ELEMENT)) { 209 209 return self.classifyToString(command_element, show_extracted_namespace); 210 210 } 211 211 else if(command_element_name.equals(FORMAT_ELEMENT)) { 212 212 return self.formatToString(command_element, show_extracted_namespace); 213 213 } 214 214 else if(command_element_name.equals(INDEXES_ELEMENT)) { 215 215 return self.indexesToString(command_element, show_extracted_namespace); 216 216 } 217 217 else if(command_element_name.equals(INDEX_DEFAULT_ELEMENT)) { 218 218 return self.indexDefaultToString(command_element, show_extracted_namespace); 219 219 } 220 220 else if(command_element_name.equals(LANGUAGES_ELEMENT)) { 221 221 return self.languagesToString(command_element); 222 222 } 223 223 else if(command_element_name.equals(LANGUAGE_DEFAULT_ELEMENT)) { 224 224 return self.languageDefaultToString(command_element); 225 225 } 226 226 else if(command_element_name.equals(LEVELS_ELEMENT)) { 227 227 return self.levelsToString(command_element); 228 228 } 229 229 else if(command_element_name.equals(COLLECTIONMETADATA_ELEMENT)) { 230 230 return self.metadataToString(command_element, show_extracted_namespace); 231 231 } 232 232 else if(command_element_name.equals(COLLECTIONMETADATA_CREATOR_ELEMENT)) { 233 233 return self.metadataToString(command_element, show_extracted_namespace); 234 234 } 235 235 else if(command_element_name.equals(COLLECTIONMETADATA_MAINTAINER_ELEMENT)) { 236 236 return self.metadataToString(command_element, show_extracted_namespace); 237 237 } 238 238 else if(command_element_name.equals(COLLECTIONMETADATA_PUBLIC_ELEMENT)) { 239 239 return self.metadataToString(command_element, show_extracted_namespace); 240 240 } 241 241 else if(command_element_name.equals(COLLECTIONMETADATA_BETA_ELEMENT)) { 242 242 return self.metadataToString(command_element, show_extracted_namespace); 243 243 } 244 244 else if(command_element_name.equals(PLUGIN_ELEMENT)) { 245 245 return self.pluginToString(command_element, show_extracted_namespace); 246 246 } 247 247 else if(command_element_name.equals(SEARCHTYPE_ELEMENT)) { 248 248 return self.searchtypeToString(command_element); 249 249 } 250 250 else if(command_element_name.equals(SUBCOLLECTION_ELEMENT)) { 251 251 return self.subcollectionToString(command_element, show_extracted_namespace); 252 252 } 253 253 else if(command_element_name.equals(SUBCOLLECTION_DEFAULT_INDEX_ELEMENT)) { 254 254 return self.subcollectionDefaultIndexToString(command_element); 255 255 } 256 256 else if(command_element_name.equals(SUBCOLLECTION_INDEXES_ELEMENT)) { 257 257 return self.subcollectionIndexesToString(command_element); 258 258 } 259 259 else if(command_element_name.equals(SUPERCOLLECTION_ELEMENT)) { 260 260 return self.supercollectionToString(command_element); 261 261 } 262 262 else if(command_element_name.equals(UNKNOWN_ELEMENT)) { 263 263 return self.unknownToString(command_element); 264 264 } 265 265 return ""; 266 267 268 269 270 271 272 266 } 267 268 /** Parses arguments from a tokenizer and returns a HashMap of mappings. The tricky bit here is that not all entries in the HashMap are name->value pairs, as some arguments are boolean and are turned on by their presence. Arguments are denoted by a '-' prefix. 269 * @param tokenizer a CommandTokenizer based on the unconsumed portion of a command string 270 * @return a HashMap containing the arguments parsed 271 */ 272 static public HashMap parseArguments(CommandTokenizer tokenizer) { 273 273 HashMap arguments = new HashMap(); 274 274 String name = null; 275 275 String value = null; 276 276 while(tokenizer.hasMoreTokens() || name != null) { 277 278 277 // First we retrieve a name if we need one. 278 if(name == null) { 279 279 name = tokenizer.nextToken(); 280 281 282 280 } 281 // Now we attempt to retrieve a value 282 if(tokenizer.hasMoreTokens()) { 283 283 value = tokenizer.nextToken(); 284 284 // Test if the value is actually a name, and if so add the name by itself, then put value into name so that it is parsed correctly during the next loop. 285 285 if(value.startsWith(StaticStrings.MINUS_CHARACTER)) { 286 287 286 arguments.put(name, null); 287 name = value; 288 288 } 289 289 // Otherwise we have a typical name->value pair ready to go 290 290 else { 291 292 293 } 294 295 296 291 arguments.put(name, value); 292 name = null; 293 } 294 } 295 // Otherwise its a binary flag 296 else { 297 297 arguments.put(name, null); 298 298 name = null; 299 299 } 300 300 } 301 301 return arguments; 302 303 304 305 306 307 308 309 310 311 312 302 } 303 304 static private ArrayList known_metadata; 305 306 static private CollectionConfiguration self; 307 308 static final private String EXTRACTED_PREFIX = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP; 309 /** Gives the preferred ordering of commands */ 310 static final private String[] COMMAND_ORDER = {StaticStrings.COLLECTIONMETADATA_CREATOR_ELEMENT, StaticStrings.COLLECTIONMETADATA_MAINTAINER_ELEMENT, StaticStrings.COLLECTIONMETADATA_PUBLIC_ELEMENT, StaticStrings.COLLECTIONMETADATA_BETA_ELEMENT, StaticStrings.SEARCHTYPE_ELEMENT, StaticStrings.PLUGIN_ELEMENT, StaticStrings.INDEXES_ELEMENT, StaticStrings.LEVELS_ELEMENT, StaticStrings.INDEX_DEFAULT_ELEMENT, StaticStrings.LANGUAGES_ELEMENT, StaticStrings.LANGUAGE_DEFAULT_ELEMENT, StaticStrings.SUBCOLLECTION_ELEMENT, StaticStrings.SUBCOLLECTION_INDEXES_ELEMENT, StaticStrings.SUBCOLLECTION_DEFAULT_INDEX_ELEMENT, StaticStrings.SUPERCOLLECTION_ELEMENT, StaticStrings.CLASSIFY_ELEMENT, StaticStrings.FORMAT_ELEMENT, StaticStrings.COLLECTIONMETADATA_ELEMENT}; 311 312 /** ************************** Public Data Members ***************************/ 313 313 314 314 /** ************************** Private Data Members ***************************/ … … 363 363 } 364 364 365 365 public Element getCreator() { 366 366 Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_CREATOR_ELEMENT, null, null); 367 367 element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_CREATOR_STR); 368 368 element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR); 369 369 return element; 370 371 372 370 } 371 372 public Element getDocumentElement() { 373 373 return document.getDocumentElement(); 374 375 376 374 } 375 376 public File getFile() { 377 377 return collect_config_file; 378 379 380 381 378 } 379 380 /** Retrieve or create the languages Element. */ 381 public Element getLanguages() { 382 382 return getOrCreateElementByTagName(LANGUAGES_ELEMENT, null, null); 383 384 385 383 } 384 385 public Element getLevels() { 386 386 return getOrCreateElementByTagName(LEVELS_ELEMENT, null, null); 387 388 389 387 } 388 389 public Element getMaintainer() { 390 390 Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_MAINTAINER_ELEMENT, null, null); 391 391 element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_MAINTAINER_STR); 392 392 element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR); 393 393 return element; 394 395 396 397 394 } 395 396 /** Retrieve or create the indexes Element. Note that this method behaves differently from the other getBlah methods, in that it also has to keep in mind that indexes come in two flavours, MG and MGPP. */ 397 public Element getMGIndexes() { 398 398 return getOrCreateElementByTagName(INDEXES_ELEMENT, MGPP_ATTRIBUTE, FALSE_STR); 399 400 401 399 } 400 401 public Element getMGPPIndexes() { 402 402 return getOrCreateElementByTagName(INDEXES_ELEMENT, MGPP_ATTRIBUTE, TRUE_STR); 403 404 405 403 } 404 405 public Element getPublic() { 406 406 Element element = getOrCreateElementByTagName(COLLECTIONMETADATA_PUBLIC_ELEMENT, null, null); 407 407 element.setAttribute(NAME_ATTRIBUTE, COLLECTIONMETADATA_PUBLIC_STR); 408 408 element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR); 409 409 return element; 410 411 412 413 410 } 411 412 /** Retrieve or create the searchtype element. */ 413 public Element getSearchType() { 414 414 ///ystem.err.println("Get or create element by tag name: " + name); 415 415 Element document_element = document.getDocumentElement(); … … 417 417 int elements_length = elements.getLength(); 418 418 if(elements_length > 0) { 419 420 419 document_element = null; 420 return (Element) elements.item(0); 421 421 } 422 422 // Create the element … … 424 424 Node target_node = findInsertionPoint(element); 425 425 if(target_node != null) { 426 426 document_element.insertBefore(element, target_node); 427 427 } 428 428 else { 429 429 document_element.appendChild(element); 430 430 } 431 431 document_element = null; … … 435 435 element.appendChild(a_searchtype_element); 436 436 return element; 437 438 439 440 437 } 438 439 /** Retrieve or create the subindexes Element. */ 440 public Element getSubIndexes() { 441 441 return getOrCreateElementByTagName(SUBCOLLECTION_INDEXES_ELEMENT, null, null); 442 443 444 445 442 } 443 444 /** Retrieve or create the supercollections Element. */ 445 public Element getSuperCollection() { 446 446 return getOrCreateElementByTagName(SUPERCOLLECTION_ELEMENT, null, null); 447 448 449 447 } 448 449 public boolean ready() { 450 450 return document != null; 451 452 453 451 } 452 453 public void save() { 454 454 save(false); 455 455 } 456 456 457 457 public void save(boolean force_xml) { … … 514 514 } 515 515 516 517 518 516 /** ************************** Private Methods ***************************/ 517 518 private String classifyToString(Element command_element, boolean show_extracted_namespace) { 519 519 StringBuffer text = new StringBuffer(CLASSIFY_STR); 520 520 text.append(TAB_CHARACTER); … … 524 524 int option_elements_length = option_elements.getLength(); 525 525 for(int j = 0; j < option_elements_length; j++) { 526 527 526 Element option_element = (Element) option_elements.item(j); 527 if(option_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) { 528 528 text.append(StaticStrings.MINUS_CHARACTER); 529 529 text.append(option_element.getAttribute(NAME_ATTRIBUTE)); 530 530 String value_str = MSMUtils.getValue(option_element); 531 531 if(value_str.length() > 0) { 532 533 532 // If the value happens to be the identifier of an extracted metadata element, then remove the namespace. 533 if(!show_extracted_namespace && value_str.startsWith(EXTRACTED_PREFIX)) { 534 534 value_str = value_str.substring(EXTRACTED_PREFIX.length()); 535 536 537 535 } 536 text.append(SPACE_CHARACTER); 537 if(value_str.indexOf(SPACE_CHARACTER) == -1) { 538 538 text.append(value_str); 539 540 539 } 540 else { 541 541 text.append(SPEECH_CHARACTER); 542 542 text.append(value_str); 543 543 text.append(SPEECH_CHARACTER); 544 544 } 545 545 } 546 546 value_str = null; 547 547 if(j < option_elements_length - 1) { 548 549 } 550 551 548 text.append(SPACE_CHARACTER); 549 } 550 } 551 option_element = null; 552 552 } 553 553 option_elements = null; 554 554 return text.toString(); 555 556 557 555 } 556 557 private String formatToString(Element command_element, boolean show_extracted_namespace) { 558 558 StringBuffer text = new StringBuffer(FORMAT_STR); 559 559 text.append(SPACE_CHARACTER); … … 562 562 String value_str = command_element.getAttribute(VALUE_ATTRIBUTE); 563 563 if(value_str.length() != 0) { 564 564 text.append(value_str); 565 565 } 566 566 else { 567 // Remember to encode format string to Greenstone specification568 value_str = Codec.transform(MSMUtils.getValue(command_element), Codec.DOM_TO_GREENSTONE);569 // Remove any references to a namespace for extracted metadata570 if(!show_extracted_namespace) {571 572 }573 text.append(SPEECH_CHARACTER);574 text.append(value_str);575 text.append(SPEECH_CHARACTER);567 // Remember to encode format string to Greenstone specification 568 value_str = Codec.transform(MSMUtils.getValue(command_element), Codec.DOM_TO_GREENSTONE); 569 // Remove any references to a namespace for extracted metadata 570 if(!show_extracted_namespace) { 571 value_str.replaceAll(EXTRACTED_PREFIX, ""); 572 } 573 text.append(SPEECH_CHARACTER); 574 text.append(value_str); 575 text.append(SPEECH_CHARACTER); 576 576 } 577 577 value_str = null; 578 578 return text.toString(); 579 580 581 582 579 } 580 581 /** Retrieve or create the indexes Element. */ 582 private Element getOrCreateElementByTagName(String name, String conditional_attribute, String required_value) { 583 583 Element document_element = document.getDocumentElement(); 584 584 NodeList elements = document_element.getElementsByTagName(name); 585 585 int elements_length = elements.getLength(); 586 586 if(elements_length > 0) { 587 587 if(conditional_attribute == null) { 588 588 document_element = null; 589 589 return (Element) elements.item(0); 590 591 590 } 591 else { 592 592 for(int i = 0; i < elements_length; i++) { 593 594 593 Element element = (Element) elements.item(i); 594 if(element.getAttribute(conditional_attribute).equals(required_value)) { 595 595 document_element = null; 596 596 return element; 597 598 599 } 600 597 } 598 element = null; 599 } 600 } 601 601 } 602 602 // Create the element … … 604 604 // If there was a property set it 605 605 if(conditional_attribute != null) { 606 606 element.setAttribute(conditional_attribute, required_value); 607 607 } 608 608 Node target_node = findInsertionPoint(element); 609 609 if(target_node != null) { 610 610 document_element.insertBefore(element, target_node); 611 611 } 612 612 else { 613 613 document_element.appendChild(element); 614 614 } 615 615 document_element = null; 616 616 return element; 617 618 619 617 } 618 619 private String indexesToString(Element command_element, boolean show_extracted_namespace) { 620 620 boolean comment_only = false; 621 621 StringBuffer text = new StringBuffer(""); 622 622 if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR)) { 623 624 623 text.append("#"); 624 comment_only = true; 625 625 } 626 626 text.append(INDEX_STR); 627 627 text.append(TAB_CHARACTER); 628 628 if(!comment_only) { 629 629 text.append(TAB_CHARACTER); 630 630 } 631 631 NodeList index_elements = command_element.getElementsByTagName(INDEX_ELEMENT); 632 632 if (index_elements.getLength() == 0) { // no indexes 633 633 return ""; 634 634 } 635 635 // For each index, write its level, a colon, then concatenate its child content elements into a single comma separated list 636 636 int index_elements_length = index_elements.getLength(); 637 637 for(int j = 0; j < index_elements_length; j++) { 638 639 640 638 Element index_element = (Element) index_elements.item(j); 639 String level_str = index_element.getAttribute(LEVEL_ATTRIBUTE); 640 if(level_str.length() > 0) { 641 641 text.append(level_str); 642 642 text.append(StaticStrings.COLON_CHARACTER); 643 644 645 646 647 643 } 644 NodeList content_elements = index_element.getElementsByTagName(CONTENT_ELEMENT); 645 int content_elements_length = content_elements.getLength(); 646 // Don't output anything if no indexes are set 647 if(content_elements_length == 0) { 648 648 return null; 649 650 649 } 650 for(int k = 0; k < content_elements_length; k++) { 651 651 Element content_element = (Element) content_elements.item(k); 652 652 String name_str = content_element.getAttribute(NAME_ATTRIBUTE); 653 653 if(!show_extracted_namespace && name_str.startsWith(EXTRACTED_PREFIX)) { 654 654 name_str = name_str.substring(EXTRACTED_PREFIX.length()); 655 655 } 656 656 text.append(name_str); 657 657 name_str = null; 658 658 if(k < content_elements_length - 1) { 659 659 text.append(StaticStrings.COMMA_CHARACTER); 660 660 } 661 661 content_element = null; 662 663 662 } 663 if(j < index_elements_length - 1) { 664 664 text.append(SPACE_CHARACTER); 665 666 667 665 } 666 content_elements = null; 667 index_element = null; 668 668 } 669 669 index_elements = null; 670 670 return text.toString(); 671 672 673 671 } 672 673 private String indexDefaultToString(Element command_element, boolean show_extracted_namespace) { 674 674 StringBuffer text = new StringBuffer(""); 675 675 if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(FALSE_STR)) { 676 676 text.append("#"); 677 677 } 678 678 text.append(INDEX_DEFAULT_STR); … … 683 683 int content_elements_length = content_elements.getLength(); 684 684 for(int j = 0; j < content_elements_length; j++) { 685 686 687 685 Element content_element = (Element) content_elements.item(j); 686 String name_str = content_element.getAttribute(NAME_ATTRIBUTE); 687 if(!show_extracted_namespace && name_str.startsWith(EXTRACTED_PREFIX)) { 688 688 name_str = name_str.substring(EXTRACTED_PREFIX.length()); 689 690 691 692 689 } 690 text.append(name_str); 691 name_str = null; 692 if(j < content_elements_length - 1) { 693 693 text.append(StaticStrings.COMMA_CHARACTER); 694 695 694 } 695 content_element = null; 696 696 } 697 697 content_elements = null; 698 698 return text.toString(); 699 700 701 699 } 700 701 private String languagesToString(Element command_element) { 702 702 StringBuffer text = new StringBuffer(LANGUAGES_STR); 703 703 text.append(TAB_CHARACTER); … … 706 706 int language_elements_length = language_elements.getLength(); 707 707 if(language_elements_length == 0) { 708 708 return null; 709 709 } 710 710 for(int j = 0; j < language_elements_length; j++) { 711 712 713 711 Element language_element = (Element) language_elements.item(j); 712 text.append(language_element.getAttribute(NAME_ATTRIBUTE)); 713 if(j < language_elements_length - 1) { 714 714 text.append(SPACE_CHARACTER); 715 715 } 716 716 } 717 717 return text.toString(); 718 719 720 718 } 719 720 private String languageDefaultToString(Element command_element) { 721 721 StringBuffer text = new StringBuffer(LANGUAGE_DEFAULT_STR); 722 722 text.append(TAB_CHARACTER); 723 723 text.append(command_element.getAttribute(NAME_ATTRIBUTE)); 724 724 return text.toString(); 725 726 727 725 } 726 727 private String levelsToString(Element command_element) { 728 728 StringBuffer text = new StringBuffer(""); 729 729 if(!command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) { 730 730 text.append("#"); 731 731 } 732 732 text.append(LEVELS_STR); … … 737 737 // Don't output anything if no levels are set. 738 738 if(content_elements_length == 0) { 739 739 return null; 740 740 } 741 741 for(int i = 0; i < content_elements_length; i++) { 742 743 744 742 Element content_element = (Element) content_elements.item(i); 743 text.append(content_element.getAttribute(NAME_ATTRIBUTE)); 744 text.append(SPACE_CHARACTER); 745 745 } 746 746 return text.substring(0, text.length() - 1); 747 748 749 747 } 748 749 static public String metadataToString(Element command_element, boolean text_value) { 750 750 boolean special = false; 751 751 // If there is no value attribute, then we don't write anything … … 754 754 // If the name is one of the special four, we don't write the collectionmeta first. Note the maintainer collectionmeta is singled out for 'prittying' reasons. 755 755 if(name_str.equals(COLLECTIONMETADATA_MAINTAINER_STR)) { 756 757 758 756 text.append(name_str); 757 text.append(TAB_CHARACTER); 758 special = true; 759 759 } 760 760 else if(name_str.equals(COLLECTIONMETADATA_BETA_STR) || name_str.equals(COLLECTIONMETADATA_CREATOR_STR) || name_str.equals(COLLECTIONMETADATA_PUBLIC_STR)) { 761 762 763 764 761 text.append(name_str); 762 text.append(TAB_CHARACTER); 763 text.append(TAB_CHARACTER); 764 special = true; 765 765 } 766 766 else { 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 767 text.append(COLLECTIONMETADATA_STR); 768 text.append(TAB_CHARACTER); 769 text.append(name_str); 770 text.append(SPACE_CHARACTER); 771 String language_str = command_element.getAttribute(LANGUAGE_ATTRIBUTE); 772 // If this is element is in english, and it is the first one found, we don't need to write the language argument. 773 //if(!language_str.equals(ENGLISH_LANGUAGE_STR) || known_metadata == null || known_metadata.contains(name_str)) { 774 // changed so that we always write the language string 775 text.append(LBRACKET_CHARACTER); 776 text.append(LANGUAGE_ARGUMENT); 777 text.append(language_str); 778 text.append(RBRACKET_CHARACTER); 779 text.append(SPACE_CHARACTER); 780 //} 781 if(known_metadata != null) { 782 782 known_metadata.add(name_str); 783 784 783 } 784 language_str = null; 785 785 } 786 786 name_str = null; … … 789 789 // The value string we retrieved will be encoded for xml, so we now decode it - to text if text_value set. This parameter was originally show_extracted_namespace, but sincethis is only true for 'toString()' commands from within the CDM, its good enough to determine if this toString() will be used to display on screen, or write to collect.cfg 790 790 if(text_value == CollectionMeta.TEXT) { 791 791 value_str = Codec.transform(value_str, Codec.DOM_TO_TEXT); 792 792 } 793 793 else { 794 794 value_str = Codec.transform(value_str, Codec.DOM_TO_GREENSTONE); 795 795 } 796 796 797 797 // We don't wrap the email addresses in quotes, nor the other special metadata 798 798 if(special) { 799 799 text.append(value_str); 800 800 } 801 801 else { 802 803 804 802 text.append(SPEECH_CHARACTER); 803 text.append(value_str); 804 text.append(SPEECH_CHARACTER); 805 805 } 806 806 value_str = null; 807 807 return text.toString(); 808 808 } 809 809 810 810 /** Parse a collect.cfg into a DOM model representation. */ … … 838 838 buffered_reader_one = null; 839 839 reader_one = null; 840 input_stream_one = null; 840 input_stream_one = null; 841 841 842 842 Element collect_cfg_element = document.getDocumentElement(); … … 1096 1096 Element command_element = null; 1097 1097 try { 1098 1099 1100 1098 CommandTokenizer tokenizer = new CommandTokenizer(command_str); 1099 // Check the token count. The token count from a command tokenizer isn't guarenteed to be correct, but it does give the maximum number of available tokens according to the underlying StringTokenizer (some of which may actually be append together by the CommandTokenizer as being a single argument). 1100 if(tokenizer.countTokens() >= 2) { // Must support "classify Phind" (no args) 1101 1101 command_element = document.createElement(CLASSIFY_ELEMENT); 1102 1102 // First token is classify … … 1109 1109 Iterator names = arguments.keySet().iterator(); 1110 1110 while(names.hasNext()) { 1111 1112 1113 1114 1111 String name = (String) names.next(); 1112 String value = (String) arguments.get(name); // Can be null 1113 // The metadata argument gets added as the content attribute 1114 if(name.equals(METADATA_ARGUMENT) && value != null) { 1115 1115 // The metadata argument must be the fully qualified name of a metadata element, so if it doesn't yet have a namespace, append the extracted metadata namespace. 1116 1116 if(value.indexOf(MSMUtils.NS_SEP) == -1) { 1117 1117 value = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + value; 1118 1118 } 1119 1119 //command_element.setAttribute(CONTENT_ATTRIBUTE, value); 1120 1121 1122 1123 1124 1120 } 1121 // Everything else is an Option Element 1122 Element option_element = document.createElement(OPTION_ELEMENT); 1123 option_element.setAttribute(NAME_ATTRIBUTE, name.substring(1)); 1124 if(value != null) { 1125 1125 // Remove any speech marks appended in strings containing whitespace 1126 1126 if(value.startsWith(SPEECH_CHARACTER) && value.endsWith(SPEECH_CHARACTER)) { 1127 1127 value = value.substring(1, value.length() - 1); 1128 1128 } 1129 1129 MSMUtils.setValue(option_element, value); 1130 1131 1132 1133 1134 1135 1136 1130 } 1131 option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR); 1132 option_element.setAttribute(CUSTOM_ATTRIBUTE, TRUE_STR); 1133 command_element.appendChild(option_element); 1134 option_element = null; 1135 name = null; 1136 value = null; 1137 1137 } 1138 1138 names = null; 1139 1139 arguments = null; 1140 1141 1140 } 1141 tokenizer = null; 1142 1142 } 1143 1143 catch(Exception error) { 1144 1144 } 1145 1145 return command_element; 1146 1146 } 1147 1147 1148 1148 private Element parseFormat(CommandTokenizer tokenizer) { … … 1178 1178 } 1179 1179 1180 1180 private Element parseIndex(String command_str) { 1181 1181 Element command_element = null; 1182 1182 try { 1183 1184 1185 1186 1187 1188 1183 StringTokenizer tokenizer = new StringTokenizer(command_str); 1184 String command = tokenizer.nextToken(); 1185 command_element = document.createElement(INDEXES_ELEMENT); 1186 command_element.setAttribute(ASSIGNED_ATTRIBUTE, (command.equals(INDEX_STR) ? TRUE_STR : FALSE_STR)); 1187 command = null; 1188 if(!tokenizer.hasMoreTokens()) { 1189 1189 1190 1190 // there are no indexes … … 1193 1193 tokenizer = null; 1194 1194 return command_element; 1195 1196 1197 1195 } 1196 1197 while(tokenizer.hasMoreTokens()) { 1198 1198 Element index_element = document.createElement(INDEX_ELEMENT); 1199 1199 String index_str = tokenizer.nextToken(); … … 1201 1201 boolean old_index; 1202 1202 if(index_str.indexOf(COLON_CHARACTER) != -1) { 1203 1204 1205 1206 1203 old_index = true; 1204 index_element.setAttribute(LEVEL_ATTRIBUTE, index_str.substring(0, index_str.indexOf(StaticStrings.COLON_CHARACTER))); 1205 index_str = index_str.substring(index_str.indexOf(StaticStrings.COLON_CHARACTER) + 1); 1206 command_element.setAttribute(MGPP_ATTRIBUTE, FALSE_STR); 1207 1207 } 1208 1208 else { 1209 1210 1209 command_element.setAttribute(MGPP_ATTRIBUTE, TRUE_STR); 1210 old_index = false; 1211 1211 } 1212 1212 StringTokenizer content_tokenizer = new StringTokenizer(index_str, StaticStrings.COMMA_CHARACTER); 1213 1213 while(content_tokenizer.hasMoreTokens()) { 1214 1215 1216 1217 1214 Element content_element = document.createElement(CONTENT_ELEMENT); 1215 String content_str = content_tokenizer.nextToken(); 1216 // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace. 1217 if(content_str.indexOf(MSMUtils.NS_SEP) == -1) { 1218 1218 if(content_str.equals(StaticStrings.TEXT_STR) || (!old_index && content_str.equals(StaticStrings.ALLFIELDS_STR))) { 1219 1219 // Our special strings are OK. 1220 1220 } 1221 1221 else { 1222 1222 content_str = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + content_str; 1223 1223 } 1224 1225 1226 1227 1224 } 1225 content_element.setAttribute(NAME_ATTRIBUTE, content_str); 1226 index_element.appendChild(content_element); 1227 content_element = null; 1228 1228 } 1229 1229 content_tokenizer = null; … … 1231 1231 command_element.appendChild(index_element); 1232 1232 index_element = null; 1233 1234 1233 } 1234 tokenizer = null; 1235 1235 } 1236 1236 catch (Exception exception) { 1237 1237 exception.printStackTrace(); 1238 1238 } 1239 1239 return command_element; 1240 1241 1242 1240 } 1241 1242 private Element parseIndexDefault(String command_str) { 1243 1243 Element command_element = null; 1244 1244 try { 1245 1246 1245 StringTokenizer tokenizer = new StringTokenizer(command_str); 1246 if(tokenizer.countTokens() >= 2) { 1247 1247 command_element = document.createElement(INDEX_DEFAULT_ELEMENT); 1248 1248 command_element.setAttribute(ASSIGNED_ATTRIBUTE, ((tokenizer.nextToken()).equals(INDEX_DEFAULT_STR) ? TRUE_STR : FALSE_STR)); … … 1252 1252 StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER); 1253 1253 while(content_tokenizer.hasMoreTokens()) { 1254 1255 1256 1257 1254 Element content_element = document.createElement(CONTENT_ELEMENT); 1255 content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken()); 1256 command_element.appendChild(content_element); 1257 content_element = null; 1258 1258 } 1259 1259 content_tokenizer = null; … … 1261 1261 content_str = null; 1262 1262 index_str = null; 1263 1264 1263 } 1264 tokenizer = null; 1265 1265 } 1266 1266 catch (Exception exception) { 1267 1267 } 1268 1268 return command_element; 1269 1270 1271 1269 } 1270 1271 private Element parseLanguage(String command_str) { 1272 1272 Element command_element = null; 1273 1273 try { 1274 1275 1276 1274 StringTokenizer tokenizer = new StringTokenizer(command_str); 1275 tokenizer.nextToken(); 1276 if(tokenizer.hasMoreTokens()) { 1277 1277 command_element = document.createElement(LANGUAGES_ELEMENT); 1278 1278 while(tokenizer.hasMoreTokens()) { 1279 1280 1281 1282 1283 } 1284 1285 1279 Element language_element = document.createElement(LANGUAGE_ELEMENT); 1280 language_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken()); 1281 command_element.appendChild(language_element); 1282 language_element = null; 1283 } 1284 } 1285 tokenizer = null; 1286 1286 } 1287 1287 catch (Exception exception) { 1288 1288 } 1289 1289 return command_element; 1290 1291 1292 1290 } 1291 1292 private Element parseLanguageDefault(String command_str) { 1293 1293 Element command_element = null; 1294 1294 try { 1295 1296 1295 StringTokenizer tokenizer = new StringTokenizer(command_str); 1296 if(tokenizer.countTokens() >= 2) { 1297 1297 command_element = document.createElement(LANGUAGE_DEFAULT_ELEMENT); 1298 1298 tokenizer.nextToken(); … … 1301 1301 command_element.setAttribute(ASSIGNED_ATTRIBUTE, StaticStrings.TRUE_STR); 1302 1302 default_language_str = null; 1303 1304 1303 } 1304 tokenizer = null; 1305 1305 } 1306 1306 catch (Exception exception) { 1307 1307 } 1308 1308 return command_element; 1309 1310 1311 1309 } 1310 1311 private Element parseLevels(String command_str) { 1312 1312 Element command_element = null; 1313 1313 try { 1314 1315 1316 1317 1314 StringTokenizer tokenizer = new StringTokenizer(command_str); 1315 // First token is command type (levels) 1316 String command = tokenizer.nextToken(); 1317 if(tokenizer.hasMoreTokens()) { 1318 1318 command_element = document.createElement(LEVELS_ELEMENT); 1319 1319 command_element.setAttribute(ASSIGNED_ATTRIBUTE, (command.equals(LEVELS_STR) ? TRUE_STR : FALSE_STR)); 1320 1320 while(tokenizer.hasMoreTokens()) { 1321 1322 1323 1324 1325 } 1326 1327 1321 Element level_element = document.createElement(CONTENT_ELEMENT); 1322 level_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken()); 1323 command_element.appendChild(level_element); 1324 level_element = null; 1325 } 1326 } 1327 command = null; 1328 1328 } 1329 1329 catch(Exception exception) { 1330 1330 } 1331 1331 return command_element; 1332 1332 } 1333 1333 1334 1334 private Element parseMetadata(CommandTokenizer tokenizer) { … … 1371 1371 } 1372 1372 1373 1373 private Element parseMetadataSpecial(String command_str) { 1374 1374 Element command_element = null; 1375 1375 try { 1376 1377 1376 StringTokenizer tokenizer = new StringTokenizer(command_str); 1377 if(tokenizer.countTokens() >= 2) { 1378 1378 String name_str = tokenizer.nextToken(); 1379 1379 String value_str = tokenizer.nextToken(); 1380 1380 if(name_str.equals(COLLECTIONMETADATA_BETA_STR)) { 1381 1381 command_element = document.createElement(COLLECTIONMETADATA_BETA_ELEMENT); 1382 1382 } 1383 1383 else if(name_str.equals(COLLECTIONMETADATA_CREATOR_STR)) { 1384 1384 command_element = document.createElement(COLLECTIONMETADATA_CREATOR_ELEMENT); 1385 1385 } 1386 1386 else if(name_str.equals(COLLECTIONMETADATA_MAINTAINER_STR)) { 1387 1387 command_element = document.createElement(COLLECTIONMETADATA_MAINTAINER_ELEMENT); 1388 1388 } 1389 1389 else if(name_str.equals(COLLECTIONMETADATA_PUBLIC_STR)) { 1390 1390 command_element = document.createElement(COLLECTIONMETADATA_PUBLIC_ELEMENT); 1391 1391 } 1392 1392 if(command_element != null) { 1393 1394 1395 1396 1397 1393 command_element.setAttribute(NAME_ATTRIBUTE, name_str); 1394 command_element.setAttribute(LANGUAGE_ATTRIBUTE, ENGLISH_LANGUAGE_STR); 1395 command_element.setAttribute(SPECIAL_ATTRIBUTE, TRUE_STR); 1396 command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR); 1397 if(value_str.startsWith(SPEECH_CHARACTER) && value_str.endsWith(SPEECH_CHARACTER)) { 1398 1398 value_str = value_str.substring(1, value_str.length() - 1); 1399 1400 1399 } 1400 MSMUtils.setValue(command_element, value_str); 1401 1401 } 1402 1402 value_str = null; 1403 1403 name_str = null; 1404 1405 1404 } 1405 tokenizer = null; 1406 1406 } 1407 1407 catch (Exception exception) { 1408 1408 } 1409 1409 return command_element; 1410 1411 1412 1410 } 1411 1412 private Element parsePlugIn(String command_str) { 1413 1413 Element command_element = null; 1414 1414 boolean use_metadata_files = false; 1415 1415 try { 1416 1417 1418 1416 CommandTokenizer tokenizer = new CommandTokenizer(command_str); 1417 // Check the token count. The token count from a command tokenizer isn't guarenteed to be correct, but it does give the maximum number of available tokens according to the underlying StringTokenizer (some of which may actually be append together by the CommandTokenizer as being a single argument). 1418 if(tokenizer.countTokens() >= 2) { 1419 1419 command_element = document.createElement(PLUGIN_ELEMENT); 1420 1420 // First token is plugin … … 1428 1428 Iterator names = arguments.keySet().iterator(); 1429 1429 while(names.hasNext()) { 1430 1431 1432 1433 1430 String name = (String) names.next(); 1431 String value = (String) arguments.get(name); // Can be null 1432 Element option_element = document.createElement(OPTION_ELEMENT); 1433 if(name.substring(1).equals(USE_METADATA_FILES_ARGUMENT)) { 1434 1434 use_metadata_files = true; 1435 1436 1437 1438 1439 1435 } 1436 option_element.setAttribute(NAME_ATTRIBUTE, name.substring(1)); 1437 option_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR); 1438 option_element.setAttribute(CUSTOM_ATTRIBUTE, TRUE_STR); // All arguments are considered to be custom until matched against base plugins arguments 1439 if(value != null) { 1440 1440 // Remove any speech marks appended in strings containing whitespace 1441 1441 if(value.startsWith(SPEECH_CHARACTER) && value.endsWith(SPEECH_CHARACTER)) { 1442 1442 value = value.substring(1, value.length() - 1); 1443 1443 } 1444 1444 if(name.equals(METADATA_ARGUMENT)) { 1445 1445 // The metadata argument must be the fully qualified name of a metadata element, so if it doesn't yet have a namespace, append the extracted metadata namespace. 1446 1446 if(value.indexOf(MSMUtils.NS_SEP) == -1) { 1447 1447 value = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + value; 1448 1448 } 1449 1449 } 1450 1450 MSMUtils.setValue(option_element, value); 1451 1452 1453 1454 1455 1451 } 1452 command_element.appendChild(option_element); 1453 option_element = null; 1454 name = null; 1455 value = null; 1456 1456 } 1457 1457 … … 1470 1470 names = null; 1471 1471 arguments = null; 1472 1473 1472 } 1473 tokenizer = null; 1474 1474 } 1475 1475 catch(Exception exception) { 1476 1476 } 1477 1477 return command_element; 1478 1479 1480 1478 } 1479 1480 private Element parseSearchType(String command_str) { 1481 1481 Element command_element = null; 1482 1482 try { 1483 1484 1485 1486 1483 StringTokenizer tokenizer = new StringTokenizer(command_str); 1484 // First token is command type (levels) 1485 tokenizer.nextToken(); 1486 if(tokenizer.hasMoreTokens()) { 1487 1487 command_element = document.createElement(SEARCHTYPE_ELEMENT); 1488 1488 command_element.setAttribute(ASSIGNED_ATTRIBUTE, TRUE_STR); 1489 1489 while(tokenizer.hasMoreTokens()) { 1490 1491 1492 1493 1494 } 1495 1490 Element search_element = document.createElement(CONTENT_ELEMENT); 1491 search_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken()); 1492 command_element.appendChild(search_element); 1493 search_element = null; 1494 } 1495 } 1496 1496 } 1497 1497 catch(Exception exception) { 1498 1498 } 1499 1499 return command_element; 1500 1501 1502 1500 } 1501 1502 private Element parseSubCollection(String command_str) { 1503 1503 Element command_element = null; 1504 1504 try { 1505 1506 1505 CommandTokenizer tokenizer = new CommandTokenizer(command_str); 1506 if(tokenizer.countTokens() >= 3) { 1507 1507 command_element = document.createElement(SUBCOLLECTION_ELEMENT); 1508 1508 // First token is command type … … 1516 1516 // Set inclusion/exclusion flag, remove any exclaimation mark and the speech marks 1517 1517 if(exclusion) { 1518 1519 1518 full_pattern_str = full_pattern_str.substring(2, full_pattern_str.length() - 1); 1519 command_element.setAttribute(TYPE_ATTRIBUTE, EXCLUDE_STR); 1520 1520 } 1521 1521 else { 1522 1523 1522 full_pattern_str = full_pattern_str.substring(1, full_pattern_str.length() - 1); 1523 command_element.setAttribute(TYPE_ATTRIBUTE, INCLUDE_STR); 1524 1524 } 1525 1525 StringTokenizer pattern_tokenizer = new StringTokenizer(full_pattern_str, SEPARATOR_CHARACTER); 1526 1526 if(pattern_tokenizer.countTokens() >= 2) { 1527 1528 1529 1527 String content_str = pattern_tokenizer.nextToken(); 1528 // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace. 1529 if(!content_str.equals(StaticStrings.FILENAME_STR) && content_str.indexOf(MSMUtils.NS_SEP) == -1) { 1530 1530 content_str = Utility.EXTRACTED_METADATA_NAMESPACE + MSMUtils.NS_SEP + content_str; 1531 1532 1533 1534 1531 } 1532 command_element.setAttribute(CONTENT_ATTRIBUTE, content_str); 1533 MSMUtils.setValue(command_element, pattern_tokenizer.nextToken()); 1534 if(pattern_tokenizer.hasMoreTokens()) { 1535 1535 command_element.setAttribute(OPTIONS_ATTRIBUTE, pattern_tokenizer.nextToken()); 1536 1536 } 1537 1537 } 1538 1538 pattern_tokenizer = null; 1539 1539 } 1540 1540 } 1541 1541 catch(Exception exception) { 1542 1542 exception.printStackTrace(); 1543 1543 } 1544 1544 return command_element; 1545 1546 1547 1545 } 1546 1547 private Element parseSubCollectionDefaultIndex(String command_str) { 1548 1548 Element command_element = null; 1549 1549 try { 1550 1551 1550 StringTokenizer tokenizer = new StringTokenizer(command_str); 1551 if(tokenizer.countTokens() == 2) { 1552 1552 command_element = document.createElement(SUBCOLLECTION_DEFAULT_INDEX_ELEMENT); 1553 1553 tokenizer.nextToken(); … … 1556 1556 StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER); 1557 1557 while(content_tokenizer.hasMoreTokens()) { 1558 1559 1560 1561 1558 Element content_element = document.createElement(CONTENT_ELEMENT); 1559 content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken()); 1560 command_element.appendChild(content_element); 1561 content_element = null; 1562 1562 } 1563 1563 content_tokenizer = null; 1564 1564 content_str = null; 1565 1566 1565 } 1566 tokenizer = null; 1567 1567 } 1568 1568 catch(Exception exception) { 1569 1569 } 1570 1570 return command_element; 1571 1572 1573 1571 } 1572 1573 private Element parseSubCollectionIndex(String command_str) { 1574 1574 Element command_element = null; 1575 1575 try { 1576 1577 1578 1576 StringTokenizer tokenizer = new StringTokenizer(command_str); 1577 tokenizer.nextToken(); 1578 if(tokenizer.hasMoreTokens()) { 1579 1579 command_element = document.createElement(SUBCOLLECTION_INDEXES_ELEMENT); 1580 1581 1580 } 1581 while(tokenizer.hasMoreTokens()) { 1582 1582 Element subcollectionindex_element = document.createElement(INDEX_ELEMENT); 1583 1583 //command_element.setAttribute(CONTENT_ATTRIBUTE, tokenizer.nextToken()); … … 1585 1585 StringTokenizer content_tokenizer = new StringTokenizer(content_str, StaticStrings.COMMA_CHARACTER); 1586 1586 while(content_tokenizer.hasMoreTokens()) { 1587 1588 1589 1590 1587 Element content_element = document.createElement(CONTENT_ELEMENT); 1588 content_element.setAttribute(NAME_ATTRIBUTE, content_tokenizer.nextToken()); 1589 subcollectionindex_element.appendChild(content_element); 1590 content_element = null; 1591 1591 } 1592 1592 content_tokenizer = null; … … 1594 1594 command_element.appendChild(subcollectionindex_element); 1595 1595 subcollectionindex_element = null; 1596 1597 1596 } 1597 tokenizer = null; 1598 1598 } 1599 1599 catch (Exception exception) { 1600 1600 } 1601 1601 return command_element; 1602 1603 1604 1602 } 1603 1604 private Element parseSuperCollection(String command_str) { 1605 1605 Element command_element = null; 1606 1606 try { 1607 1608 1607 StringTokenizer tokenizer = new StringTokenizer(command_str); 1608 if(tokenizer.countTokens() >= 3) { 1609 1609 command_element = document.createElement(SUPERCOLLECTION_ELEMENT); 1610 1610 tokenizer.nextToken(); 1611 1611 while(tokenizer.hasMoreTokens()) { 1612 1613 1614 1615 1616 } 1617 1618 1612 Element collection_element = document.createElement(COLLECTION_ELEMENT); 1613 collection_element.setAttribute(NAME_ATTRIBUTE, tokenizer.nextToken()); 1614 command_element.appendChild(collection_element); 1615 collection_element = null; 1616 } 1617 } 1618 tokenizer = null; 1619 1619 } 1620 1620 catch(Exception exception) { 1621 1621 } 1622 1622 return command_element; 1623 1624 1625 1623 } 1624 1625 private String pluginToString(Element command_element, boolean show_extracted_namespace) { 1626 1626 StringBuffer text = new StringBuffer(); 1627 1627 if(!command_element.getAttribute(SEPARATOR_ATTRIBUTE).equals(TRUE_STR)) { 1628 1629 1630 1631 1632 1633 1634 1635 1628 text.append(PLUGIN_STR); 1629 text.append(TAB_CHARACTER); 1630 text.append(TAB_CHARACTER); 1631 text.append(command_element.getAttribute(TYPE_ATTRIBUTE)); 1632 // Retrieve, and output, the arguments 1633 NodeList option_elements = command_element.getElementsByTagName(OPTION_ELEMENT); 1634 int option_elements_length = option_elements.getLength(); 1635 if(option_elements_length > 0) { 1636 1636 text.append(SPACE_CHARACTER); 1637 1637 for(int j = 0; j < option_elements_length; j++) { 1638 1639 1638 Element option_element = (Element) option_elements.item(j); 1639 if(option_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) { 1640 1640 text.append(StaticStrings.MINUS_CHARACTER); 1641 1641 text.append(option_element.getAttribute(NAME_ATTRIBUTE)); 1642 1642 String value_str = MSMUtils.getValue(option_element); 1643 1643 if(!show_extracted_namespace && value_str.startsWith(EXTRACTED_PREFIX)) { 1644 1644 value_str = value_str.substring(EXTRACTED_PREFIX.length()); 1645 1645 } 1646 1646 if(value_str.length() > 0) { 1647 1648 1647 text.append(SPACE_CHARACTER); 1648 if(value_str.indexOf(SPACE_CHARACTER) == -1) { 1649 1649 text.append(value_str); 1650 1651 1650 } 1651 else { 1652 1652 text.append(SPEECH_CHARACTER); 1653 1653 text.append(value_str); 1654 1654 text.append(SPEECH_CHARACTER); 1655 1655 } 1656 1656 } 1657 1657 value_str = null; 1658 1658 if(j < option_elements_length - 1) { 1659 1659 text.append(SPACE_CHARACTER); 1660 1660 } 1661 1662 1663 } 1664 1665 1661 } 1662 option_element = null; 1663 } 1664 } 1665 option_elements = null; 1666 1666 } 1667 1667 return text.toString(); 1668 1669 1670 1668 } 1669 1670 private String searchtypeToString(Element command_element) { 1671 1671 if(command_element.getAttribute(ASSIGNED_ATTRIBUTE).equals(TRUE_STR)) { 1672 1673 1674 1675 1676 1672 StringBuffer text = new StringBuffer(SEARCHTYPE_STR); 1673 text.append(TAB_CHARACTER); 1674 NodeList search_elements = command_element.getElementsByTagName(CONTENT_ELEMENT); 1675 int search_elements_length = search_elements.getLength(); 1676 for(int i = 0; i < search_elements_length; i++) { 1677 1677 Element search_element = (Element) search_elements.item(i); 1678 1678 text.append(search_element.getAttribute(NAME_ATTRIBUTE)); 1679 1679 text.append(SPACE_CHARACTER); 1680 1681 1680 } 1681 return text.substring(0, text.length() - 1); 1682 1682 } 1683 1683 else { 1684 1685 } 1686 1687 1688 1684 return null; 1685 } 1686 } 1687 1688 private String subcollectionToString(Element command_element, boolean show_extracted_namespace) { 1689 1689 StringBuffer text = new StringBuffer(SUBCOLLECTION_STR); 1690 1690 text.append(SPACE_CHARACTER); … … 1694 1694 text.append(SPEECH_CHARACTER); 1695 1695 if(command_element.getAttribute(TYPE_ATTRIBUTE).equals(EXCLUDE_STR)) { 1696 1696 text.append(EXCLAIMATION_CHARACTER); 1697 1697 } 1698 1698 String content_str = command_element.getAttribute(CONTENT_ATTRIBUTE); 1699 1699 if(!show_extracted_namespace && content_str.startsWith(EXTRACTED_PREFIX)) { 1700 1700 content_str = content_str.substring(EXTRACTED_PREFIX.length()); 1701 1701 } 1702 1702 text.append(content_str); … … 1707 1707 String options_str = command_element.getAttribute(OPTIONS_ATTRIBUTE); 1708 1708 if(options_str.length() > 0) { 1709 1709 text.append(options_str); 1710 1710 } 1711 1711 options_str = null; 1712 1712 text.append(SPEECH_CHARACTER); 1713 1713 return text.toString(); 1714 1715 1716 1714 } 1715 1716 private String subcollectionDefaultIndexToString(Element command_element) { 1717 1717 StringBuffer text = new StringBuffer(SUBCOLLECTION_DEFAULT_INDEX_STR); 1718 1718 text.append(TAB_CHARACTER); … … 1720 1720 int content_elements_length = content_elements.getLength(); 1721 1721 for(int j = 0; j < content_elements_length; j++) { 1722 1723 1724 1722 Element content_element = (Element) content_elements.item(j); 1723 text.append(content_element.getAttribute(NAME_ATTRIBUTE)); 1724 if(j < content_elements_length - 1) { 1725 1725 text.append(StaticStrings.COMMA_CHARACTER); 1726 1726 } 1727 1727 } 1728 1728 return text.toString(); 1729 1730 1731 1729 } 1730 1731 private String subcollectionIndexesToString(Element command_element) { 1732 1732 StringBuffer text = new StringBuffer(SUBCOLLECTION_INDEX_STR); 1733 1733 text.append(TAB_CHARACTER); … … 1736 1736 int subcollectionindex_elements_length = subcollectionindex_elements.getLength(); 1737 1737 if(subcollectionindex_elements_length == 0) { 1738 1738 return null; 1739 1739 } 1740 1740 for(int j = 0; j < subcollectionindex_elements_length; j++) { 1741 1742 1743 1744 1741 Element subcollectionindex_element = (Element) subcollectionindex_elements.item(j); 1742 NodeList content_elements = subcollectionindex_element.getElementsByTagName(CONTENT_ELEMENT); 1743 int content_elements_length = content_elements.getLength(); 1744 for(int k = 0; k < content_elements_length; k++) { 1745 1745 Element content_element = (Element) content_elements.item(k); 1746 1746 text.append(content_element.getAttribute(NAME_ATTRIBUTE)); 1747 1747 if(k < content_elements_length - 1) { 1748 1749 } 1750 1751 1748 text.append(StaticStrings.COMMA_CHARACTER); 1749 } 1750 } 1751 if(j < subcollectionindex_elements_length - 1) { 1752 1752 text.append(SPACE_CHARACTER); 1753 1753 } 1754 1754 } 1755 1755 return text.toString(); 1756 1757 1758 1756 } 1757 1758 private String supercollectionToString(Element command_element) { 1759 1759 NodeList content_elements = command_element.getElementsByTagName(COLLECTION_ELEMENT); 1760 1760 int content_elements_length = content_elements.getLength(); 1761 1761 if(content_elements_length > 1) { 1762 1763 1764 1762 StringBuffer text = new StringBuffer(SUPERCOLLECTION_STR); 1763 text.append(TAB_CHARACTER); 1764 for(int j = 0; j < content_elements_length; j++) { 1765 1765 Element content_element = (Element) content_elements.item(j); 1766 1766 text.append(content_element.getAttribute(NAME_ATTRIBUTE)); 1767 1767 if(j < content_elements_length - 1) { 1768 1769 } 1770 1771 1768 text.append(SPACE_CHARACTER); 1769 } 1770 } 1771 return text.toString(); 1772 1772 } 1773 1773 return null; 1774 1775 1776 1774 } 1775 1776 private String unknownToString(Element command_element) { 1777 1777 return MSMUtils.getValue(command_element); 1778 1779 1780 1781 1782 1783 1784 1778 } 1779 1780 /** Write the text to the buffer. This is used so we don't have to worry about storing intermediate String values just so we can calaulate length and offset. 1781 * @param writer the BufferedWriter to which the str will be written 1782 * @param str the String to be written 1783 */ 1784 private void write(BufferedWriter writer, String str) 1785 1785 throws IOException { 1786 1786 writer.write(str, 0, str.length()); 1787 1787 } 1788 1788 }
Note:
See TracChangeset
for help on using the changeset viewer.
