source: trunk/gli/src/org/greenstone/gatherer/msm/GDMDocument.java@ 6158

Last change on this file since 6158 was 6158, checked in by jmt12, 20 years ago

Removed a debug comment that had escaped me
  • Property svn:keywords set to Author Date Id Revision
File size: 26.4 KB
Line 
1/**
2 *#########################################################################
3 *
4 * A component of the Gatherer application, part of the Greenstone digital
5 * library suite from the New Zealand Digital Library Project at the
6 * University of Waikato, New Zealand.
7 *
8 * Author: John Thompson, Greenstone Digital Library, University of Waikato
9 *
10 * Copyright (C) 1999 New Zealand Digital Library Project
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 *########################################################################
26 */
27package org.greenstone.gatherer.msm;
28
29import java.io.*;
30import java.util.*;
31import org.greenstone.gatherer.Gatherer;
32import org.greenstone.gatherer.msm.GDMManager;
33import org.greenstone.gatherer.msm.MSMUtils;
34import org.greenstone.gatherer.util.Codec;
35import org.greenstone.gatherer.util.HashMap3D;
36import org.greenstone.gatherer.util.StaticStrings;
37import org.greenstone.gatherer.util.Utility;
38import org.greenstone.gatherer.valuetree.GValueModel;
39import org.greenstone.gatherer.valuetree.GValueNode;
40import org.w3c.dom.*;
41
42/** This class wraps around a DOM Document providing methods for accessing the data within. In this case the DOM represents a Greenstone Directory metadata file. It provides the necessary functionality to create a new metadata.xml file.
43 * @author John Thompson, Greenstone Digital Library, University of Waikato
44 * @version 2.3b
45 */
46public class GDMDocument {
47 /** Record if the document this object is based on is up to date. */
48 private boolean up_to_date = true;
49 /** The document this class sources its data from. */
50 private Document base_document;
51 static final private String ACCUMULATE = "accumulate";
52 /** The pattern to match when searching for directory level assignments. */
53 static final private String DIRECTORY_FILENAME = ".*";
54 static final private String DESCRIPTION_ELEMENT = "Description";
55 static final private String FILENAME_ELEMENT = "FileName";
56 static final private String FILESET_ELEMENT = "FileSet";
57 static final private String HVALUE_ATTRIBUTE = "hvalue";
58 static final private String MODE_ATTRIBUTE = "mode";
59 static final private String OVERWRITE = "overwrite";
60 static final private String[] ALL_METADATA_TYPES = {StaticStrings.METADATA_ELEMENT, StaticStrings.EXTRACTED_METADATA_ELEMENT};
61
62 /** Constructor which creates a brand new metadata.xml document. */
63 public GDMDocument() {
64 // Create new document. We do this by loading a copy of the template. */
65 this.base_document = Utility.parse(Utility.GREENSTONEDIRECTORYMETADATA_TEMPLATE, true);
66 }
67
68 /** Constructor which parses an existing metadata.xml document. */
69 public GDMDocument(File file) {
70 try {
71 this.base_document = Utility.parse(file.getAbsolutePath(), false);
72 }
73 catch (Exception error) {
74 // Poorly formed, or completely invalid metadata.xml file!
75 }
76 }
77
78 /** Constructor which wraps around an existing metadata.xml document. */
79 public GDMDocument(Document base_document) {
80 this.base_document = base_document;
81 }
82
83 /** Add this metadata to the named file. There is one tricky thing to consider. Whenever a metadata entry is added it is taken to be accumulating except if it is the first added, in which case it overwrites! Actually this gets worse, as we could have been told to append this metadata to a document which already inherits metadata. Thus we need a new argument to determine whether this add was triggered by an append or a replace. */
84 public void addMetadata(String filename, Metadata metadata, boolean force_accumulate) {
85 ///atherer.println("Add '" + metadata + "' to " + (filename != null ? filename : "directory."));
86 try {
87 // Retrieve the document element.
88 Element directorymetadata_element = base_document.getDocumentElement();
89 // Iterate through the filesets looking for one that matches the given filename.
90 Element fileset_element = null;
91 boolean found = false;
92 NodeList fileset_elements = directorymetadata_element.getElementsByTagName(FILESET_ELEMENT);
93 for(int i = 0; !found && i < fileset_elements.getLength(); i++) {
94 fileset_element = (Element) fileset_elements.item(i);
95 NodeList filename_elements = fileset_element.getElementsByTagName(FILENAME_ELEMENT);
96 for(int j = 0; !found && j < filename_elements.getLength(); j++) {
97 Element filename_element = (Element) filename_elements.item(j);
98 String filename_pattern = MSMUtils.getValue(filename_element);
99 // Have we found a match. If so break out of for loop.
100 if(filename != null && filename.matches(filename_pattern) && !filename_pattern.equals(DIRECTORY_FILENAME)) {
101 ///ystem.err.println("Adding to existing file fileset!");
102 found = true;
103 }
104 else if(filename == null && filename_pattern.equals(DIRECTORY_FILENAME)) {
105 ///ystem.err.println("Adding to existing folder fileset!");
106 ///ystem.err.println("filename_pattern = '" + filename_pattern + "'");
107 found = true;
108 }
109 // No match. On to the next one.
110 else {
111 fileset_element = null;
112 }
113 filename_pattern = null;
114 filename_element = null;
115 }
116 }
117 fileset_elements = null;
118 // If we still haven't found an existing fileset, then its time to create one.
119 if(fileset_element == null) {
120 ///ystem.err.println("Creating a new fileset.");
121 fileset_element = base_document.createElement(FILESET_ELEMENT);
122 Element filename_element = base_document.createElement(FILENAME_ELEMENT);
123 Element description_element = base_document.createElement(DESCRIPTION_ELEMENT);
124 fileset_element.appendChild(filename_element);
125 fileset_element.appendChild(description_element);
126 Text filename_text = null;
127 // If the filename is null then we add a directory metadata set as directorymetadata_element's first child
128 if(filename == null) {
129 filename_text = base_document.createTextNode(DIRECTORY_FILENAME);
130 if(directorymetadata_element.hasChildNodes()) {
131 directorymetadata_element.insertBefore(fileset_element, directorymetadata_element.getFirstChild());
132 }
133 else {
134 directorymetadata_element.appendChild(fileset_element);
135 }
136 }
137 // Otherwise we just append the new fileset to directorymetadata_element's children.
138 else {
139 filename_text = base_document.createTextNode(filename);
140 directorymetadata_element.appendChild(fileset_element);
141 }
142 filename_element.appendChild(filename_text);
143 filename_text = null;
144 description_element = null;
145 filename_element = null;
146 }
147 // Now, finally, we can add the metadata.
148 Element metadata_element = null;
149 String name = metadata.getElement().getName();
150 // If this is extracted metadata, we use a special element name that won't be recognized by greenstone
151 if(name.startsWith(Utility.EXTRACTED_METADATA_NAMESPACE)) {
152 metadata_element = base_document.createElement(ALL_METADATA_TYPES[1]);
153 name = name.substring(Utility.EXTRACTED_METADATA_NAMESPACE.length() + 1);
154 }
155 else {
156 metadata_element = base_document.createElement(ALL_METADATA_TYPES[0]);
157 }
158 metadata_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, name);
159
160 // To determine if this metadata entry should overwrite or accumulate we check if there are other entries with the same element in this fileset.
161 boolean will_accumulate = false;
162 NodeList sibling_description_elements = fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT);
163 for(int k = 0; !will_accumulate && k < sibling_description_elements.getLength(); k++) {
164 Element sibling_description_element = (Element) sibling_description_elements.item(k);
165 // We have to do this for each type of metadata
166 for(int z = 0; z < ALL_METADATA_TYPES.length; z++) {
167 NodeList sibling_metadata_elements = sibling_description_element.getElementsByTagName(ALL_METADATA_TYPES[z]);
168 for(int l = 0; !will_accumulate && l < sibling_metadata_elements.getLength(); l++) {
169 Element sibling_metadata_element = (Element) sibling_metadata_elements.item(l);
170 // It appears that its possible that we can be asked to add the same metadata twice (especially after a copy action is cancelled then repeated). So we check if we have been asked to add exactly the same value twice.
171 if(sibling_metadata_element.getAttribute(StaticStrings.NAME_ATTRIBUTE).equals(metadata_element.getAttribute(StaticStrings.NAME_ATTRIBUTE))) {
172 // Check the values and return if they are the same.
173 if(metadata.getAbsoluteValue().equals(MSMUtils.getValue(sibling_metadata_element))) {
174 return;
175 }
176 will_accumulate = true;
177 }
178 sibling_metadata_element = null;
179 }
180 sibling_metadata_elements = null;
181 }
182 sibling_description_element = null;
183 }
184 sibling_description_elements = null;
185 if(will_accumulate || force_accumulate) { //mode.equals(ACCUMULATE)) {
186 metadata_element.setAttribute(MODE_ATTRIBUTE, ACCUMULATE);
187 }
188 // As we can't possibly store all the metadata in memory, nor can we ensure that the indexes written to file remain the same until the new time we look at this file, and to avoid having to open a rewrite every collection document whenever any value tree changes, I'm writing the value out as a full path string
189 GValueModel model = Gatherer.c_man.getCollection().msm.getValueTree(metadata.getElement());
190 String node_value = null;
191 if(model != null && model.isHierarchy()) {
192 //node_value = /odec.transform(metadata.getValueNode().getFullPath(false), /odec.TEXT_TO_DOM);
193 node_value = metadata.getValueNode().getFullPath(false);
194 }
195 else {
196 node_value = metadata.getAbsoluteValue();
197 }
198 ///ystem.err.println("Creating node in GDMDocument: '" + node_value + "'");
199 metadata_element.appendChild(base_document.createTextNode(node_value));
200 // Retrieve the first description element for this fileset (there should only be one, but I'll play it safe).
201 NodeList description_elements = fileset_element.getElementsByTagName("Description");
202 Element description_element = (Element) description_elements.item(0);
203 description_element.appendChild(metadata_element);
204 description_element = null;
205 metadata_element = null;
206 //mode = null;
207 fileset_element = null;
208 directorymetadata_element = null;
209 up_to_date = false;
210 }
211 catch (Exception error) {
212 Gatherer.printStackTrace(error);
213 }
214 }
215
216 public int countMetadata() {
217 int count = 0;
218 try {
219 // Retrieve the document element.
220 Element directorymetadata_element = base_document.getDocumentElement();
221 // Iterate through the filesets, checking the FileName child element against the target file's name using regular expression matching.
222 NodeList fileset_elements = directorymetadata_element.getElementsByTagName(FILESET_ELEMENT);
223 for(int i = 0; i < fileset_elements.getLength(); i++) {
224 Element fileset_element = (Element) fileset_elements.item(i);
225 NodeList description_elements = fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT);
226 for(int k = 0; k < description_elements.getLength(); k++) {
227 Element description_element = (Element) description_elements.item(k);
228 // We have to do this for each type of metadata
229 for(int z = 0; z < ALL_METADATA_TYPES.length; z++) {
230 NodeList metadata_elements = description_element.getElementsByTagName(ALL_METADATA_TYPES[z]);
231 count = count + metadata_elements.getLength();
232 metadata_elements = null;
233 }
234 description_element = null;
235 }
236 description_elements = null;
237 fileset_element = null;
238 }
239 fileset_elements = null;
240 directorymetadata_element = null;
241 }
242 catch (Exception error) {
243 Gatherer.printStackTrace(error);
244 }
245 return count;
246 }
247
248 /** Retrieve the document this class is wrapping. */
249 public Document getDocument() {
250 return base_document;
251 }
252 /** Get all of the metadata, including directory level, associated with this file. */
253 public ArrayList getMetadata(String filename, boolean remove, ArrayList metadatum_so_far, File file, boolean append_folder_level) {
254 return getMetadata(filename, remove, metadatum_so_far, file, append_folder_level, false);
255 }
256 /** Retrieve the metadata associated with the given filename. Keep track of what metadata should be overwritten and what should be accumulated. Also make note of the source file, and remove the metadata if required. Finally if purge is set retrieve every piece of metadata in this file. */
257 public ArrayList getMetadata(String filename, boolean remove, ArrayList metadatum_so_far, File file, boolean append_folder_level, boolean purge) {
258 Gatherer.println("Get metadata for " + filename);
259 ArrayList metadatum = null;
260 if(metadatum_so_far == null) {
261 metadatum = new ArrayList();
262 }
263 else {
264 metadatum = metadatum_so_far;
265 }
266 try {
267 // Retrieve the document element.
268 Element directorymetadata_element = base_document.getDocumentElement();
269 // Iterate through the filesets, checking the FileName child element against the target file's name using regular expression matching.
270 NodeList fileset_elements = directorymetadata_element.getElementsByTagName(FILESET_ELEMENT);
271 for(int i = 0; i < fileset_elements.getLength(); i++) {
272 Element fileset_element = (Element) fileset_elements.item(i);
273 NodeList filename_elements = fileset_element.getElementsByTagName(FILENAME_ELEMENT);
274 for(int j = 0; j < filename_elements.getLength(); j++) {
275 Element filename_element = (Element) filename_elements.item(j);
276 String filename_text = MSMUtils.getValue(filename_element);
277 if((filename != null && (filename.matches(filename_text) || (append_folder_level && filename.indexOf(File.separator) != -1 && filename_text.equals(filename.substring(0, filename.indexOf(File.separator)))))) || ((filename == null || append_folder_level) && filename_text.equals(DIRECTORY_FILENAME)) || purge) {
278 // If they match add all of the metadata found in the Description child element, remembering to abide by desired mode (accumulate vs. overwrite).
279 // Normal metadata
280 NodeList description_elements = fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT);
281 for(int k = 0; k < description_elements.getLength(); k++) {
282 Element description_element = (Element) description_elements.item(k);
283 // We have to do this for each type of metadata
284 for(int z = 0; z < ALL_METADATA_TYPES.length; z++) {
285 NodeList metadata_elements = description_element.getElementsByTagName(ALL_METADATA_TYPES[z]);
286 for(int l = 0; l < metadata_elements.getLength(); l++) {
287 Element metadata_element = (Element) metadata_elements.item(l);
288 String raw_element = metadata_element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
289 //String language = metadata_element.getAttribute("language");
290 String mode = metadata_element.getAttribute(MODE_ATTRIBUTE);
291 String raw_value = MSMUtils.getValue(metadata_element);
292 //
293 //raw_value = Codec.transform(raw_value, Codec.DOM_TO_);
294 ///ystem.err.println("Retrieved raw value: " + raw_value);
295 // ***** LEGACY SUPPORT *****
296 // If this raw_value contains a '\' character, but no '\\', '[' or ']' characters, then replace the '\' with a '\\'
297 if(raw_value.indexOf(StaticStrings.ESCAPE_STR) != -1) {
298 ///ystem.err.println("Blarg");
299 Gatherer.println("Detected Legacy Path: " + raw_value);
300 raw_value = raw_value.replaceAll(StaticStrings.ESCAPE_PATTERN, StaticStrings.PIPE_STR);
301 Gatherer.println("Updated Path To: " + raw_value);
302 MSMUtils.setValue(metadata_element, raw_value);
303 }
304 // **************************
305 // Using the element string and value, retrieve a matching Metadata object from the cache
306 Metadata metadata = null;
307 // If this element has hierarchy values then we must ensure the raw value is a full path, not an index.
308 // Try to retrieve an already comstructed piece of metadata from file - but not if we are purging, as this will stuff up anything that is still using that metadata - such as the GTable
309 if(GDMManager.metadata_cache.contains(raw_element, raw_value) && !purge) {
310 ///ystem.err.println("HIT! Retrieve metadata from cache: " + raw_element + " -> " + raw_value + "\n");
311 metadata = (Metadata) GDMManager.metadata_cache.get(raw_element, raw_value);
312 }
313 else {
314 ElementWrapper element = Gatherer.c_man.getCollection().msm.getElement(raw_element);
315 if (element != null) {
316 GValueNode value = Metadata.getDefaultValueNode(element, raw_value);
317 ///ystem.err.println("Miss. Create new metadata: " + raw_element + " -> " + raw_value + "\n");
318 metadata = new Metadata(element, value);
319 if(!purge) {
320 GDMManager.metadata_cache.put(raw_element, raw_value, metadata);
321 }
322 ///ystem.err.println("Added metadata to cache: " + raw_element + " -> " + raw_value + "\n");
323 value = null;
324 element = null;
325 }
326 }
327 // check whether the metadata is null
328 if (metadata != null) {
329 // We determine whether this metadata is file or folder level
330 if(filename != null) {
331 ///ystem.err.println("Filename = " + filename);
332 ///ystem.err.println("filename_text = " + filename_text);
333 // If can only be file level if there is no folder path details in filename and if the filename matched the filename text node (it may have matched .* instead)!
334 if(filename.indexOf(File.separator) == -1 && filename.equals(filename_text)) {
335 metadata.setFileLevel(true);
336 ///ystem.err.println("File level!!!");
337 }
338 else {
339 metadata.setFileLevel(false);
340 ///ystem.err.println("Inherited!!!");
341 }
342 }
343 else {
344 ///ystem.err.println("Filename is null therefore this is file level metadata.");
345 metadata.setFileLevel(true);
346 }
347 metadata.setFile(file);
348 // If mode is overwrite, then remove any previous values for this metadata element.
349 if(mode.equals("accumulate")) {
350 metadata.setAccumulate(true);
351 }
352 else {
353 metadata.setAccumulate(false);
354 ///ystem.err.println("Metadata overwrites: " + metadata);
355 for(int m = metadatum.size() - 1; m >= 0; m--) {
356 Metadata old_metadata = (Metadata) metadatum.get(m);
357 if(old_metadata.getElement().equals(metadata.getElement())) {
358 metadatum.remove(m);
359 ///ystem.err.println("Removing overridden metadata: " + old_metadata);
360 }
361 old_metadata = null;
362 }
363 }
364 mode = null;
365 // Add the completed metadata and clean up
366 ///ystem.err.println("Adding metadata: " + metadata);
367 metadatum.add(metadata);
368 // Having found our metadata check if the value from the xml matches the one from the gvaluenode. If not update it. This happens whenever hierarchy information is involved (indexes rapidly become obsolete).
369 // If remove was set, remove it. We can only remove pure file level metadata, or folder level iff we were asked for folder level.
370 if(remove && ((filename != null && filename.matches(filename_text) && !filename_text.equals(DIRECTORY_FILENAME)) || (filename == null && filename_text.equals(DIRECTORY_FILENAME)))) {
371 ///ystem.err.println("Removing " + metadata + " from " + file);
372 description_element.removeChild(metadata_element);
373 // Remove the description element if empty.
374 if(!description_element.hasChildNodes()) {
375 fileset_element.removeChild(description_element);
376 }
377 }
378 else {
379 //String current_value = metadata.getAbsoluteValue();
380 //String current_value = Codec.transform(metadata.getValueNode().getFullPath(false), Codec.TEXT_TO_DOM);
381 String current_value = metadata.getValueNode().getFullPath(false);
382 ///ystem.err.println("Checking the current mdv path: " + current_value);
383 ///ystem.err.println("Against whats in the metadata file: " + raw_value);
384 if(!raw_value.equals(current_value)) {
385 // Remove old text
386 while(metadata_element.hasChildNodes()) {
387 metadata_element.removeChild(metadata_element.getFirstChild());
388 }
389 // Add new.
390 metadata_element.appendChild(base_document.createTextNode(current_value));
391 }
392 }
393 }
394 metadata = null;
395 raw_value = null;
396 raw_element = null;
397 metadata_element = null;
398 }
399 metadata_elements = null;
400 }
401 description_element = null;
402 }
403 description_elements = null;
404 }
405 filename_text = null;
406 filename_element = null;
407 }
408 // If the file set no longer has any description entries, remove it entirely
409 NodeList description_elements = fileset_element.getElementsByTagName(DESCRIPTION_ELEMENT);
410 if(description_elements.getLength() == 0) {
411 directorymetadata_element.removeChild(fileset_element);
412 }
413 description_elements = null;
414 filename_elements = null;
415 fileset_element = null;
416 }
417 fileset_elements = null;
418 directorymetadata_element = null;
419 }
420 catch (Exception error) {
421 Gatherer.self.printStackTrace(error);
422 }
423 ///ystem.err.println("Found " + metadatum.size() + " pieces of metadata.");
424 return metadatum;
425 }
426
427 /** Determine if this document has been saved recently, and thus xml file version is up to date. */
428 public boolean isUpToDate() {
429 return false;
430 }
431
432 /** Determine is this is a valid Greenstone Directory Metadata file. It may of course just be some xml file with the name metadata.xml. */
433 public boolean isValid() {
434 // Just determine if the doctype is GreenstoneDirectoryMetadata and root node is called DirectoryMetadata.
435 String doctype_name = base_document.getDoctype().getName();
436 String root_name = base_document.getDocumentElement().getTagName();
437 return ((doctype_name.equals("GreenstoneDirectoryMetadata") && root_name.equals("GreenstoneDirectoryMetadata")) || (doctype_name.equals("DirectoryMetadata") && root_name.equals("DirectoryMetadata")));
438 }
439 /** Remove the given directory level metadata from this document. All directory level metadata is available under the FileSet with filename '.*'. There is at least one nasty case to consider, where the first overwriting metadata entry, of several with the same element, is removed. In this case the next entry must become overwrite to ensure proper inheritance. */
440 public void removeMetadata(String filename, Metadata metadata) {
441 Gatherer.println("Remove metadata: " + metadata + "\nFrom filename: " + filename);
442 try {
443 boolean found = false;
444 boolean first_metadata_element_found = true;
445 boolean make_next_metadata_element_overwrite = false;
446 boolean remove_fileset = false;
447 // Retrieve the document element.
448 Element directorymetadata_element = base_document.getDocumentElement();
449 // Iterate through the filesets looking for the directory level one.
450 NodeList fileset_elements = directorymetadata_element.getElementsByTagName(FILESET_ELEMENT);
451 for(int i = 0; !found && i < fileset_elements.getLength(); i++) {
452 Element fileset_element = (Element) fileset_elements.item(i);
453 NodeList filename_elements = fileset_element.getElementsByTagName(FILENAME_ELEMENT);
454 for(int j = 0; !found && j < filename_elements.getLength(); j++) {
455 Element filename_element = (Element) filename_elements.item(j);
456 String filename_text = MSMUtils.getValue(filename_element);
457 if((filename != null && filename.matches(filename_text) && !filename.equals(DIRECTORY_FILENAME)) || (filename == null && filename_text.equals(DIRECTORY_FILENAME))) {
458 // Retrieve the Metadata Element for this fileset, and iterate through them looking for the one which we are to remove.
459 NodeList description_elements = fileset_element.getElementsByTagName("Description");
460 for(int k = 0; !found && k < description_elements.getLength(); k++) {
461 Element description_element = (Element) description_elements.item(k);
462 // We have to do this for each type of metadata
463 for(int z = 0; z < ALL_METADATA_TYPES.length; z++) {
464 NodeList metadata_elements = description_element.getElementsByTagName(ALL_METADATA_TYPES[z]);
465 for(int l = 0; (!found || !make_next_metadata_element_overwrite) && l < metadata_elements.getLength(); l++) {
466 Element metadata_element = (Element) metadata_elements.item(l);
467 String element = metadata_element.getAttribute("name");
468 String value = MSMUtils.getValue(metadata_element);
469 // See if this is the metadata we wish to remove
470 if(element.equals(metadata.getElement().getName())) {
471 if(value.equals(metadata.getAbsoluteValue())) {
472 // Remove it
473 ///ystem.err.println("Remove " + element + "-" + value);
474 description_element.removeChild(metadata_element);
475 found = true;
476 // If this was the first metadata with this element found, and it was set to overwrite, then we have to ensure that the next metadata with this element found (if any) is changed to be overwrite now.
477 if(first_metadata_element_found && !metadata.accumulates()) {
478 ///ystem.err.println("First of this element found!");
479 make_next_metadata_element_overwrite = true;
480 }
481 }
482 // If this was the first metadata we've found with the element of the one to be removed set first found to false.
483 else if(first_metadata_element_found) {
484 ///ystem.err.println("Found a matching element: " + element + "=" + value);
485 first_metadata_element_found = false;
486 }
487 // Otherwise we should make this metadata overwrite as requested.
488 else if(make_next_metadata_element_overwrite) {
489 ///ystem.err.println("Changing to overwrite: " + element + "=" + value);
490 metadata_element.setAttribute(MODE_ATTRIBUTE, "");
491 }
492 }
493 value = null;
494 element = null;
495 metadata_element = null;
496 }
497 metadata_elements = description_element.getElementsByTagName(ALL_METADATA_TYPES[z]);
498 // If we found it, removed it, and now the description tag has no children, mark the fileset for removal
499 if(metadata_elements.getLength() == 0) {
500 remove_fileset = true;
501 }
502 metadata_elements = null;
503 }
504 description_element = null;
505 }
506 description_elements = null;
507 }
508 filename_text = null;
509 filename_element = null;
510 }
511 filename_elements = null;
512 if(found && remove_fileset) {
513 directorymetadata_element.removeChild(fileset_element);
514 }
515 fileset_element = null;
516 }
517 fileset_elements = null;
518 directorymetadata_element = null;
519 up_to_date = false;
520 }
521 catch (Exception error) {
522 Gatherer.printStackTrace(error);
523 }
524 }
525
526 /** Change the up to date flag. */
527 public void setUpToDate(boolean up_to_date) {
528 this.up_to_date = up_to_date;
529 }
530}
Note: See TracBrowser for help on using the repository browser.