jdk/src/sample/share/jmx/jmx-scandir/src/com/sun/jmx/examples/scandir/config/XmlConfigUtils.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  *   - Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *
  *   - Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *
  *   - Neither the name of Oracle nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 /*
  * This source code is provided to illustrate the usage of a given feature
  * or technique and has been deliberately simplified. Additional steps
  * required for a production-quality application, such as security checks,
  * input validation and proper error handling, might not be present in
  * this sample code.
  */


 package com.sun.jmx.examples.scandir.config;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.logging.Logger;
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Marshaller;
 import javax.xml.bind.Unmarshaller;

 /**
  * The class XmlConfigUtils is used to deal with XML serialization
  * and XML files.
  *
  * @author Sun Microsystems, 2006 - All rights reserved.
  */
 public class XmlConfigUtils {

     /**
      * A URI for our XML configuration namespace. This doesn't start with
      * http:// because we are not going to publish this private schema
      * anywhere.
      **/
     public static final String NAMESPACE =
             "jmx:com.sun.jmx.examples.scandir.config";
     /**
      * A logger for this class.
      **/
     private static final Logger LOG =
             Logger.getLogger(XmlConfigUtils.class.getName());

     // Our JAXBContext.
     private static JAXBContext context;

     // The file name of the XML file in which an instance of this object
     // will read and write XML data.
     final String file;

     /**
      * Creates a new instance of XmlConfigUtils.
      * @param file The file name of the XML file in which an instance of this
      *        object will read and write XML data.
      */
     public XmlConfigUtils(String file) {
         this.file = file;
     }

     /**
      * Write the given bean to the XML file.
      * <p>
      * Performs an atomic write, first writing in {@code <file>.new}, then
      * renaming {@code <file>} to {@code <file>~}, then renaming
      * renaming {@code <file>.new} to {@code <file>}.
      * </p>
      * @param bean The configuration to write in the XML file.
      * @throws IOException if write to file failed.
      **/
     public synchronized void writeToFile(ScanManagerConfig bean)
         throws IOException {

         // Creates a new file named <file>.new
         final File f = newXmlTmpFile(file);
         try {
             final FileOutputStream out = new FileOutputStream(f);
             boolean failed = true;
             try {
                 // writes to <file>.new
                 write(bean,out,false);

                 // no exception: set failed=false for finaly {} block.
                 failed = false;
             } finally {
                 out.close();
                 // An exception was raised: delete temporary file.
                 if (failed == true) f.delete();
             }

             // rename <file> to <file>~ and <file>.new to <file>
             commit(file,f);
         } catch (JAXBException x) {
             final IOException io =
                     new IOException("Failed to write SessionConfigBean to " +
                     file+": "+x,x);
             throw io;
         }
     }

     /**
      * Creates an XML string representation of the given bean.
      * @throws IllegalArgumentException if the bean class is not known by the
      *         underlying XMLbinding context.
      * @return An XML string representation of the given bean.
      **/
     public static String toString(Object bean) {
         try {
             final ByteArrayOutputStream baos = new ByteArrayOutputStream();
             final Marshaller m = createMarshaller();
             m.setProperty(m.JAXB_FRAGMENT,Boolean.TRUE);
             m.marshal(bean, baos);
             return baos.toString();
         } catch (JAXBException x) {
             final IllegalArgumentException iae =
                     new IllegalArgumentException(
                         "Failed to write SessionConfigBean: "+x,x);
             throw iae;
         }
     }

     /**
      * Creates an XML clone of the given bean.
      * <p>
      * In other words, this method XML-serializes the given bean, and
      * XML-deserializes a copy of that bean.
      * </p>
      * @return A deep-clone of the given bean.
      * @throws IllegalArgumentException if the bean class is not known by the
      *         underlying XML binding context.
      * @param bean The bean to clone.
      */
     public static ScanManagerConfig xmlClone(ScanManagerConfig bean) {
         final Object clone = copy(bean);
         return (ScanManagerConfig)clone;
     }

     /**
      * Creates an XML clone of the given bean.
      * <p>
      * In other words, this method XML-serializes the given bean, and
      * XML-deserializes a copy of that bean.
      * </p>
      * @throws IllegalArgumentException if the bean class is not known by the
      *         underlying XML binding context.
      * @return A deep-clone of the given bean.
      **/
     private static Object copy(Object bean) {
         try {
             final ByteArrayOutputStream baos = new ByteArrayOutputStream();
             final Marshaller m = createMarshaller();
             m.marshal(bean, baos);
             final ByteArrayInputStream bais =
                     new ByteArrayInputStream(baos.toByteArray());
             return createUnmarshaller().unmarshal(bais);
         } catch (JAXBException x) {
             final IllegalArgumentException iae =
                     new IllegalArgumentException("Failed to write SessionConfigBean: "+x,x);
             throw iae;
         }
     }

     /**
      * Creates an XML clone of the given bean.
      * <p>
      * In other words, this method XML-serializes the given bean, and
      * XML-deserializes a copy of that bean.
      * </p>
      * @return A deep-clone of the given bean.
      * @throws IllegalArgumentException if the bean class is not known by the
      *         underlying XML binding context.
      * @param bean The bean to clone.
      */
     public static DirectoryScannerConfig xmlClone(DirectoryScannerConfig bean) {
         final Object clone = copy(bean);
         return (DirectoryScannerConfig)clone;
     }

     /**
      * Reads the configuration from the XML configuration file.
      * @throws IOException if it fails to read the configuration.
      * @return A {@code ScanManagerConfig} bean read from the
      *         XML configuration file.
      **/
     public synchronized ScanManagerConfig readFromFile() throws IOException {
         final File f = new File(file);
         if (!f.exists())
             throw new IOException("No such file: "+file);
         if (!f.canRead())
             throw new IOException("Can't read file: "+file);
         try {
             return read(f);
         } catch (JAXBException x) {
             final IOException io =
                     new IOException("Failed to read SessionConfigBean from " +
                     file+": "+x,x);
             throw io;
         }
     }

     /**
      * Reads the configuration from the given XML configuration file.
      * @param f the file to read from.
      * @return A {@code ScanManagerConfig} bean read from the
      *         XML configuration file.
      * @throws javax.xml.bind.JAXBException if it fails to read the configuration.
      */
     public static ScanManagerConfig read(File f)
         throws JAXBException {
         final Unmarshaller u = createUnmarshaller();
         return (ScanManagerConfig) u.unmarshal(f);

     }

     /**
      * Writes the given bean to the given output stream.
      * @param bean the bean to write.
      * @param os the output stream to write to.
      * @param fragment whether the {@code <?xml ... ?>} header should be
      *        included. The header is not included if the bean is just an
      *        XML fragment encapsulated in a higher level XML element.
      * @throws JAXBException An XML Binding exception occurred.
      **/
     public static void write(ScanManagerConfig bean, OutputStream os,
             boolean fragment)
         throws JAXBException {
         writeXml((Object)bean,os,fragment);
     }

     /**
      * Writes the given bean to the given output stream.
      * @param bean the bean to write.
      * @param os the output stream to write to.
      * @param fragment whether the {@code <?xml ... ?>} header should be
      *        included. The header is not included if the bean is just an
      *        XML fragment encapsulated in a higher level XML element.
      * @throws JAXBException An XML Binding exception occurred.
      **/
     public static void write(ResultRecord bean, OutputStream os, boolean fragment)
         throws JAXBException {
         writeXml((Object)bean,os,fragment);
     }

     /**
      * Writes the given bean to the given output stream.
      * @param bean the bean to write.
      * @param os the output stream to write to.
      * @param fragment whether the {@code <?xml ... ?>} header should be
      *        included. The header is not included if the bean is just an
      *        XML fragment encapsulated in a higher level XML element.
      * @throws JAXBException An XML Binding exception occurred.
      **/
     private static void writeXml(Object bean, OutputStream os, boolean fragment)
         throws JAXBException {
         final Marshaller m = createMarshaller();
         if (fragment) m.setProperty(m.JAXB_FRAGMENT,Boolean.TRUE);
         m.marshal(bean,os);
     }

     // Creates a JAXB Unmarshaller.
     private static Unmarshaller createUnmarshaller() throws JAXBException {
         return getContext().createUnmarshaller();
     }

     // Creates a JAXB Marshaller - for nicely XML formatted output.
     private static Marshaller createMarshaller() throws JAXBException {
         final  Marshaller m = getContext().createMarshaller();
         m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,Boolean.TRUE);
         return m;
     }

     // Creates a JAXBContext if needed, and returns it.
     // The JAXBContext instance we create will be able to handle the
     // ScanManagerConfig and ResultRecord classes, plus all the property
     // classes they reference (DirectoryScannerBean etc...).
     //
     private static synchronized JAXBContext getContext() throws JAXBException {
         if (context == null)
             context = JAXBContext.newInstance(ScanManagerConfig.class,
                                               ResultRecord.class);
         return context;
     }


     // Creates a new XML temporary file called <basename>.new
     // This method is used to implement atomic writing to file.
     // The usual sequence is:
     //
     // Final tmp = newXmlTmpFile(basename);
     // boolean failed = true;
     // try {
     //      ... write to 'tmp' ...
     //      // no exception: set failed=false for finaly {} block.
     //      failed = false;
     // } finally
     //      // failed==true means there was an exception and
     //      // commit won't be called...
     //      if (failed==true) tmp.delete();
     // }
     // commit(tmp,basename)
     //
     private static File newXmlTmpFile(String basename) throws IOException {
         final File f = new File(basename+".new");
         if (!f.createNewFile())
             throw new IOException("file "+f.getName()+" already exists");

         try {
             final OutputStream newStream = new FileOutputStream(f);
             try {
                 final String decl =
                     "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
                 newStream.write(decl.getBytes("UTF-8"));
                 newStream.flush();
             } finally {
                 newStream.close();
             }
         } catch (IOException x) {
             f.delete();
             throw x;
         }
         return f;
     }

     // Commit the temporary file by renaming <basename> to <baesname>~
     // and tmpFile to <basename>.
     private static File commit(String basename, File tmpFile)
         throws IOException {
         try {
             final String backupName = basename+"~";
             final File desired = new File(basename);
             final File backup = new File(backupName);
             backup.delete();
             if (desired.exists()) {
                 if (!desired.renameTo(new File(backupName)))
                     throw new IOException("can't rename to "+backupName);
             }
             if (!tmpFile.renameTo(new File(basename)))
                 throw new IOException("can't rename to "+basename);
         } catch (IOException x) {
             tmpFile.delete();
             throw x;
         }
         return new File(basename);
     }

     /**
      * Creates a new committed XML file for {@code <basename>}, containing only
      * the {@code <?xml ...?>} header.
      * <p>This method will rename {@code <basename>} to {@code <basename>~},
      * if it exists.
      * </p>
      * @return A newly created XML file containing the regular
      *         {@code <?xml ...?>} header.
      * @param basename The name of the new file.
      * @throws IOException if the new XML file couldn't be created.
      */
     public static File createNewXmlFile(String basename) throws IOException {
         return commit(basename,newXmlTmpFile(basename));
     }

 }
	/*
	* Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* - Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* - Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* - Neither the name of Oracle nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
	* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	/*
	* This source code is provided to illustrate the usage of a given feature
	* or technique and has been deliberately simplified. Additional steps
	* required for a production-quality application, such as security checks,
	* input validation and proper error handling, might not be present in
	* this sample code.
	*/


	package com.sun.jmx.examples.scandir.config;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.logging.Logger;
	import javax.xml.bind.JAXBContext;
	import javax.xml.bind.JAXBException;
	import javax.xml.bind.Marshaller;
	import javax.xml.bind.Unmarshaller;

	/**
	* The class XmlConfigUtils is used to deal with XML serialization
	* and XML files.
	*
	* @author Sun Microsystems, 2006 - All rights reserved.
	*/
	public class XmlConfigUtils {

	/**
	* A URI for our XML configuration namespace. This doesn't start with
	* http:// because we are not going to publish this private schema
	* anywhere.
	**/
	public static final String NAMESPACE =
	"jmx:com.sun.jmx.examples.scandir.config";
	/**
	* A logger for this class.
	**/
	private static final Logger LOG =
	Logger.getLogger(XmlConfigUtils.class.getName());

	// Our JAXBContext.
	private static JAXBContext context;

	// The file name of the XML file in which an instance of this object
	// will read and write XML data.
	final String file;

	/**
	* Creates a new instance of XmlConfigUtils.
	* @param file The file name of the XML file in which an instance of this
	* object will read and write XML data.
	*/
	public XmlConfigUtils(String file) {
	this.file = file;
	}

	/**
	* Write the given bean to the XML file.
	* <p>
	* Performs an atomic write, first writing in {@code <file>.new}, then
	* renaming {@code <file>} to {@code <file>~}, then renaming
	* renaming {@code <file>.new} to {@code <file>}.
	* </p>
	* @param bean The configuration to write in the XML file.
	* @throws IOException if write to file failed.
	**/
	public synchronized void writeToFile(ScanManagerConfig bean)
	throws IOException {

	// Creates a new file named <file>.new
	final File f = newXmlTmpFile(file);
	try {
	final FileOutputStream out = new FileOutputStream(f);
	boolean failed = true;
	try {
	// writes to <file>.new
	write(bean,out,false);

	// no exception: set failed=false for finaly {} block.
	failed = false;
	} finally {
	out.close();
	// An exception was raised: delete temporary file.
	if (failed == true) f.delete();
	}

	// rename <file> to <file>~ and <file>.new to <file>
	commit(file,f);
	} catch (JAXBException x) {
	final IOException io =
	new IOException("Failed to write SessionConfigBean to " +
	file+": "+x,x);
	throw io;
	}
	}

	/**
	* Creates an XML string representation of the given bean.
	* @throws IllegalArgumentException if the bean class is not known by the
	* underlying XMLbinding context.
	* @return An XML string representation of the given bean.
	**/
	public static String toString(Object bean) {
	try {
	final ByteArrayOutputStream baos = new ByteArrayOutputStream();
	final Marshaller m = createMarshaller();
	m.setProperty(m.JAXB_FRAGMENT,Boolean.TRUE);
	m.marshal(bean, baos);
	return baos.toString();
	} catch (JAXBException x) {
	final IllegalArgumentException iae =
	new IllegalArgumentException(
	"Failed to write SessionConfigBean: "+x,x);
	throw iae;
	}
	}

	/**
	* Creates an XML clone of the given bean.
	* <p>
	* In other words, this method XML-serializes the given bean, and
	* XML-deserializes a copy of that bean.
	* </p>
	* @return A deep-clone of the given bean.
	* @throws IllegalArgumentException if the bean class is not known by the
	* underlying XML binding context.
	* @param bean The bean to clone.
	*/
	public static ScanManagerConfig xmlClone(ScanManagerConfig bean) {
	final Object clone = copy(bean);
	return (ScanManagerConfig)clone;
	}

	/**
	* Creates an XML clone of the given bean.
	* <p>
	* In other words, this method XML-serializes the given bean, and
	* XML-deserializes a copy of that bean.
	* </p>
	* @throws IllegalArgumentException if the bean class is not known by the
	* underlying XML binding context.
	* @return A deep-clone of the given bean.
	**/
	private static Object copy(Object bean) {
	try {
	final ByteArrayOutputStream baos = new ByteArrayOutputStream();
	final Marshaller m = createMarshaller();
	m.marshal(bean, baos);
	final ByteArrayInputStream bais =
	new ByteArrayInputStream(baos.toByteArray());
	return createUnmarshaller().unmarshal(bais);
	} catch (JAXBException x) {
	final IllegalArgumentException iae =
	new IllegalArgumentException("Failed to write SessionConfigBean: "+x,x);
	throw iae;
	}
	}

	/**
	* Creates an XML clone of the given bean.
	* <p>
	* In other words, this method XML-serializes the given bean, and
	* XML-deserializes a copy of that bean.
	* </p>
	* @return A deep-clone of the given bean.
	* @throws IllegalArgumentException if the bean class is not known by the
	* underlying XML binding context.
	* @param bean The bean to clone.
	*/
	public static DirectoryScannerConfig xmlClone(DirectoryScannerConfig bean) {
	final Object clone = copy(bean);
	return (DirectoryScannerConfig)clone;
	}

	/**
	* Reads the configuration from the XML configuration file.
	* @throws IOException if it fails to read the configuration.
	* @return A {@code ScanManagerConfig} bean read from the
	* XML configuration file.
	**/
	public synchronized ScanManagerConfig readFromFile() throws IOException {
	final File f = new File(file);
	if (!f.exists())
	throw new IOException("No such file: "+file);
	if (!f.canRead())
	throw new IOException("Can't read file: "+file);
	try {
	return read(f);
	} catch (JAXBException x) {
	final IOException io =
	new IOException("Failed to read SessionConfigBean from " +
	file+": "+x,x);
	throw io;
	}
	}

	/**
	* Reads the configuration from the given XML configuration file.
	* @param f the file to read from.
	* @return A {@code ScanManagerConfig} bean read from the
	* XML configuration file.
	* @throws javax.xml.bind.JAXBException if it fails to read the configuration.
	*/
	public static ScanManagerConfig read(File f)
	throws JAXBException {
	final Unmarshaller u = createUnmarshaller();
	return (ScanManagerConfig) u.unmarshal(f);

	}

	/**
	* Writes the given bean to the given output stream.
	* @param bean the bean to write.
	* @param os the output stream to write to.
	* @param fragment whether the {@code <?xml ... ?>} header should be
	* included. The header is not included if the bean is just an
	* XML fragment encapsulated in a higher level XML element.
	* @throws JAXBException An XML Binding exception occurred.
	**/
	public static void write(ScanManagerConfig bean, OutputStream os,
	boolean fragment)
	throws JAXBException {
	writeXml((Object)bean,os,fragment);
	}

	/**
	* Writes the given bean to the given output stream.
	* @param bean the bean to write.
	* @param os the output stream to write to.
	* @param fragment whether the {@code <?xml ... ?>} header should be
	* included. The header is not included if the bean is just an
	* XML fragment encapsulated in a higher level XML element.
	* @throws JAXBException An XML Binding exception occurred.
	**/
	public static void write(ResultRecord bean, OutputStream os, boolean fragment)
	throws JAXBException {
	writeXml((Object)bean,os,fragment);
	}

	/**
	* Writes the given bean to the given output stream.
	* @param bean the bean to write.
	* @param os the output stream to write to.
	* @param fragment whether the {@code <?xml ... ?>} header should be
	* included. The header is not included if the bean is just an
	* XML fragment encapsulated in a higher level XML element.
	* @throws JAXBException An XML Binding exception occurred.
	**/
	private static void writeXml(Object bean, OutputStream os, boolean fragment)
	throws JAXBException {
	final Marshaller m = createMarshaller();
	if (fragment) m.setProperty(m.JAXB_FRAGMENT,Boolean.TRUE);
	m.marshal(bean,os);
	}

	// Creates a JAXB Unmarshaller.
	private static Unmarshaller createUnmarshaller() throws JAXBException {
	return getContext().createUnmarshaller();
	}

	// Creates a JAXB Marshaller - for nicely XML formatted output.
	private static Marshaller createMarshaller() throws JAXBException {
	final Marshaller m = getContext().createMarshaller();
	m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,Boolean.TRUE);
	return m;
	}

	// Creates a JAXBContext if needed, and returns it.
	// The JAXBContext instance we create will be able to handle the
	// ScanManagerConfig and ResultRecord classes, plus all the property
	// classes they reference (DirectoryScannerBean etc...).
	//
	private static synchronized JAXBContext getContext() throws JAXBException {
	if (context == null)
	context = JAXBContext.newInstance(ScanManagerConfig.class,
	ResultRecord.class);
	return context;
	}


	// Creates a new XML temporary file called <basename>.new
	// This method is used to implement atomic writing to file.
	// The usual sequence is:
	//
	// Final tmp = newXmlTmpFile(basename);
	// boolean failed = true;
	// try {
	// ... write to 'tmp' ...
	// // no exception: set failed=false for finaly {} block.
	// failed = false;
	// } finally
	// // failed==true means there was an exception and
	// // commit won't be called...
	// if (failed==true) tmp.delete();
	// }
	// commit(tmp,basename)
	//
	private static File newXmlTmpFile(String basename) throws IOException {
	final File f = new File(basename+".new");
	if (!f.createNewFile())
	throw new IOException("file "+f.getName()+" already exists");

	try {
	final OutputStream newStream = new FileOutputStream(f);
	try {
	final String decl =
	"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
	newStream.write(decl.getBytes("UTF-8"));
	newStream.flush();
	} finally {
	newStream.close();
	}
	} catch (IOException x) {
	f.delete();
	throw x;
	}
	return f;
	}

	// Commit the temporary file by renaming <basename> to <baesname>~
	// and tmpFile to <basename>.
	private static File commit(String basename, File tmpFile)
	throws IOException {
	try {
	final String backupName = basename+"~";
	final File desired = new File(basename);
	final File backup = new File(backupName);
	backup.delete();
	if (desired.exists()) {
	if (!desired.renameTo(new File(backupName)))
	throw new IOException("can't rename to "+backupName);
	}
	if (!tmpFile.renameTo(new File(basename)))
	throw new IOException("can't rename to "+basename);
	} catch (IOException x) {
	tmpFile.delete();
	throw x;
	}
	return new File(basename);
	}

	/**
	* Creates a new committed XML file for {@code <basename>}, containing only
	* the {@code <?xml ...?>} header.
	* <p>This method will rename {@code <basename>} to {@code <basename>~},
	* if it exists.
	* </p>
	* @return A newly created XML file containing the regular
	* {@code <?xml ...?>} header.
	* @param basename The name of the new file.
	* @throws IOException if the new XML file couldn't be created.
	*/
	public static File createNewXmlFile(String basename) throws IOException {
	return commit(basename,newXmlTmpFile(basename));
	}

	}