xmlioFactory<\code>.
* If this attribute is not present, the node name is taken as
* the identification string. The identification string is
* assigned by the XMLIOManager by using the object's final
* part of the Class name.
* @param objClass The Class of the object to be created.
* @return The corresponding XMLIOFactory.
* @throws IllegalArgumentException if the XMLIOFactory does not exist.
*
*/
XMLIOFactory getXMLIOFactory( Class objClass ) throws IllegalArgumentException;
/**
* Get the appropriate XMLIOProxy to restore the object
* that wrote the xml node. The XMLIOProxy identification string
* is the node name. The identification string is
* assigned by the XMLIOManager by using the object's final
* part of the Class name.
* @param objClass The Class of the object to be restored.
* @return The corresponding XMLIOProxy.
* @throws IllegalArgumentException if the XMLIOProxy does not exist.
*
*/
XMLIOProxy getXMLIOProxy( Class objClass ) throws IllegalArgumentException;
/**
* Get the identification string corresponding to a Class.
* @param clName The Class.
* @return The identification String.
*
*/
String getClassId( Class clName );
/**
* Get the Class corresponding to an identification String.
* @param objName The object's identification String.
* @return The corresponding Class.
*
*/
Class getIdClass( String objName );
}
src/main/java/org/freehep/xml/io/XMLIOFileManager.java 0000644 0001750 0001750 00000005352 11335255452 023174 0 ustar giovanni giovanni /*
* XMLIOFileManager.java
*
* Created on October 16, 2001, 8:03 AM
*/
package org.freehep.xml.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import org.jdom.DocType;
import org.jdom.Element;
import org.jdom.JDOMException;
/**
* Class XMLIOFileManager deals with xml files.
*
* @author turri
* @version 1.0
*
*/
public class XMLIOFileManager extends XMLIOStreamManager
{
private File xmlFile;
private boolean isZipped = false;
public XMLIOFileManager( String fileName )
{
xmlFile = new File(fileName);
}
/**
* After opening the input file, converts the text in xml format
* and returns the main root Element
* @return the jdom main Element or null if something
* went wrong in the text to xml conversion (the trace is
* printed).
* @exception JDOMException from XMLIOStreamManager
* @see XMLIOStreamManager#getRootElement()
* @exception IOException from XMLIOStreamManager
* @see XMLIOStreamManager#getRootElement()
*
*/
public Element getRootElement() throws JDOMException, IOException
{
InputStream inputStream = null;
try {
inputStream = new GZIPInputStream( new FileInputStream( xmlFile ) );
} catch ( IOException ioe ) {
if ( inputStream != null ) inputStream.close();
inputStream = new FileInputStream( xmlFile );
}
super.setXMLInputStream( inputStream, "file:"+xmlFile.getAbsolutePath());
return super.getRootElement();
}
/**
* Write the output file performing an xml to text conversion
* @param rootEl is the root Element that gets converted
* to text and dumped in the output file.
* @exception IOException from XMLIOStreamManager
* @see XMLIOStreamManager#saveRootElement( Element )
*
*/
public void saveRootElement( Element rootEl, String docName, String sysId ) throws IOException {
if ( isXMLFileZipped() ) super.setXMLOutputStream( new GZIPOutputStream( new FileOutputStream( xmlFile ) ) );
else super.setXMLOutputStream( new FileOutputStream( xmlFile ));
if ( ! docName.equals("") && ! sysId.equals("") ) super.saveRootElement( rootEl, new DocType(docName, sysId) );
else super.saveRootElement( rootEl );
}
public void saveRootElement( Element rootEl ) throws IOException {
saveRootElement(rootEl,"","");
}
public boolean isXMLFileZipped() {
return isZipped;
}
public void setXMLFileZipped( boolean isZipped ) {
this.isZipped = isZipped;
}
}
src/main/java/org/freehep/xml/io/XMLIO.java 0000644 0001750 0001750 00000003110 11335255452 021067 0 ustar giovanni giovanni /**
* XMLIO.java
*/
package org.freehep.xml.io;
import org.jdom.Element;
/**
* Interface to for objects that can be save/restore to/from xml.
*
* @author turri
* @version 1.0
*
*/
public interface XMLIO {
/**
* Save the current configuration of an object.
* @param xmlioManager The objects ID manager.
* @param nodeEl The jdom node containing the object's configuration info.
* This node is created by the XMLIOManager. Its name is,
* by default, the final part of the object's class.
* The node contains the attribute "objId", i.e. the unique id
* assigned to this object by the XMLIOManager. This id is
* used internally by the XMLIOManager for cross references
* to this object. The user has to append to this node all
* the attributes and other Elements required to save the
* object's configuration. Any other object, either XMLIO or Proxy-XMLIO,
* that needs to be saved has to be passed to the XMLIOManager through its save(Object) method.
* @see XMLIOManager#save(Object obj).
*
*/
void save( XMLIOManager xmlioManager, Element nodeEl );
/**
* Restore the object configuration.
* @param xmlioManager The objects ID manager.
* @param nodeEl The jdom node containing the object's configuration info.
*
*/
void restore( XMLIOManager xmlioManager, Element nodeEl );
}
src/main/java/org/freehep/xml/io/XMLIOStreamManager.java 0000644 0001750 0001750 00000006053 11335255452 023547 0 ustar giovanni giovanni /*
* XMLIOStreamManager.java
*
* Created on October 16, 2001, 8:03 AM
*
*/
package org.freehep.xml.io;
import java.io.*;
import java.lang.String;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
import org.jdom.output.Format;
import org.jdom.*;
/**
* Class XMLIOStreamManager deals with xml files.
*
* @author turri
* @version 1.0
*
*/
public class XMLIOStreamManager
{
private InputStream xmlInputStream;
private OutputStream xmlOutputStream;
private String systemId;
private SAXBuilder xmlBuilder = new SAXBuilder(false);
private XMLOutputter xmlOutputter = new XMLOutputter(Format.getPrettyFormat());
/**
* The main constructor
*
*/
public XMLIOStreamManager() {
}
/**
* The main constructor
* @param xmlInputStream the input Stream
* @param xmlOutputStream the output Stream
*
*/
public XMLIOStreamManager( InputStream xmlInputStream, OutputStream xmlOutputStream )
{
setXMLInputStream( xmlInputStream );
setXMLOutputStream( xmlOutputStream );
}
public SAXBuilder getBuilder() {
return xmlBuilder;
}
/**
* Set the input Stream
* @param xmlInputStream the input Stream
*
*/
public void setXMLInputStream( InputStream xmlInputStream )
{
this.xmlInputStream = xmlInputStream;
}
public void setXMLInputStream( InputStream xmlInputStream, String systemId )
{
this.xmlInputStream = xmlInputStream;
this.systemId = systemId;
}
/**
* Set the output Stream
* @param xmlOutputStream the output Stream
*
*/
public void setXMLOutputStream( OutputStream xmlOutputStream )
{
this.xmlOutputStream = xmlOutputStream;
}
/**
* From the input Stream convert the text in xml format
* and return the main root Element
* @return the jdom main Element
* @exception JDOMException from the build method of SAXBuilder
* @see org.jdom.input.SAXBuilder#build( InputStream )
* @exception IOMException for the specific implementations of InputStream
*
*/
public Element getRootElement() throws JDOMException, IOException
{
Document outputDoc = xmlBuilder.build(xmlInputStream, systemId);
return outputDoc.getRootElement();
}
/**
* Write to the output Stream performing an xml to text conversion
* @param rootEl is the root Element that gets converted
* to text and dumped in the output file.
* @exception IOException from the output method of XMLOutputter
* @see org.jdom.output.XMLOutputter#output( Document, OutputStream )
*
*/
public void saveRootElement( Element rootEl ) throws IOException {
saveRootElement(rootEl,null);
}
public void saveRootElement( Element rootEl, DocType docType ) throws IOException
{
Document inputDoc = docType != null ? new Document(rootEl, docType) : new Document(rootEl);
xmlOutputter.output( inputDoc, xmlOutputStream );
xmlOutputStream.close();
}
}
src/main/java/org/freehep/xml/io/XMLIOFile.java 0000644 0001750 0001750 00000001535 11335255452 021700 0 ustar giovanni giovanni /*
* XMLIOFile.java
*/
package org.freehep.xml.io;
import org.jdom.Element;
import java.lang.String;
/**
* This is a dummy class. It saves the name of a file,
* and restores it registering it with the XMLIOManager
*
* @author turri
* @version 1.0
*/
public class XMLIOFile implements XMLIO
{
private String fileName;
/**
* The default constructor does nothing
*/
public XMLIOFile() {}
/**
* The constructor only loads the name of the file
* @param fileName the name of the file
*/
public XMLIOFile( String fileName ) {
this.fileName = fileName;
}
public void save(XMLIOManager xmlioManager, Element el) {
el.setAttribute( "fName", fileName );
}
public void restore(XMLIOManager xmlioManager, Element nodeEl) {
fileName = (String) nodeEl.getAttributeValue( "fName" );
}
}
src/main/java/org/freehep/xml/io/XMLIOUtils.java 0000644 0001750 0001750 00000003271 11335255452 022120 0 ustar giovanni giovanni /*
* XMLIOUtils.java
*
* Created on October 19, 2001, 4:34 PM
*/
package org.freehep.xml.io;
import java.util.*;
import java.awt.*;
/**
* XMLIOUtils. This class is static and contains utilities.
* @author turri
* @version $Id: XMLIOUtils.java 8584 2006-08-10 23:06:37Z duns $
*/
public abstract class XMLIOUtils
{
/**
* Get the Components implementing the interface XMLIO
* contained in the object obj<\obj>.
* Only the first level Components are returned.
* @param obj the root Container
* @return the list of XMLIO Components.
*
*/
public static java.util.List getXMLIOComponents( Object obj ) {
java.util.List xmlioList = new ArrayList();
Component[] comp = ((Container)obj).getComponents();
for ( int ii = 0; ii < comp.length; ii++ ) {
Component c = comp[ii];
if ( c instanceof XMLIO ) {
xmlioList.add( c );
} else if ( c instanceof Container ) {
xmlioList.addAll( getXMLIOComponents( c ) );
}
}
return xmlioList;
}
/**
* Get the Components implementing the interface XMLIO
* contained in the object obj<\obj>.
* All level Components are returned.
* @param obj the root Container
* @return the list of XMLIO Components.
*
*/
public static java.util.List getXMLIOComponentsAll( Object obj ) {
java.util.List xmlioList = new ArrayList();
Component[] comp = ((Container)obj).getComponents();
for ( int ii = 0; ii < comp.length; ii++ ) {
Component c = comp[ii];
if ( c instanceof XMLIO ) {
xmlioList.add( c );
}
if ( c instanceof Container ) {
xmlioList.addAll( getXMLIOComponentsAll( c ) );
}
}
return xmlioList;
}
}
src/main/java/org/freehep/xml/io/DefaultXMLIORegistry.java 0000644 0001750 0001750 00000006046 11335255452 024140 0 ustar giovanni giovanni /*
* DefaultXMLIORegistry.java
*/
package org.freehep.xml.io;
import java.util.Hashtable;
/**
* Default XMLIORegistry.
* @see XMLIORegistry
* @author turri
* @version 1.0
*/
public class DefaultXMLIORegistry implements XMLIORegistry {
private Hashtable factoryHash = new Hashtable();
private Hashtable proxyHash = new Hashtable();
private Hashtable classIds = new Hashtable();
private Hashtable idClasses = new Hashtable();
/**
* Register an XMLIOFactory or an XMLIOProxy.
* param xmlioFactory the XMLIOFactory being registered
* param factoryId the identification String.
*
*/
public void register( Object obj ) {
if ( !(obj instanceof XMLIOFactory) && !(obj instanceof XMLIOProxy) ) throw new IllegalArgumentException("Cannot register object "+obj+"."+
"Only XMLIOFactories and XMLIOProxies can be registered!");
if ( obj instanceof XMLIOFactory ) {
XMLIOFactory xmlioFactory = (XMLIOFactory)obj;
Class[] classes = xmlioFactory.XMLIOFactoryClasses();
for ( int i = 0; i < classes.length; i++ ) {
if ( factoryHash.containsKey( classes[i] ) ) throw new IllegalArgumentException("Identifier "+classes[i]+" has already been registered!!");
factoryHash.put( classes[i], xmlioFactory );
addClassId( classes[i] );
}
}
if ( obj instanceof XMLIOProxy ) {
XMLIOProxy xmlioProxy = (XMLIOProxy)obj;
Class[] classes = xmlioProxy.XMLIOProxyClasses();
for ( int i = 0; i < classes.length; i++ ) {
if ( proxyHash.containsKey( classes[i] ) ) throw new IllegalArgumentException("Class "+classes[i]+" has already been registered!!");
proxyHash.put( classes[i], xmlioProxy );
}
}
}
private void addClassId( Class clazz ) {
String objClassString = clazz.toString();
String classId = objClassString.substring( objClassString.lastIndexOf(".")+1 );
classId = classId.replace('$','-');
if ( classIds.containsValue(classId) ) throw new RuntimeException("Already registered ClassId in the registry!!! "+classId);
classIds.put(clazz,classId);
idClasses.put(classId,clazz);
}
/**
* Get the XMLIOFactory corresponding to the identification
* string factoryId<\code>
* param factoryId the identification String
* @return the XMLIOFactory corresponding to factoryId<\code>
*
*/
public XMLIOFactory getXMLIOFactory(Class objClass) {
return (XMLIOFactory) factoryHash.get( objClass );
}
public XMLIOProxy getXMLIOProxy(Class objClass) {
return (XMLIOProxy) proxyHash.get( objClass );
}
public String getClassId( Class clName ) {
if ( ! classIds.containsKey(clName ) )
addClassId(clName);
return (String) classIds.get( clName );
}
public Class getIdClass(String objName) {
return (Class) idClasses.get(objName);
}
}
src/main/java/org/freehep/xml/io/package.html 0000644 0001750 0001750 00000000565 11335255452 021630 0 ustar giovanni giovanni
The XMLIO package is a set of interfaces and classes to save and restore
objects using XML.
@status Under Development.
src/main/java/org/freehep/xml/io/XMLIOFileFactory.java 0000644 0001750 0001750 00000001404 11335255452 023223 0 ustar giovanni giovanni /*
* XMLIOFileFactory.java
*
* Created on October 18, 2001, 3:39 PM
*/
package org.freehep.xml.io;
/**
* @author turri
* @version $Id: XMLIOFileFactory.java 8584 2006-08-10 23:06:37Z duns $
*/
public class XMLIOFileFactory implements XMLIOFactory
{
private Class[] classes;
/**
* Creates a new instance of XMLIOFileFactory
*/
public XMLIOFileFactory() {
classes = new Class[1];
classes[0] = XMLIOFile.class;
}
public Object createObject(Class objClass) {
if ( objClass == XMLIOFile.class ) return new XMLIOFile();
else throw new IllegalArgumentException("XMLIOFileFactory cannot create object of class "+objClass);
}
public Class[] XMLIOFactoryClasses() {
return classes;
}
}
src/main/java/org/freehep/xml/io/XMLIOProxy.java 0000644 0001750 0001750 00000002710 11335255452 022136 0 ustar giovanni giovanni /*
* XMLIOProxy.java
*/
package org.freehep.xml.io;
import org.jdom.Element;
/**
* Interface for proxyes that can save and restore objects to/from xml.
*
* @author turri
*
*/
public interface XMLIOProxy {
/**
* Save the current configuration of an object.
* @param obj The object to be saved to xml.
* @param xmlioManager The objects ID manager.
* @return Element A jdom node containing the object's
* configuration info.
* @throws An IllegalArgumentException if the object
* is not saveble by this proxy.
*
*/
void save(Object obj, XMLIOManager xmlioManager, Element nodeEl) throws IllegalArgumentException;
/**
* Restore the configuration of an object.
* @param obj The object to be restored.
* @param xmlioManager The objects ID manager.
* @param nodeEl Is the jdom node containing the
* object's configuration info
* @throws An IllegalArgumentException if the object
* cannot be restored by this proxy.
*
*/
void restore(Object obj, XMLIOManager xmlioManager, Element nodeEl) throws IllegalArgumentException;
/**
* Returns the array containing the Class of the objects that the proxy is
* able to save and restore.
* @return The classes.
*
*/
Class[] XMLIOProxyClasses();
}
src/main/java/org/freehep/xml/io/XMLIOManager.java 0000644 0001750 0001750 00000027217 11335255452 022400 0 ustar giovanni giovanni /*
* XMLIOManager.java
*
* Created on October 16, 2001, 8:03 AM
*/
package org.freehep.xml.io;
import java.util.*;
import org.jdom.*;
/**
* The XMLIOManager is in charge of saving and restoring any object
* configuration through XML. It internally assigns objects and unique
* identification string used for cross-reference among xml nodes.
*
* @author turri
* @version 1.0
*
*/
public class XMLIOManager {
private Hashtable objIdHash = new Hashtable();
private Hashtable idHash = new Hashtable();
private Hashtable nodeHash = new Hashtable();
private Hashtable classHash = new Hashtable();
private Hashtable refTable = new Hashtable();
private XMLIORegistry xmlioRegistry;
private XMLIOStreamManager xmlioStreamManager;
private boolean useId = true;
/**
* The basic constructor.
* @param xmlioRegistry The XMLIORegistry from which the XMLIOManager
* gets the XMLIOFactories and the XMLIOProxies to
* save and restore objects.
* @param xmlioStreamManager The xmlioStreamManager that deals with the input/output file.
*
*/
/* MD: never used
private XMLIOManager() {
this( new DefaultXMLIORegistry(), new XMLIOFileManager("defaultXMLIOFile.xml"), true);
}
*/
public XMLIOManager(String fileName) {
this( new DefaultXMLIORegistry(), new XMLIOFileManager(fileName), true);
}
/* MD: never used
private XMLIOManager( boolean useId ) {
this( new DefaultXMLIORegistry(), new XMLIOFileManager("defaultXMLIOFile.xml"), useId);
}
*/
/* MD: never used
private XMLIOManager( XMLIORegistry xmlioRegistry, XMLIOStreamManager xmlioFileManager ) {
this( xmlioRegistry, xmlioFileManager, true);
}
*/
private XMLIOManager( XMLIORegistry xmlioRegistry, XMLIOStreamManager xmlioFileManager, boolean useId ) {
setXMLIORegistry( xmlioRegistry );
setXMLIOStreamManager( xmlioFileManager );
this.useId = useId;
}
protected void setXMLIORegistry( XMLIORegistry xmlioRegistry ) {
this.xmlioRegistry = xmlioRegistry;
}
/**
* Get the XMLIORegistry.
* @return the XMLIORegistry
*
*/
public XMLIORegistry getXMLIORegistry() {
return xmlioRegistry;
}
public void setXMLIOStreamManager( XMLIOStreamManager xmlioStreamManager ) {
this.xmlioStreamManager = xmlioStreamManager;
}
public XMLIOStreamManager getXMLIOStreamManager() {
return xmlioStreamManager;
}
/**
* Restore an object from an xml node.
* @param nodeEl The node containing the object's information.
* This method should be used by the user to restore
* nested objects within the restore method of an object
* implementing the XMLIO interface.
* @return The restored object. The object is first created by
* invoking the create method on the corresponding XMLIOFactory.
* Once created the restore method is invoked either on the object
* itself (if it implements the XMLIO interface) or on the appropriate
* XMLIOProxy.
*
*/
public Object restore( Object obj, Element nodeEl ) {
String objIdRef = (String) nodeEl.getAttributeValue( "objIdRef" );
if ( objIdRef != null )
if ( useId )
if ( isObjIdRegistered( objIdRef ) )
return getObj( objIdRef );
else
return restore(obj, (Element) refTable.get(objIdRef) );
String objId = (String) nodeEl.getAttributeValue( "objId" );
if ( useId && isObjIdRegistered( objId ) ) return getObj( objId );
Class objClass;
if ( classHash.containsKey( nodeEl.getName() ) )
objClass = (Class) classHash.get( nodeEl.getName() );
else
objClass = xmlioRegistry.getIdClass(nodeEl.getName());
if ( obj == null )
obj = getXMLIOFactory( objClass ).createObject( objClass );
if ( useId ) registerObj( obj, objId );
if ( obj instanceof XMLIO ) ((XMLIO)obj).restore( this, nodeEl );
else getXMLIOProxy( objClass ).restore( obj, this, nodeEl);
return obj;
}
public Object restore( Element nodeEl ) {
return restore(null, nodeEl);
}
/**
* Save an object to an XML node.
* @param obj The object to be saved.
* @return The jdom Element containing the object's unique
* identification string (in the attribute "objId") and
* whose name is the object's identifier. The user will have
* to append to this node all the attributes and other
* jdom elemets required to save the object's configuration.
*
*/
public Element saveAs( Object obj, Class clazz ) {
String nodeName;
if ( nodeHash.containsKey( clazz ) ) nodeName = (String) nodeHash.get(clazz);
else nodeName = (String) xmlioRegistry.getClassId( clazz );
Element el = new Element( nodeName );
if ( isObjRegistered( obj ) ) el.setAttribute( "objIdRef", getObjId( obj ) );
else {
if ( useId ) el.setAttribute( "objId", registerObj( obj ) );
if ( obj instanceof XMLIO ) ((XMLIO)obj).save( this, el );
else getXMLIOProxy( clazz ).save( obj, this, el );
}
return el;
}
public Element save( Object obj ) {
return saveAs( obj, obj.getClass() );
}
/**
* The main method to save an array of objects to XML.
* @param objs The array of objects to be saved.
*
*/
public void saveToXML( Object[] objs, Element nodeEl ) {
resetObjId();
for ( int i = 0; i < objs.length; i++ ) {
nodeEl.addContent( save( objs[i] ) );
}
try {
xmlioStreamManager.saveRootElement( nodeEl );
} catch ( java.io.IOException ioe ) {
System.out.println(" Problem with file "+ioe.getMessage());
}
}
/**
* The main method to restore from xml.
* @return The array of the restored objects.
*
*/
public Object[] restoreFromXML() {
resetObjId();
Object[] objs = null;
try {
Element restoreElement = xmlioStreamManager.getRootElement();
//Create the list of references here.
List children = restoreElement.getChildren();
for (Iterator it = children.iterator(); it.hasNext(); )
loadRefTable( (Element) it.next() );
objs = new Object[ children.size() ];
int child = 0;
for (Iterator it = children.iterator(); it.hasNext(); )
objs[ child++ ] = restore( (Element) it.next() );
} catch ( JDOMException je ) {
System.out.println(" Problem with restoring "+je.getMessage());
} catch ( java.io.IOException ioe ) {
System.out.println(" Problem with file "+ioe.getMessage());
}
return objs;
}
/**
* Assign to a Class a string identifier.
* @param clName The Class.
* @param id The new identifier for the class.
*
*/
public void setClassId(Class clName, String id) {
nodeHash.put(clName, id);
classHash.put(id, clName);
}
protected void loadRefTable(Element el) {
String objId = el.getAttributeValue("objId");
if ( objId != null )
refTable.put( objId, el );
List children = el.getChildren();
for (Iterator it = children.iterator(); it.hasNext(); )
loadRefTable( (Element) it.next() );
}
/**
* Down here are only private and protected methods.
*
*/
/**
* Create the object's unique Id for cross-reference among xml nodes
* @param obj the object.
* @return the object's unique Id.
*/
private String makeObjId( Object obj ) {
String clName = obj.getClass().getName();
String pkgName = obj.getClass().getPackage().getName();
String idName = clName.substring( pkgName.length()+1, clName.length() ).trim();
while ( idName.indexOf('$') != -1 )
idName = idName.substring( idName.indexOf('$')+1, idName.length() ).trim();
int i = 1;
if ( idHash.containsKey( idName ) ) i = ( (Integer)( idHash.get( idName ) ) ).intValue() + 1;
idHash.put( idName, new Integer( i ) );
String objId = idName+i;
return objId;
}
/**
* Register object assigning an unique Id for cross-reference among xml nodes
* @param obj the object to be registered.
* @return the object's unique Id.
*/
private String registerObj( Object obj ) {
if ( objIdHash.contains( obj ) ) return getObjId( obj );
String objId = makeObjId( obj );
objIdHash.put( objId, obj );
return objId;
}
/**
* Register object with a pre-assigned Id for cross-reference among xml nodes
* @param obj the object to be registered
* @param objId the object's Id
*/
private void registerObj( Object obj, String objId ) {
if ( objIdHash.containsKey( objId ) ) return;
objIdHash.put( objId, obj);
}
/**
* Get the object's unique Id for cross-reference among xml nodes
* @param obj the object whose unique id we are looking for
* @return the unique String Id of object obj
* if no string is found the object itself is returned
*/
private String getObjId( Object obj ) {
for ( Enumeration keys = objIdHash.keys(); keys.hasMoreElements(); ) {
String key = (String) ( keys.nextElement() );
if ( objIdHash.get( key ).equals( obj ) ) return key;
}
return (String)obj;
}
/**
* Get the object corresponding to unique Id for cross-reference among xml nodes
* @param objId the object's unique String Id
* @return the object corrisponding to unique Id objId
* if the object is registered or the string objId
* if the object is not registered
*
*/
private Object getObj( String objId ) {
if ( objIdHash.containsKey( objId ) )
return objIdHash.get( objId );
return objId;
}
/**
* Check if an object is registered
* @param obj the object to be checked
* @return true if the object is registered
* false otherwise
*
*/
private boolean isObjRegistered( Object obj ) {
if ( objIdHash.contains( obj ) ) return true;
return false;
}
/**
* Check if an unique Id is registered
* @param objId the unique Id to be checked
* @return true if the unique Id is registered
* false otherwise
*
*/
private boolean isObjIdRegistered( String objId ) {
if ( objIdHash.containsKey( objId ) ) return true;
return false;
}
/**
* Reset the stored ids
*/
public void resetObjId() {
objIdHash.clear();
idHash.clear();
refTable.clear();
}
/**
* Get the XMLIOFactory to restore the xml node
* param nodeEl the node to be restored
* @return the XMLIOFactory
*
*/
protected XMLIOFactory getXMLIOFactory( Class objClass ) {
return xmlioRegistry.getXMLIOFactory( objClass );
}
protected XMLIOProxy getXMLIOProxy( Class objClass ) {
return xmlioRegistry.getXMLIOProxy( objClass );
}
}
src/main/java/org/freehep/xml/util/ 0000755 0001750 0001750 00000000000 11341744246 017710 5 ustar giovanni giovanni src/main/java/org/freehep/xml/util/SAXErrorHandler.java 0000644 0001750 0001750 00000004657 11335255452 023531 0 ustar giovanni giovanni /*
* SAXErrorHandler.java
*
* Created on February 14, 2001, 4:38 PM
*/
package org.freehep.xml.util;
import org.xml.sax.*;
/**
* A simple SAXErrorHandler. Reports errors to System.err and keeps track
* of the most severe error. Can be configured to throw exceptions when errors
* more severe than a certain LEVEL are encountered
* @author tonyj
* @version $Id: SAXErrorHandler.java 8584 2006-08-10 23:06:37Z duns $
*/
public class SAXErrorHandler implements ErrorHandler
{
public final static int LEVEL_SUCCESS = 0;
public final static int LEVEL_WARNING = 1;
public final static int LEVEL_ERROR = 2;
public final static int LEVEL_FATAL = 3;
/**
* Create a SAXErrorHandler which will throw exceptions for all errors (but not warnings)
*/
public SAXErrorHandler()
{
this(LEVEL_ERROR);
}
/**
* Create a SAXErrorHandler
* @param minLevelForException The minimum error level for which exceptions will be thrown
*/
public SAXErrorHandler(int minLevelForException)
{
this.minLevel = minLevelForException;
}
public void warning(SAXParseException exception) throws org.xml.sax.SAXException
{
handle(exception,LEVEL_WARNING,"Warning");
}
public void error(SAXParseException exception) throws org.xml.sax.SAXException
{
handle(exception,LEVEL_ERROR,"Error");
}
public void fatalError(SAXParseException exception) throws SAXException
{
handle(exception,LEVEL_FATAL,"Fatal");
}
private void handle(SAXParseException exception, int level, String levelName) throws SAXException
{
StringBuffer message = new StringBuffer(levelName);
String fileName = exception.getPublicId();
if (fileName == null) fileName = exception.getSystemId();
if (fileName != null) message.append(" at "+fileName);
message.append(" line "+exception.getLineNumber());
if (level > maxLevel) maxLevel = level;
if (level >= minLevel) throw new BadXMLException(message.toString(),exception);
else
{
message.append(": "+exception);
System.err.println(message);
}
}
/**
* Get the level of the most severe error.
* @return one of LEVEL_SUCCESS, LEVEL_WARNING, LEVEL_ERROR, LEVEL_FATAL
*/
public int getErrorLevel()
{
return maxLevel;
}
private int maxLevel = 0;
private int minLevel;
}
src/main/java/org/freehep/xml/util/XMLWriter.java 0000644 0001750 0001750 00000033234 11335255452 022414 0 ustar giovanni giovanni // Copyright 2002-2007, FreeHEP.
package org.freehep.xml.util;
import java.awt.Color;
import java.io.IOException;
import java.io.Writer;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Stack;
import org.freehep.util.io.IndentPrintWriter;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* A class that makes it easy to write XML documents.
*
* @author Tony Johnson
* @author Mark Donszelmann
* @version $Id: XMLWriter.java 10527 2007-02-13 17:49:08Z duns $
*/
public class XMLWriter implements XMLTagWriter
{
public XMLWriter(Writer w, String indentString, String defaultNameSpace)
{
writer = new IndentPrintWriter(w);
writer.setIndentString(indentString);
this.defaultNameSpace = defaultNameSpace;
}
public XMLWriter(Writer w, String indentString) {
this(w, indentString, "");
}
public XMLWriter(Writer w)
{
this(w, " "); // By popular demand of Babar
}
/**
* closes the writer
*/
public void close() throws IOException
{
closeDoc();
writer.close();
}
/**
* Opens the document with an xml header
*/
public void openDoc()
{
openDoc("1.0", "", false);
}
/**
* Opens the document with an xml header
*/
public void openDoc(String version, String encoding, boolean standalone)
{
String indentString = writer.getIndentString();
writer.setIndentString(indentString);
closed = false;
if (!XMLCharacterProperties.validVersionNum(version)) throw new RuntimeException("Invalid version number: "+version);
writer.print("");
writer.setIndentString(indentString);
}
/**
* Writes a reference to a DTD
*/
public void referToDTD(String name, String pid, String ref) {
if (dtdName != null) {
throw new RuntimeException("ReferToDTD cannot be called twice");
}
dtdName = name;
writer.println("");
}
/**
* Writes a reference to a DTD
*/
public void referToDTD(String name, String system)
{
if (dtdName != null) {
throw new RuntimeException("ReferToDTD cannot be called twice");
}
dtdName = name;
writer.println("");
}
/**
* Closes the document, and checks if you closed all the tags
*/
public void closeDoc()
{
if (!closed) {
if (!openTags.isEmpty()) {
StringBuffer sb = new StringBuffer("Not all tags were closed before closing XML document:\n");
while (!openTags.isEmpty()) {
sb.append(" \n");
}
throw new RuntimeException(sb.toString());
}
closed = true;
}
writer.flush();
}
/**
* Print a comment
*/
public void printComment(String comment)
{
if (comment.indexOf("--") >= 0) throw new RuntimeException("'--' sequence not allowed in comment");
writer.print("");
}
/**
* Prints character data, while escaping < and >
*/
public void print(String text)
{
writer.print(normalizeText(text));
}
/**
* Prints character data, while escaping < and >
*/
public void println(String text)
{
print(text);
writer.println();
}
/**
* Prints a new XML tag and increases the identation level
*/
public void openTag(String namespace, String name)
{
if (namespace.equals(defaultNameSpace)) {
openTag(name);
} else {
openTag(namespace+":"+name);
}
}
/**
* Prints a new XML tag and increases the identation level
*/
public void openTag(String name)
{
checkNameValid(name);
if (openTags.isEmpty() && dtdName != null && !dtdName.equals(name)) {
throw new RuntimeException("First tag: '"+name+"' not equal to DTD id: '"+dtdName+"'");
}
writer.print("<"+name);
printAttributes(name.length());
writer.println(">");
writer.indent();
openTags.push(name);
}
/**
* Closes the current XML tag and decreases the indentation level
*/
public void closeTag()
{
if (openTags.isEmpty()) {
writer.close();
throw new RuntimeException("No open tags");
}
Object name = openTags.pop();
writer.outdent();
writer.print("");
}
/**
* Prints an empty XML tag.
*/
public void printTag(String namespace, String name)
{
if (namespace.equals(defaultNameSpace)) {
printTag(name);
} else {
printTag(namespace+":"+name);
}
}
/**
* Prints an empty XML tag.
*/
public void printTag(String name)
{
checkNameValid(name);
writer.print("<"+name);
printAttributes(name.length());
writer.println("/>");
}
/**
* Sets an attribute which will be included in the next tag
* printed by openTag or printTag
*/
public void setAttribute(String name, String value)
{
if ((name != null) && (value != null)) {
attributes.put(name,value);
}
}
public void setAttribute(String namespace, String name, String value)
{
if ((namespace != null) && (name != null)) {
attributes.put(namespace+":"+name, value);
}
}
public void setAttribute(String name, byte value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, char value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, long value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, int value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, short value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, boolean value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, float value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, double value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, Color value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String ns, String name, byte value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, char value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, long value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, int value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, short value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, boolean value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, float value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, double value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, Color value) { setAttribute(ns+":"+name, String.valueOf(value)); }
protected void printAttributes(int tagLength)
{
int width = tagLength + 1;
boolean extraIndent = false;
Enumeration e = attributes.keys();
while (e.hasMoreElements())
{
String key = e.nextElement().toString();
checkNameValid(key);
String value = normalize(attributes.get(key).toString());
int length = key.length() + value.length() + 3;
if (width > 0 && width + length + 2*writer.getIndent() > 60)
{
width = 0;
writer.println();
if (!extraIndent)
{
writer.indent();
extraIndent = true;
}
}
else
{
width += length;
writer.print(' ');
}
writer.print(key);
writer.print("=\"");
writer.print(value);
writer.print("\"");
}
attributes.clear();
if (extraIndent) writer.outdent();
}
/**
* Prints a DOM node, recursively.
* No support for a document node
*/
public void print(Node node)
{
if ( node == null ) return;
int type = node.getNodeType();
switch ( type ) {
// print document
case Node.DOCUMENT_NODE:
throw new RuntimeException("No support for printing nodes of type Document");
// print element with attributes
case Node.ELEMENT_NODE:
NamedNodeMap attributes = node.getAttributes();
for ( int i = 0; i < attributes.getLength(); i++ ) {
Node attr = attributes.item(i);
setAttribute(attr.getNodeName(), attr.getNodeValue());
}
NodeList children = node.getChildNodes();
if ( children == null ) {
printTag(node.getNodeName());
} else {
openTag(node.getNodeName());
int len = children.getLength();
for ( int i = 0; i < len; i++ ) {
print(children.item(i));
}
closeTag();
}
break;
// handle entity reference nodes
case Node.ENTITY_REFERENCE_NODE:
writer.print('&');
writer.print(node.getNodeName());
writer.print(';');
break;
// print cdata sections
case Node.CDATA_SECTION_NODE:
writer.print("");
break;
// print text
case Node.TEXT_NODE:
print(node.getNodeValue());
break;
// print processing instruction
case Node.PROCESSING_INSTRUCTION_NODE:
writer.print(" 0 ) {
writer.print(' ');
writer.print(data);
}
writer.print("?>");
break;
}
} // print(Node)
/** Normalizes the given string for an Attribute value*/
public static String normalize(String s)
{
StringBuffer str = new StringBuffer();
int len = (s != null) ? s.length() : 0;
for (int i = 0; i < len; i++) {
char ch = s.charAt(i);
switch (ch) {
case '<': {
str.append("<");
break;
}
case '>': {
str.append(">");
break;
}
case '&': {
str.append("&");
break;
}
case '"': {
str.append(""");
break;
}
case '\r':
case '\n': {
str.append("&#");
str.append(Integer.toString(ch));
str.append(';');
break;
}
default: {
if (ch > 0x00FF) {
String hex = "0000"+Integer.toHexString(ch);
str.append("&#x");
str.append(hex.substring(hex.length()-4));
str.append(';');
} else {
str.append(ch);
}
}
}
}
return str.toString();
} // normalize(String):String
/** Normalizes the given string for Text */
public static String normalizeText(String s)
{
StringBuffer str = new StringBuffer();
int len = (s != null) ? s.length() : 0;
for (int i = 0; i < len; i++) {
char ch = s.charAt(i);
switch (ch) {
case '<': {
str.append("<");
break;
}
case '>': {
str.append(">");
break;
}
case '&': {
str.append("&");
break;
}
default: {
if (ch > 0x007f) {
String hex = "0000"+Integer.toHexString(ch);
str.append("&#x");
str.append(hex.substring(hex.length()-4));
str.append(';');
} else {
str.append(ch);
}
}
}
}
return str.toString();
}
protected void checkNameValid(String s)
{
if (!XMLCharacterProperties.validName(s)) throw new RuntimeException("Invalid name: "+s);
}
protected boolean closed = true;
private String dtdName = null;
private Hashtable attributes = new Hashtable();
private Stack openTags = new Stack();
protected IndentPrintWriter writer;
protected String defaultNameSpace;
}
src/main/java/org/freehep/xml/util/XMLNodeTraverser.java 0000644 0001750 0001750 00000012015 11335255452 023715 0 ustar giovanni giovanni // Copyright 2000, SLAC, Stanford, California, U.S.A.
package org.freehep.xml.util;
import org.w3c.dom.*;
/**
* Utility class for traversing XML DOM trees.
* This is an abstract class that has methods which are
* called as different elements are located in a DOM tree.
* It is designed to be extended for each nore in a specific
* DOM tree, with its methods overriden to handle specific
* elements and attributes of the tree.
*
* @deprecated The design of this class is misguided, it is better to use SAX, and SAXTraverser. Will be removed from future FreeHEP releases
* @author Tony Johnson (tonyj@slac.stanford.edu)
* @version $Id: XMLNodeTraverser.java 8584 2006-08-10 23:06:37Z duns $
*/
public abstract class XMLNodeTraverser
{
/**
* Traverse a node
* @param node The node to traverse
*/
public void traverse(Node node) throws BadXMLException
{
if (node instanceof Element)
{
attrs = ((Element) node).getAttributes();
handleElementAttributes(attrs);
}
for (Node n = node.getFirstChild(); n != null; n = n.getNextSibling())
{
handleSubNode(n,n.getNodeName());
}
attrs = null; // for efficiency, dont hold on to attributes
}
/**
* Called to handle a subnode of the node being traversed.
* The default implementation calls handleElement, handleTextNode
* or handleOtherNode as appropriate.
* @param node The subnode being handled
* @param name The name of the subnode
*/
protected void handleSubNode(Node node, String name) throws BadXMLException
{
int type = node.getNodeType();
switch (type)
{
case Node.ELEMENT_NODE:
handleElement((Element) node,name);
break;
case Node.TEXT_NODE:
handleTextNode((Text) node,name);
break;
default:
handleOtherNode(node,name);
}
}
/**
* Called to handle the attributes associated with the
* element being traversed. The default implementation calls
* handleAttributeNode for each attribute
* @param nnm The attrinbutes being handled
*/
protected void handleElementAttributes(NamedNodeMap nnm) throws BadXMLException
{
for (int i=0; i
XML Utilities to add in reading and writing XML.
@Status Stable.