Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (c) 2001-2007 Sun Microsystems, Inc. All rights reserved.
*
* The Sun Project JXTA(TM) Software License
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. 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.
*
* 3. The end-user documentation included with the redistribution, if any, must
* include the following acknowledgment: "This product includes software
* developed by Sun Microsystems, Inc. for JXTA(TM) technology."
* Alternately, this acknowledgment may appear in the software itself, if
* and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
* not be used to endorse or promote products derived from this software
* without prior written permission. For written permission, please contact
* Project JXTA at http://www.jxta.org.
*
* 5. Products derived from this software may not be called "JXTA", nor may
* "JXTA" appear in their name, without prior written permission of Sun.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 SUN
* MICROSYSTEMS OR ITS 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.
*
* JXTA is a registered trademark of Sun Microsystems, Inc. in the United
* States and other countries.
*
* Please see the license information page at :
* for instructions on use of
* the license in source files.
*
* ====================================================================
*
* This software consists of voluntary contributions made by many individuals
* on behalf of Project JXTA. For more information on Project JXTA, please see
* http://www.jxta.org.
*
* This license is based on the BSD license adopted by the Apache Foundation.
*/
package net.jxta.document;
import java.util.Enumeration;
/**
* Provides a number of static utility members which are helpful in
* manipluating StructuredDocuments.
*
**/
public final class StructuredDocumentUtils {
/**
* A singleton class, not meant to be constructed
**/
private StructuredDocumentUtils() {
;
}
/**
* Recursively copy children elements of from into the
* the element intoElement of document intoDoc.
*
* BEWARE that this does NOT copy the TEXTVALUE (if any) of the
* fromParent element, ONLY CHILDREN. All other elements
* are fully copied, including their textValue.
*
* It is not possible to copy a textValue in an existing element.
*
* @param intoDoc the document into which the elements will be
* copied.
* @param intoElement the element which will serve as the parent for
* the elements being copied.
* @param from the parent element of the elements which will be copied.
**/
public static void copyChildren(StructuredDocument intoDoc, Element intoElement, Element from) {
for (Enumeration eachChild = from.getChildren(); eachChild.hasMoreElements();) {
Element aChild = (Element) eachChild.nextElement();
Element newElement = intoDoc.createElement(aChild.getKey(), aChild.getValue());
intoElement.appendChild(newElement);
// copy attributes if any
if ((aChild instanceof Attributable) && (newElement instanceof Attributable)) {
Enumeration eachAttrib = ((Attributable) aChild).getAttributes();
while (eachAttrib.hasMoreElements()) {
Attribute anAttrib = (Attribute) eachAttrib.nextElement();
((Attributable) newElement).addAttribute(anAttrib.getName(), anAttrib.getValue());
}
}
// recurse to add the children.
copyChildren(intoDoc, newElement, aChild);
}
}
/**
* Recursively copy elements beginnging with from into the
* document identified by intoDoc.
*
* @param intoDoc the document into which the elements which will be
* copied.
* @param intoElement the element which will serve as the parent for
* the elements being copied.
* @param from the root element of the hierarchy which will be copied.
* @param newName the root element being copied is renamed
* newName.
* @return The added element.
*
**/
public static Element copyElements(StructuredDocument intoDoc, Element intoElement, Element from, Object newName) {
Element newElement = intoDoc.createElement(newName, from.getValue());
intoElement.appendChild(newElement);
boolean hasType = false;
// copy attributes if any
if (newElement instanceof Attributable) {
if (from instanceof Attributable) {
Enumeration eachAttrib = ((Attributable) from).getAttributes();
while (eachAttrib.hasMoreElements()) {
Attribute anAttrib = (Attribute) eachAttrib.nextElement();
String attribName = anAttrib.getName();
if (attribName.equals("type")) {
hasType = true;
}
((Attributable) newElement).addAttribute(attribName, anAttrib.getValue());
}
}
// If "from" happens to be a document, and if it happens to be renamed, and if it does not have an explicit type
// attribute, then preserve the document type, which we assume is the original name, converted to string, as a type
// attribute. It is an XMLism. It may be wrong or at least ineffective for other kinds of structured documents. If
// it one day becomes an issue, it will have to be resolved by having a method specific to each kind of structured
// document and dedicated to correcting type loss.
Object origName = from.getKey().toString();
if ((!hasType) && (!newName.equals(origName)) && (from instanceof Document)) {
((Attributable) newElement).addAttribute("type", origName.toString());
}
}
StructuredDocumentUtils.copyChildren(intoDoc, newElement, from);
return newElement;
}
/**
* Recursively copy elements beginnging with from into the
* document identified by intoDoc.
*
* @param intoDoc the document into which the elements which will be
* copied.
* @param intoElement the element which will serve as the parent for
* the elements being copied.
* @param from the root element of the hierarchy which will be copied.
* @return The added element.
**/
public static Element copyElements(StructuredDocument intoDoc, Element intoElement, Element from) {
return copyElements(intoDoc, intoElement, from, from.getKey());
}
/**
* Copies the specified element or document into a standalone document of
* same type. The from
