942 lines
No EOL
34 KiB
Java
942 lines
No EOL
34 KiB
Java
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2008 by Sun Microsystems, Inc.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: XMLTools.java,v $
|
|
* $Revision: 1.4 $
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
package util;
|
|
|
|
import java.io.PrintWriter ;
|
|
import java.util.Vector ;
|
|
import java.util.Hashtable ;
|
|
import java.util.Enumeration ;
|
|
import java.util.HashSet ;
|
|
|
|
// access the implementations via names
|
|
import com.sun.star.uno.XInterface;
|
|
import com.sun.star.io.XOutputStream;
|
|
import com.sun.star.io.XInputStream;
|
|
import com.sun.star.io.XActiveDataSource;
|
|
import com.sun.star.ucb.XSimpleFileAccess;
|
|
import com.sun.star.lang.XMultiServiceFactory;
|
|
import com.sun.star.xml.sax.XDocumentHandler;
|
|
import com.sun.star.uno.Any;
|
|
import com.sun.star.uno.Type;
|
|
import com.sun.star.uno.UnoRuntime;
|
|
import com.sun.star.beans.PropertyValue;
|
|
import com.sun.star.xml.sax.XLocator;
|
|
import com.sun.star.xml.sax.XAttributeList;
|
|
import com.sun.star.xml.sax.XParser ;
|
|
import com.sun.star.xml.sax.InputSource ;
|
|
import com.sun.star.lang.XComponent;
|
|
import com.sun.star.document.XExporter;
|
|
import com.sun.star.document.XImporter;
|
|
import com.sun.star.document.XFilter;
|
|
|
|
|
|
public class XMLTools {
|
|
|
|
/**
|
|
* The implementation of <code>com.sun.star.xml.sax.XAttributeList</code>
|
|
* where attributes and their values can be added.
|
|
*/
|
|
public static class AttributeList implements XAttributeList {
|
|
private static class Attribute {
|
|
public String Name ;
|
|
public String Type ;
|
|
public String Value ;
|
|
}
|
|
private Hashtable attrByName = new Hashtable() ;
|
|
private Vector attributes = new Vector() ;
|
|
private PrintWriter log = null ;
|
|
|
|
/**
|
|
* Creates a class instance.
|
|
*/
|
|
public AttributeList() {}
|
|
|
|
/**
|
|
* Constructs a list which will report to <code>log</code>
|
|
* specified about each <code>XDocumentHandler</code> method
|
|
* call.
|
|
*/
|
|
public AttributeList(PrintWriter log) {
|
|
this.log = log ;
|
|
}
|
|
|
|
public AttributeList(XAttributeList list) {
|
|
if (list == null) return ;
|
|
for (short i = 0; i < list.getLength(); i++) {
|
|
add(list.getNameByIndex(i), list.getTypeByIndex(i),
|
|
list.getValueByIndex(i)) ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds an attribute with type and value specified.
|
|
* @param name The attribute name.
|
|
* @param type Value type (usually 'CDATA' used).
|
|
* @param value Attribute value.
|
|
*/
|
|
public void add(String name, String type, String value) {
|
|
Attribute attr = new Attribute() ;
|
|
attr.Name = name ;
|
|
attr.Type = type ;
|
|
attr.Value = value ;
|
|
attributes.add(attr) ;
|
|
attrByName.put(attr.Name, attr) ;
|
|
}
|
|
|
|
/**
|
|
* Adds an attribute with value specified. As a type of
|
|
* value 'CDATA' string specified.
|
|
* @param name The attribute name.
|
|
* @param value Attribute value.
|
|
*/
|
|
public void add(String name, String value) {
|
|
add(name, "CDATA", value) ;
|
|
}
|
|
|
|
/**
|
|
* Clears all attributes added before.
|
|
*/
|
|
public void clear() {
|
|
attrByName.clear() ;
|
|
attributes.clear() ;
|
|
}
|
|
|
|
/***************************************
|
|
* XAttributeList methods
|
|
****************************************/
|
|
|
|
public short getLength() {
|
|
if (log != null)
|
|
log.println("getLength() called -> " + attributes.size()) ;
|
|
return (short) attributes.size() ;
|
|
}
|
|
|
|
public String getNameByIndex(short idx) {
|
|
String name = ((Attribute) attributes.get(idx)).Name ;
|
|
if (log != null)
|
|
log.println("getNameByIndex(" + idx + ") called -> '" +
|
|
name + "'") ;
|
|
return name ;
|
|
}
|
|
|
|
public String getTypeByIndex(short idx) {
|
|
String type = ((Attribute) attributes.get(idx)).Type ;
|
|
if (log != null)
|
|
log.println("getTypeByIndex(" + idx + ") called -> '" +
|
|
type + "'") ;
|
|
return type;
|
|
}
|
|
|
|
public String getTypeByName(String name) {
|
|
String type = ((Attribute) attrByName.get(name)).Type ;
|
|
if (log != null)
|
|
log.println("getTypeByName('" + name + "') called -> '" +
|
|
type + "'") ;
|
|
return type;
|
|
}
|
|
public String getValueByIndex(short idx) {
|
|
String value = ((Attribute) attributes.get(idx)).Value ;
|
|
if (log != null)
|
|
log.println("getValueByIndex(" + idx + ") called -> '" +
|
|
value + "'") ;
|
|
return value;
|
|
}
|
|
|
|
public String getValueByName(String name) {
|
|
String value = ((Attribute) attrByName.get(name)).Value ;
|
|
if (log != null)
|
|
log.println("getValueByName('" + name + "') called -> '" +
|
|
value + "'") ;
|
|
return value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class writes all XML data handled into a stream specified
|
|
* in the constructor.
|
|
*/
|
|
public static class XMLWriter implements XDocumentHandler {
|
|
private PrintWriter _log = null ;
|
|
private String align = "" ;
|
|
|
|
/**
|
|
* Creates a SAX handler which writes all XML data
|
|
* handled into a <code>log</code> stream specified.
|
|
*/
|
|
public XMLWriter(PrintWriter log) {
|
|
_log = log ;
|
|
}
|
|
|
|
/**
|
|
* Creates a SAX handler which does nothing.
|
|
*/
|
|
public XMLWriter() {
|
|
}
|
|
|
|
public void processingInstruction(String appl, String data) {
|
|
if (_log == null) return ;
|
|
_log.println(align + "<?" + appl + " " + data + "?>") ;
|
|
}
|
|
public void startDocument() {
|
|
if (_log == null) return ;
|
|
_log.println("START DOCUMENT:") ;
|
|
}
|
|
public void endDocument() {
|
|
if (_log == null) return ;
|
|
_log.println("END DOCUMENT:") ;
|
|
}
|
|
public void setDocumentLocator(XLocator loc) {
|
|
if (_log == null) return ;
|
|
_log.println("DOCUMENT LOCATOR: ('" + loc.getPublicId() +
|
|
"','" + loc.getSystemId() + "')") ;
|
|
}
|
|
public void startElement(String name, XAttributeList attr) {
|
|
if (_log == null) return ;
|
|
_log.print(align + "<" + name + " ") ;
|
|
if (attr != null) {
|
|
short attrLen = attr.getLength() ;
|
|
for (short i = 0; i < attrLen; i++) {
|
|
if (i != 0) _log.print(align + " ") ;
|
|
_log.print(attr.getNameByIndex(i) + "[" +
|
|
attr.getTypeByIndex(i) + "]=\"" +
|
|
attr.getValueByIndex(i) + "\"") ;
|
|
if (i+1 != attrLen) {
|
|
_log.println() ;
|
|
}
|
|
}
|
|
}
|
|
_log.println(">") ;
|
|
|
|
align += " " ;
|
|
}
|
|
|
|
public void endElement(String name) {
|
|
if (_log == null) return ;
|
|
align = align.substring(3) ;
|
|
_log.println(align + "</" + name + ">") ;
|
|
}
|
|
|
|
public void characters(String chars) {
|
|
if (_log == null) return ;
|
|
_log.println(align + chars) ;
|
|
}
|
|
public void ignorableWhitespace(String sp) {
|
|
if (_log == null) return ;
|
|
_log.println(sp) ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if the XML structure is well formed (i.e. all tags opened must be
|
|
* closed and all tags opened inside a tag must be closed
|
|
* inside the same tag). It also checks parameters passed.
|
|
* If any collisions found appropriate error message is
|
|
* output into a stream specified. No XML data output, i.e.
|
|
* no output will be performed if no errors occur.<p>
|
|
* After document is completed there is a way to cehck
|
|
* if the XML data and structure was valid.
|
|
*/
|
|
public static class XMLWellFormChecker extends XMLWriter {
|
|
protected boolean docStarted = false ;
|
|
protected boolean docEnded = false ;
|
|
protected Vector tagStack = new Vector() ;
|
|
protected boolean wellFormed = true ;
|
|
protected boolean noOtherErrors = true ;
|
|
protected PrintWriter log = null ;
|
|
protected boolean printXMLData = false ;
|
|
|
|
public XMLWellFormChecker(PrintWriter log) {
|
|
super() ;
|
|
this.log = log ;
|
|
}
|
|
|
|
public XMLWellFormChecker(PrintWriter log_, boolean printXMLData) {
|
|
super(printXMLData ? log_ : null) ;
|
|
this.printXMLData = printXMLData ;
|
|
this.log = log_ ;
|
|
}
|
|
|
|
/**
|
|
* Reset all values. This is important e.g. for test of XFilter
|
|
* interface, where 'filter()' method istbstarted twice.
|
|
*/
|
|
public void reset() {
|
|
docStarted = false ;
|
|
docEnded = false ;
|
|
tagStack = new Vector() ;
|
|
wellFormed = true ;
|
|
noOtherErrors = true ;
|
|
PrintWriter log = null ;
|
|
printXMLData = false ;
|
|
}
|
|
|
|
public void startDocument() {
|
|
super.startDocument();
|
|
|
|
if (docStarted) {
|
|
printError("Document is started twice.") ;
|
|
wellFormed = false ;
|
|
}
|
|
|
|
docStarted = true ;
|
|
}
|
|
public void endDocument() {
|
|
super.endDocument();
|
|
if (!docStarted) {
|
|
wellFormed = false ;
|
|
printError("Document ended but not started.") ;
|
|
}
|
|
docEnded = true ;
|
|
}
|
|
public void startElement(String name, XAttributeList attr) {
|
|
super.startElement(name, attr);
|
|
if (attr == null) {
|
|
printError("attribute list passed as parameter to startElement()"+
|
|
" method has null value for tag <" + name + ">") ;
|
|
noOtherErrors = false ;
|
|
}
|
|
tagStack.add(0, name) ;
|
|
}
|
|
public void endElement(String name) {
|
|
super.endElement(name);
|
|
if (wellFormed) {
|
|
if (tagStack.size() == 0) {
|
|
wellFormed = false ;
|
|
printError("No tags to close (bad closing tag </" + name + ">)") ;
|
|
} else {
|
|
String startTag = (String) tagStack.elementAt(0) ;
|
|
tagStack.remove(0) ;
|
|
if (!startTag.equals(name)) {
|
|
wellFormed = false ;
|
|
printError("Bad closing tag: </" + name +
|
|
">; tag expected: </" + startTag + ">");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if there were no errors during document handling.
|
|
* I.e. startDocument() and endDocument() must be called,
|
|
* XML must be well formed, paramters must be valid.
|
|
*/
|
|
public boolean isWellFormed() {
|
|
if (!docEnded) {
|
|
printError("Document was not ended.") ;
|
|
wellFormed = false ;
|
|
}
|
|
|
|
return wellFormed && noOtherErrors ;
|
|
}
|
|
|
|
/**
|
|
* Prints error message and all tags where error occured inside.
|
|
* Also prints "Tag trace" in case if the full XML data isn't
|
|
* printed.
|
|
*/
|
|
public void printError(String msg) {
|
|
log.println("!!! Error: " + msg) ;
|
|
if (printXMLData) return ;
|
|
log.println(" Tag trace :") ;
|
|
for (int i = 0; i < tagStack.size(); i++) {
|
|
String tag = (String) tagStack.elementAt(i) ;
|
|
log.println(" <" + tag + ">") ;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Beside structure of XML this class also can check existence
|
|
* of tags, inner tags, and character data. After document
|
|
* completion there is a way to check if required tags and
|
|
* character data was found. If there any error occurs an
|
|
* appropriate message is output.
|
|
*/
|
|
public static class XMLTagsChecker extends XMLWellFormChecker {
|
|
protected Hashtable tags = new Hashtable() ;
|
|
protected Hashtable chars = new Hashtable() ;
|
|
protected boolean allOK = true ;
|
|
|
|
public XMLTagsChecker(PrintWriter log) {
|
|
super(log) ;
|
|
}
|
|
|
|
/**
|
|
* Adds a tag name which must be contained in the XML data.
|
|
*/
|
|
public void addTag(String tag) {
|
|
tags.put(tag, "") ;
|
|
}
|
|
/**
|
|
* Adds a tag name which must be contained in the XML data and
|
|
* must be inside the tag with name <code>outerTag</code>.
|
|
*/
|
|
public void addTagEnclosed(String tag, String outerTag) {
|
|
tags.put(tag, outerTag) ;
|
|
}
|
|
/**
|
|
* Adds a character data which must be contained in the XML data.
|
|
*/
|
|
public void addCharacters(String ch) {
|
|
chars.put(ch, "") ;
|
|
}
|
|
/**
|
|
* Adds a character data which must be contained in the XML data and
|
|
* must be inside the tag with name <code>outerTag</code>.
|
|
*/
|
|
public void addCharactersEnclosed(String ch, String outerTag) {
|
|
chars.put(ch, outerTag) ;
|
|
}
|
|
|
|
public void startElement(String name, XAttributeList attrs) {
|
|
super.startElement(name, attrs) ;
|
|
if (tags.containsKey(name)) {
|
|
String outerTag = (String) tags.get(name);
|
|
if (!outerTag.equals("")) {
|
|
boolean isInTag = false ;
|
|
for (int i = 0; i < tagStack.size(); i++) {
|
|
if (outerTag.equals((String) tagStack.elementAt(i))) {
|
|
isInTag = true ;
|
|
break ;
|
|
}
|
|
}
|
|
if (!isInTag) {
|
|
printError("Required tag <" + name + "> found, but is not enclosed in tag <" +
|
|
outerTag + ">") ;
|
|
allOK = false ;
|
|
}
|
|
}
|
|
tags.remove(name) ;
|
|
}
|
|
}
|
|
|
|
public void characters(String ch) {
|
|
super.characters(ch) ;
|
|
|
|
if (chars.containsKey(ch)) {
|
|
String outerTag = (String) chars.get(ch);
|
|
if (!outerTag.equals("")) {
|
|
boolean isInTag = false ;
|
|
for (int i = 0; i < tagStack.size(); i++) {
|
|
if (outerTag.equals((String) tagStack.elementAt(i))) {
|
|
isInTag = true ;
|
|
break ;
|
|
}
|
|
}
|
|
if (!isInTag) {
|
|
printError("Required characters '" + ch + "' found, but are not enclosed in tag <" +
|
|
outerTag + ">") ;
|
|
allOK = false ;
|
|
}
|
|
}
|
|
chars.remove(ch) ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if the XML data was valid and well formed and if
|
|
* all necessary tags and character data was found.
|
|
*/
|
|
public boolean checkTags() {
|
|
allOK &= isWellFormed() ;
|
|
|
|
Enumeration badTags = tags.keys() ;
|
|
Enumeration badChars = chars.keys() ;
|
|
|
|
if (badTags.hasMoreElements()) {
|
|
allOK = false ;
|
|
log.println("Required tags were not found in export :") ;
|
|
while(badTags.hasMoreElements()) {
|
|
log.println(" <" + ((String) badTags.nextElement()) + ">") ;
|
|
}
|
|
}
|
|
if (badChars.hasMoreElements()) {
|
|
allOK = false ;
|
|
log.println("Required characters were not found in export :") ;
|
|
while(badChars.hasMoreElements()) {
|
|
log.println(" <" + ((String) badChars.nextElement()) + ">") ;
|
|
}
|
|
}
|
|
reset();
|
|
return allOK ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Represents an XML tag which must be found in XML data written.
|
|
* This tag can contain only its name or tag name and attribute
|
|
* name, or attribute value additionally.
|
|
*/
|
|
public static class Tag {
|
|
private String name = null;
|
|
private String[][] attrList = new String[0][3] ;
|
|
|
|
/**
|
|
* Creates tag which has only a name. Attributes don't make sense.
|
|
* @param tagName The name of the tag.
|
|
*/
|
|
public Tag(String tagName) {
|
|
name = tagName ;
|
|
}
|
|
|
|
/**
|
|
* Creates a tag with the name specified, which must have an
|
|
* attribute with name specified. The value of this attribute
|
|
* doesn't make sense.
|
|
* @param tagName The name of the tag.
|
|
* @param attrName The name of attribute which must be contained
|
|
* in the tag.
|
|
*/
|
|
public Tag(String tagName, String attrName) {
|
|
name = tagName ;
|
|
attrList = new String[1][3] ;
|
|
attrList[0][0] = attrName ;
|
|
}
|
|
|
|
/**
|
|
* Creates a tag with the name specified, which must have an
|
|
* attribute with the value specified. The type of value
|
|
* assumed to be 'CDATA'.
|
|
* @param tagName The name of the tag.
|
|
* @param attrName The name of attribute which must be contained
|
|
* in the tag.
|
|
* @param attrValue Attribute value.
|
|
*/
|
|
public Tag(String tagName, String attrName, String attrValue) {
|
|
name = tagName ;
|
|
attrList = new String[1][3] ;
|
|
attrList[0][0] = attrName ;
|
|
attrList[0][1] = "CDATA" ;
|
|
attrList[0][2] = attrValue ;
|
|
}
|
|
|
|
/**
|
|
* Creates a tag with the name specified, which must have
|
|
* attributes specified. The value of thesee attributes
|
|
* doesn't make sense.
|
|
* @param tagName The name of the tag.
|
|
* @param attrNames Array with names of attributes which must
|
|
* be contained in the tag.
|
|
*/
|
|
public Tag(String tagName, String[] attrNames) {
|
|
name = tagName ;
|
|
attrList = new String[attrNames.length][3] ;
|
|
for (int i = 0; i < attrNames.length; i++) {
|
|
attrList[i][0] = attrNames[i] ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a tag with the name specified, which must have an
|
|
* attributes with their values specified. The type of all values
|
|
* assumed to be 'CDATA'.
|
|
* @param tagName The name of the tag.
|
|
* @param attrValues An array with attribute names and their values.
|
|
* <code>attrValues[N][0]</code> element contains the name of Nth
|
|
* attribute, and <code>attrValues[N][1]</code> element contains
|
|
* value of Nth attribute, if value is <code>null</code> then the
|
|
* attribute value can be any.
|
|
*/
|
|
public Tag(String tagName, String[][] attrValues) {
|
|
name = tagName ;
|
|
attrList = new String[attrValues.length][3] ;
|
|
for (int i = 0; i < attrValues.length; i++) {
|
|
attrList[i][0] = attrValues[i][0] ;
|
|
attrList[i][1] = "CDATA" ;
|
|
attrList[i][2] = attrValues[i][1] ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets tag String description.
|
|
*/
|
|
public String toString() {
|
|
String ret = "<" + name ;
|
|
for (int i = 0; i < attrList.length; i++) {
|
|
ret += " " + attrList[i][0] + "=";
|
|
if (attrList[i][2] == null) {
|
|
ret += "(not specified)";
|
|
} else {
|
|
ret += "\"" + attrList[i][2] + "\"";
|
|
}
|
|
}
|
|
ret += ">";
|
|
|
|
return ret ;
|
|
}
|
|
|
|
protected boolean checkAttr(int attrListIdx, XAttributeList list) {
|
|
short j = 0 ;
|
|
int listLen = list.getLength();
|
|
while(j < listLen) {
|
|
if (attrList[attrListIdx][0].equals(list.getNameByIndex(j))) {
|
|
if (attrList[attrListIdx][2] == null) return true ;
|
|
return attrList[attrListIdx][2].equals(list.getValueByIndex(j)) ;
|
|
}
|
|
j++ ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
/**
|
|
* Checks if this tag matches tag passed in parameters.
|
|
* I.e. if tag specifies only it's name it mathes if names
|
|
* are equal (attributes don't make sense). If there are
|
|
* some attributes names specified in this tag method checks
|
|
* if all names present in attribute list <code>list</code>
|
|
* (attributes' values don't make sense). If attributes specified
|
|
* with values method checks if these attributes exist and
|
|
* have appropriate values.
|
|
*/
|
|
public boolean isMatchTo(String tagName, XAttributeList list) {
|
|
if (!name.equals(tagName)) return false;
|
|
boolean result = true ;
|
|
for (int i = 0; i < attrList.length; i++) {
|
|
result &= checkAttr(i, list) ;
|
|
}
|
|
return result ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class realises extended XML data checking. It has possibilities
|
|
* to check if a tag exists, if it has some attributes with
|
|
* values, and if this tag is contained in another tag (which
|
|
* also can specify any attributes). It can check if some
|
|
* character data exists inside any tag specified.
|
|
*/
|
|
public static class XMLChecker extends XMLWellFormChecker {
|
|
protected HashSet tagSet = new HashSet() ;
|
|
protected Vector tags = new Vector() ;
|
|
protected Vector chars = new Vector() ;
|
|
protected Vector tagStack = new Vector() ;
|
|
protected Vector attrStack = new Vector() ;
|
|
|
|
public XMLChecker(PrintWriter log, boolean writeXML) {
|
|
super(log, writeXML) ;
|
|
}
|
|
|
|
public void addTag(Tag tag) {
|
|
tags.add(new Tag[] {tag, null}) ;
|
|
tagSet.add(tag.name) ;
|
|
}
|
|
|
|
public void addTagEnclosed(Tag tag, Tag outerTag) {
|
|
tags.add(new Tag[] {tag, outerTag}) ;
|
|
tagSet.add(tag.name) ;
|
|
}
|
|
|
|
public void addCharacters(String ch) {
|
|
chars.add(new Object[] {ch.trim(), null}) ;
|
|
}
|
|
|
|
public void addCharactersEnclosed(String ch, Tag outerTag) {
|
|
chars.add(new Object[] {ch.trim(), outerTag}) ;
|
|
}
|
|
|
|
public void startElement(String name, XAttributeList attr) {
|
|
try {
|
|
super.startElement(name, attr);
|
|
|
|
if (tagSet.contains(name)) {
|
|
for (int i = 0; i < tags.size(); i++) {
|
|
Tag[] tag = (Tag[]) tags.elementAt(i);
|
|
if (tag[0].isMatchTo(name, attr)) {
|
|
if (tag[1] == null) {
|
|
tags.remove(i--);
|
|
} else {
|
|
boolean isInStack = false ;
|
|
for (int j = 0; j < tagStack.size(); j++) {
|
|
if (tag[1].isMatchTo((String) tagStack.elementAt(j),
|
|
(XAttributeList) attrStack.elementAt(j))) {
|
|
|
|
isInStack = true ;
|
|
break ;
|
|
}
|
|
}
|
|
if (isInStack) {
|
|
tags.remove(i--) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
tagStack.add(0, name) ;
|
|
attrStack.add(0, new AttributeList(attr));
|
|
} catch (Exception e) {
|
|
e.printStackTrace(log);
|
|
}
|
|
}
|
|
|
|
public void characters(String ch) {
|
|
super.characters(ch) ;
|
|
for (int i = 0; i < chars.size(); i++) {
|
|
Object[] chr = (Object[]) chars.elementAt(i);
|
|
if (((String) chr[0]).equals(ch)) {
|
|
if (chr[1] == null) {
|
|
chars.remove(i--);
|
|
} else {
|
|
boolean isInStack = false ;
|
|
for (int j = 0; j < tagStack.size(); j++) {
|
|
if (((Tag) chr[1]).isMatchTo((String) tagStack.elementAt(j),
|
|
(XAttributeList) attrStack.elementAt(j))) {
|
|
|
|
isInStack = true ;
|
|
break ;
|
|
}
|
|
}
|
|
if (isInStack) {
|
|
chars.remove(i--) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void endElement(String name) {
|
|
try {
|
|
super.endElement(name);
|
|
|
|
if (tagStack.size() > 0) {
|
|
tagStack.remove(0) ;
|
|
attrStack.remove(0) ;
|
|
}
|
|
} catch(Exception e) {
|
|
e.printStackTrace(log) ;
|
|
}
|
|
}
|
|
|
|
public boolean check() {
|
|
if (tags.size()> 0) {
|
|
log.println("!!! Error: Some tags were not found :") ;
|
|
for (int i = 0; i < tags.size(); i++) {
|
|
Tag[] tag = (Tag[]) tags.elementAt(i) ;
|
|
log.println(" Tag " + tag[0] + " was not found");
|
|
if (tag[1] != null)
|
|
log.println(" inside tag " + tag[1]) ;
|
|
}
|
|
}
|
|
if (chars.size() > 0) {
|
|
log.println("!!! Error: Some character data blocks were not found :") ;
|
|
for (int i = 0; i < chars.size(); i++) {
|
|
Object[] ch = (Object[]) chars.elementAt(i) ;
|
|
log.println(" Character data \"" + ch[0] + "\" was not found ") ;
|
|
if (ch[1] != null)
|
|
log.println(" inside tag " + ch[1]) ;
|
|
}
|
|
}
|
|
|
|
if (!isWellFormed())
|
|
log.println("!!! Some errors were found in XML structure") ;
|
|
|
|
boolean result = tags.size() == 0 && chars.size() == 0 && isWellFormed();
|
|
reset();
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates <code>XDocumentHandler</code> implementation in form
|
|
* of <code>com.sun.star.xml.sax.Writer</code> service, which
|
|
* writes XML data into a <code>com.sun.star.io.Pipe</code>
|
|
* created.
|
|
* @return Single element array which contains the handler
|
|
* contained in <code>Any</code> structure.
|
|
*/
|
|
public static Object[] getDocumentHandler(XMultiServiceFactory xMSF) {
|
|
Object[] ret = new Object[1];
|
|
try {
|
|
XInterface Writer = (XInterface) xMSF.createInstance(
|
|
"com.sun.star.xml.sax.Writer");
|
|
XInterface oPipe = (XInterface) xMSF.createInstance
|
|
( "com.sun.star.io.Pipe" );
|
|
XOutputStream xPipeOutput = (XOutputStream) UnoRuntime.
|
|
queryInterface(XOutputStream.class, oPipe) ;
|
|
|
|
XActiveDataSource xADS = (XActiveDataSource)
|
|
UnoRuntime.queryInterface(XActiveDataSource.class,Writer);
|
|
xADS.setOutputStream(xPipeOutput);
|
|
XDocumentHandler handler = (XDocumentHandler)
|
|
UnoRuntime.queryInterface(XDocumentHandler.class,Writer);
|
|
|
|
Any arg = new Any(new Type(XDocumentHandler.class),handler);
|
|
|
|
ret[0] = arg;
|
|
} catch (com.sun.star.uno.Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public static PropertyValue[] createMediaDescriptor(String[] propNames, Object[] values) {
|
|
PropertyValue[] props = new PropertyValue[propNames.length] ;
|
|
|
|
for (int i = 0; i < props.length; i++) {
|
|
props[i] = new PropertyValue() ;
|
|
props[i].Name = propNames[i] ;
|
|
if (values != null && i < values.length) {
|
|
props[i].Value = values[i] ;
|
|
}
|
|
}
|
|
|
|
return props ;
|
|
}
|
|
|
|
/**
|
|
* Gets the hanlder, which writes all the XML data passed to the
|
|
* file specified.
|
|
* @param xMSF Soffice <code>ServiceManager</code> factory.
|
|
* @param fileURL The file URL (in form file:///<path>) to which
|
|
* XML data is written.
|
|
* @return SAX handler to which XML data has to be written.
|
|
*/
|
|
public static XDocumentHandler getFileXMLWriter(XMultiServiceFactory xMSF, String fileURL)
|
|
throws com.sun.star.uno.Exception
|
|
{
|
|
XInterface oFacc = (XInterface)xMSF.createInstance(
|
|
"com.sun.star.comp.ucb.SimpleFileAccess");
|
|
XSimpleFileAccess xFacc = (XSimpleFileAccess)UnoRuntime.queryInterface
|
|
(XSimpleFileAccess.class, oFacc) ;
|
|
|
|
XInterface oWriter = (XInterface)xMSF.createInstance(
|
|
"com.sun.star.xml.sax.Writer");
|
|
XActiveDataSource xWriterDS = (XActiveDataSource)
|
|
UnoRuntime.queryInterface(XActiveDataSource.class, oWriter);
|
|
XDocumentHandler xDocHandWriter = (XDocumentHandler) UnoRuntime.queryInterface
|
|
(XDocumentHandler.class, oWriter) ;
|
|
|
|
if (xFacc.exists(fileURL))
|
|
xFacc.kill(fileURL);
|
|
XOutputStream fOut = xFacc.openFileWrite(fileURL) ;
|
|
xWriterDS.setOutputStream(fOut);
|
|
|
|
return xDocHandWriter ;
|
|
}
|
|
|
|
/**
|
|
* Parses XML file and passes its data to the SAX handler specified.
|
|
* @param xMSF Soffice <code>ServiceManager</code> factory.
|
|
* @param fileURL XML file name (in form file:///<path>) to be parsed.
|
|
* @param handler SAX handler to which XML data from file will
|
|
* be transferred.
|
|
*/
|
|
public static void parseXMLFile(XMultiServiceFactory xMSF,
|
|
String fileURL, XDocumentHandler handler) throws com.sun.star.uno.Exception
|
|
{
|
|
XInterface oFacc = (XInterface)xMSF.createInstance(
|
|
"com.sun.star.comp.ucb.SimpleFileAccess");
|
|
XSimpleFileAccess xFacc = (XSimpleFileAccess)UnoRuntime.queryInterface
|
|
(XSimpleFileAccess.class, oFacc) ;
|
|
XInputStream oIn = xFacc.openFileRead(fileURL) ;
|
|
|
|
XInterface oParser = (XInterface)xMSF.createInstance(
|
|
"com.sun.star.xml.sax.Parser");
|
|
XParser xParser = (XParser) UnoRuntime.queryInterface(XParser.class, oParser);
|
|
|
|
xParser.setDocumentHandler(handler) ;
|
|
InputSource inSrc = new InputSource() ;
|
|
inSrc.aInputStream = oIn ;
|
|
xParser.parseStream(inSrc) ;
|
|
|
|
oIn.closeInput();
|
|
}
|
|
|
|
/**
|
|
* Exports document (the whole or a part) into the file specified
|
|
* in XML format.
|
|
* @param xMSF Soffice <code>ServiceManager</code> factory.
|
|
* @param xDoc Document to be exported.
|
|
* @param docType Type of document (for example 'Calc', 'Writer', 'Draw')
|
|
* The type must start with <b>capital</b> letter.
|
|
* @param exportType The type of export specifies if the whole
|
|
* document will be exported or one of its parts (Meta info, Styles, etc.).
|
|
* The following types supported (it also depends of document type) :
|
|
* "" (empty string) - for the whole document ;
|
|
* "Content" - only content exported ;
|
|
* "Meta" - meta document info exported ;
|
|
* "Settings" - view settings of document exported ;
|
|
* "Styles" - document styles exported ;
|
|
* @param fileURL XML file name (in form file:///<path>) to be exported to.
|
|
*/
|
|
public static void exportDocument(XMultiServiceFactory xMSF, XComponent xDoc,
|
|
String docType, String exportType, String fileURL)
|
|
throws com.sun.star.uno.Exception {
|
|
|
|
XDocumentHandler xDocHandWriter = XMLTools.getFileXMLWriter(xMSF, fileURL) ;
|
|
|
|
Any arg = new Any(new Type(XDocumentHandler.class), xDocHandWriter);
|
|
XInterface oExp = (XInterface)xMSF.createInstanceWithArguments(
|
|
"com.sun.star.comp." + docType + ".XML" + exportType + "Exporter",
|
|
new Object[] {arg});
|
|
|
|
XExporter xExp = (XExporter) UnoRuntime.queryInterface
|
|
(XExporter.class, oExp) ;
|
|
xExp.setSourceDocument(xDoc) ;
|
|
|
|
XFilter filter = (XFilter) UnoRuntime.queryInterface(XFilter.class, oExp) ;
|
|
filter.filter(XMLTools.createMediaDescriptor(
|
|
new String[] {"FilterName"},
|
|
new Object[] {"Custom filter"})) ;
|
|
}
|
|
|
|
/**
|
|
* Imports document (the whole or a part) from the file specified
|
|
* in XML format.
|
|
* @param xMSF Soffice <code>ServiceManager</code> factory.
|
|
* @param xDoc Target document to be imported.
|
|
* @param docType Type of document (for example 'Calc', 'Writer', 'Draw')
|
|
* The type must start with <b>capital</b> letter.
|
|
* @param exportType The type of export specifies if the whole
|
|
* document will be exported or one of its parts (Meta info, Styles, etc.).
|
|
* The following types supported (it hardly depends of XML data in file) :
|
|
* "" (empty string) - for the whole document ;
|
|
* "Content" - only content exported ;
|
|
* "Meta" - meta document info exported ;
|
|
* "Settings" - view settings of document exported ;
|
|
* "Styles" - document styles exported ;
|
|
* @param fileURL XML file name (in form file:///<path>) to be imported from.
|
|
*/
|
|
public static void importDocument(XMultiServiceFactory xMSF, XComponent xDoc,
|
|
String docType, String importType, String fileURL)
|
|
throws com.sun.star.uno.Exception {
|
|
|
|
XInterface oImp = (XInterface)xMSF.createInstance(
|
|
"com.sun.star.comp." + docType + ".XML" + importType + "Importer");
|
|
XImporter xImp = (XImporter) UnoRuntime.queryInterface
|
|
(XImporter.class, oImp) ;
|
|
XDocumentHandler xDocHandImp = (XDocumentHandler) UnoRuntime.queryInterface
|
|
(XDocumentHandler.class, oImp) ;
|
|
|
|
xImp.setTargetDocument(xDoc) ;
|
|
parseXMLFile(xMSF, fileURL, xDocHandImp) ;
|
|
}
|
|
} |