public class GwtActivityDomReader extends ActivityDomReader {

	@Override
	protected AclDomReader getAclDomReader() {
		return new GwtAclDomReader();
	}

	@Override
	protected ActivityFactory getActivityFactory() {
		return new DefaultActivityFactory();
	}

	@Override
	protected AtomDomReader getAtomDomReader() {
		return new GwtAtomDomReader();
	}

	@Override
	protected Date parseDate(String atomDate) {
		return AtomHelper.parseDate(atomDate);
	}

} public class GwtActivityDomWriter extends ActivityDomWriter {

	@Override
	protected AclDomWriter getAclDomWriter() {
		return new GwtAclDomWriter();
	}

	@Override
	protected AtomDomWriter getAtomDomWriter() {
		return new GwtAtomDomWriter();
	}

} public class GwtRelationDomReader extends RelationDomReader {

	@Override
	protected AclDomReader getAclDomReader() {
		return new GwtAclDomReader();
	}

	@Override
	protected RelationFactory getRelationFactory() {
		return new DefaultRelationFactory();
	}

} public class GwtRelationDomWriter extends RelationDomWriter {

	@Override
	protected String format(Date date) {
		return AtomHelper.formatDate(date);
	}

	@Override
	protected AclDomWriter getAclDomWriter() {
		return new GwtAclDomWriter();
	}

} public class GwtVCard4DomReader extends VCard4DomReader {

	@Override
	protected AclDomReader getAclDomReader() {
		return new GwtAclDomReader();
	}

	@Override
	protected VCard4Factory getProfileFactory() {
		return new GwtProfileFactory();
	}

} public class GwtVCard4DomWriter extends VCard4DomWriter {

	@Override
	protected AclDomWriter getAclDomWriter() {
		return new GwtAclDomWriter();
	}

} public class GwtProfileFactory extends VCard4Factory {

	@Override
	public BirthdayField birthday() {
		return new GwtBirthdayField();
	}

	@Override
	public FullNameField fullname() {
		return new DefaultFullNameField();
	}

	@Override
	public GenderField gender() {
		return new DefaultGenderField();
	}

	@Override
	public NoteField note() {
		return new DefaultNoteField();
	}

	@Override
	public PhotoField photo() {
		return new DefaultPhotoField();
	}

	@Override
	public Profile profile() {
		return new DefaultProfile();
	}

	@Override
	public EmailField email() {
		return new DefaultEmailField();
	}

	@Override
	public NameField name() {
		return new DefaultNameField();
	}

	@Override
	public TelField tel() {
		return new DefaultTelField();
	}

	@Override
	public TimeZoneField timeZone() {
		return new DefaultTimeZoneField();
	}

	@Override
	public URLField url() {
		return new DefaultURLField();
	}

} public interface OswService {

	public void setup(String httpBase, String hostname, String service);

	public void login(String username, String password,
			RequestCallback<Object> callback);

	public void logout(RequestCallback<Object> callback);

	public boolean isLoggedIn();

	public Stream<ActivityEntry> getInbox();

	public void getProfile(String jid, RequestCallback<Profile> callback);

	public void setProfile(Profile profile, RequestCallback<Object> callback);

	public Roster getRoster();

	public Stream<ActivityEntry> getActivities(String jid);

	public void post(ActivityEntry entry, RequestCallback<ActivityEntry> callback);
	
	public void delete(String activityId, RequestCallback<Object> callback);
	
	public void update(ActivityEntry entry, RequestCallback<ActivityEntry> callback);

	public void subscribe(String jid, RequestCallback<Object> callback);

	public void unsubscribe(String jid, RequestCallback<Object> callback);

	public void getRelations(String jid,
			RequestCallback<List<Relation>> callback);

	public void setupRelation(Relation relation,
			RequestCallback<Object> callback);

	public void updateRelation(Relation relation,
			RequestCallback<Object> callback);

	public void getSubscriptions(String jid,
			RequestCallback<List<String>> callback);

	public void getSubscribers(String jid,
			RequestCallback<List<String>> callback);

	public String startUpload(String requestId,
			UpdateCallback<UploadStatus> callback);

	public ActivityFactory getActivityFactory();

	public AtomFactory getAtomFactory();

	public AclFactory getAclFactory();

	public VCard4Factory getProfileFactory();

	public RelationFactory getRelationFactory();

	public String getUserBareJID();

	public String getUserFullJID();

	public Presence getPresence();

} public interface RequestCallback<T> {

	public void onSuccess(T result);

	public void onFailure();
} public interface Roster extends Observable<RosterEvent> {

	public Set<String> getGroups();

	public List<RosterItem> getItems();

	public RosterItem getItem(String jid);

	public void addItem(String jid, String nickname, List<String> groups,
			RequestCallback<RosterItem> callback);

	public void removeItem(String jid, RequestCallback<RosterItem> callback);

} public interface RosterItem extends Observable<RosterEvent> {

	public static enum Presence {
		available, away, chat, dnd, xa, unknown
	};

	public Presence getPresence();

	public String getJid();

	public String getNickname();

	public void setNickname(String nickname);

	public List<String> getGroups();

	public void setGroups(List<String> groups);

	public void save(RequestCallback<RosterItem> callback);

} public interface Stream<T> extends Observable<StreamEvent<T>> {

	public List<T> getItems();

	public void refresh(RequestCallback<List<T>> callback);

	public boolean isReady();

} public interface UpdateCallback<T> {

	public void onUpdate(T update);

	public void onError();
} public interface UploadStatus {

	public class Status {

		public static final String PROGRESS = "http://onesocialweb.org/spec/1.0/upload/status/progress";

		public static final String COMPLETED = "http://onesocialweb.org/spec/1.0/upload/status/completed";

		public static final String ERROR = "http://onesocialweb.org/spec/1.0/upload/status/error";

	}

	public String getRequestId();

	public String getFileId();

	public String getStatus();

	public long getSize();

	public long getBytesRead();

	public String getMimeType();

	public boolean hasRequestId();

	public boolean hasStatus();

	public boolean hasFileId();

	public boolean hasSize();

	public boolean hasMimeType();

	public boolean hasBytesRead();
} public static enum Presence {
	available, away, chat, dnd, xa, unknown
}; public class DocumentAdapter extends NodeAdapter implements Document {

	public DocumentAdapter(com.google.gwt.xml.client.Document document) {
		super(document);
	}

	@Override
	public Node adoptNode(Node source) throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Attr createAttribute(String name) throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Attr createAttributeNS(String namespaceURI, String qualifiedName)
			throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public CDATASection createCDATASection(String data) throws DOMException {
		return new CDataSectionAdapter(getGwtDocument()
				.createCDATASection(data));
	}

	@Override
	public Comment createComment(String data) {
		return new CommentAdapter(getGwtDocument().createComment(data));
	}

	@Override
	public DocumentFragment createDocumentFragment() {
		return new DocumentFragmentAdapter(getGwtDocument()
				.createDocumentFragment());
	}

	@Override
	public Element createElement(String tagName) throws DOMException {
		return new ElementAdapter(getGwtDocument().createElement(tagName));
	}

	@Override
	public Element createElementNS(String namespaceURI, String qualifiedName)
			throws DOMException {
		com.google.gwt.xml.client.Element e = getGwtDocument().createElement(
				qualifiedName);
		e.setAttribute("xmlns", namespaceURI);
		return new ElementAdapter(e);
	}

	@Override
	public EntityReference createEntityReference(String name)
			throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public ProcessingInstruction createProcessingInstruction(String target,
			String data) throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Text createTextNode(String data) {
		return new TextAdapter(getGwtDocument().createTextNode(data));
	}

	@Override
	public DocumentType getDoctype() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Element getDocumentElement() {
		return new ElementAdapter(getGwtDocument().getDocumentElement());
	}

	@Override
	public String getDocumentURI() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public DOMConfiguration getDomConfig() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Element getElementById(String elementId) {
		return new ElementAdapter(getGwtDocument().getElementById(elementId));
	}

	@Override
	public NodeList getElementsByTagName(String tagname) {
		return new NodeListAdapter(getGwtDocument().getElementsByTagName(
				tagname));
	}

	@Override
	public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
		return getElementsByTagName(localName);
	}

	@Override
	public DOMImplementation getImplementation() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public String getInputEncoding() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean getStrictErrorChecking() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public String getXmlEncoding() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean getXmlStandalone() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public String getXmlVersion() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Node importNode(Node importedNode, boolean deep) throws DOMException {
		if (importedNode instanceof NodeAdapter) {
			return new NodeAdapter(getGwtDocument().importNode(
					((NodeAdapter) importedNode).getGwtNode(), deep));
		}
		return null;
	}

	@Override
	public void normalizeDocument() {
		getGwtDocument().normalize();
	}

	@Override
	public Node renameNode(Node n, String namespaceURI, String qualifiedName)
			throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void setDocumentURI(String documentURI) {
		// TODO Auto-generated method stub

	}

	@Override
	public void setStrictErrorChecking(boolean strictErrorChecking) {
		// TODO Auto-generated method stub

	}

	@Override
	public void setXmlStandalone(boolean xmlStandalone) throws DOMException {
		// TODO Auto-generated method stub

	}

	@Override
	public void setXmlVersion(String xmlVersion) throws DOMException {
		// TODO Auto-generated method stub

	}

	protected com.google.gwt.xml.client.Document getGwtDocument() {
		return (com.google.gwt.xml.client.Document) getGwtNode();
	}

} public class ElementAdapter extends NodeAdapter implements Element {

	public ElementAdapter(com.google.gwt.xml.client.Element element) {
		super(element);
	}

	@Override
	public String getAttribute(String name) {
		return getGwtElement().getAttribute(name);
	}

	@Override
	public String getAttributeNS(String namespaceURI, String localName)
			throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Attr getAttributeNode(String name) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Attr getAttributeNodeNS(String namespaceURI, String localName)
			throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public NodeList getElementsByTagName(String name) {
		return new NodeListAdapter(getGwtElement().getElementsByTagName(name));
	}

	@Override
	public NodeList getElementsByTagNameNS(String namespaceURI, String localName)
			throws DOMException {
		return getElementsByTagName(localName);
	}

	@Override
	public TypeInfo getSchemaTypeInfo() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public String getTagName() {
		return getGwtElement().getTagName();
	}

	@Override
	public boolean hasAttribute(String name) {
		return getGwtElement().hasAttribute(name);
	}

	@Override
	public boolean hasAttributeNS(String namespaceURI, String localName)
			throws DOMException {
		return hasAttribute(localName);
	}

	@Override
	public void removeAttribute(String name) throws DOMException {
		getGwtElement().removeAttribute(name);
	}

	@Override
	public void removeAttributeNS(String namespaceURI, String localName)
			throws DOMException {
		removeAttribute(localName);
	}

	@Override
	public Attr removeAttributeNode(Attr oldAttr) throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void setAttribute(String name, String value) throws DOMException {
		getGwtElement().setAttribute(name, value);
	}

	@Override
	public void setAttributeNS(String namespaceURI, String qualifiedName,
			String value) throws DOMException {
		getGwtElement().setAttribute(qualifiedName, value);
	}

	@Override
	public Attr setAttributeNode(Attr newAttr) throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Attr setAttributeNodeNS(Attr newAttr) throws DOMException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void setIdAttribute(String name, boolean isId) throws DOMException {
		// TODO Auto-generated method stub

	}

	@Override
	public void setIdAttributeNS(String namespaceURI, String localName,
			boolean isId) throws DOMException {
		// TODO Auto-generated method stub

	}

	@Override
	public void setIdAttributeNode(Attr idAttr, boolean isId)
			throws DOMException {
		// TODO Auto-generated method stub

	}

	public com.google.gwt.xml.client.Element getGwtElement() {
		return (com.google.gwt.xml.client.Element) getGwtNode();
	}

} public interface Document extends Node {
	/**
	 * The Document Type Declaration (see <code>DocumentType</code>) associated
	 * with this document. For XML documents without a document type declaration
	 * this returns <code>null</code>. For HTML documents, a
	 * <code>DocumentType</code> object may be returned, independently of the
	 * presence or absence of document type declaration in the HTML document. <br>
	 * This provides direct access to the <code>DocumentType</code> node, child
	 * node of this <code>Document</code>. This node can be set at document
	 * creation time and later changed through the use of child nodes
	 * manipulation methods, such as <code>Node.insertBefore</code>, or
	 * <code>Node.replaceChild</code>. Note, however, that while some
	 * implementations may instantiate different types of <code>Document</code>
	 * objects supporting additional features than the "Core", such as "HTML"
	 * [<a href='http://www.w3.org/TR/2003/REC-DOM-Level-2-HTML-20030109'>DOM
	 * Level 2 HTML</a>] , based on the <code>DocumentType</code> specified at
	 * creation time, changing it afterwards is very unlikely to result in a
	 * change of the features supported.
	 * 
	 * @since DOM Level 3
	 */
	public DocumentType getDoctype();

	/**
	 * The <code>DOMImplementation</code> object that handles this document. A
	 * DOM application may use objects from multiple implementations.
	 */
	public DOMImplementation getImplementation();

	/**
	 * This is a convenience attribute that allows direct access to the child
	 * node that is the document element of the document.
	 */
	public Element getDocumentElement();

	/**
	 * Creates an element of the type specified. Note that the instance returned
	 * implements the <code>Element</code> interface, so attributes can be
	 * specified directly on the returned object. <br>
	 * In addition, if there are known attributes with default values,
	 * <code>Attr</code> nodes representing them are automatically created and
	 * attached to the element. <br>
	 * To create an element with a qualified name and namespace URI, use the
	 * <code>createElementNS</code> method.
	 * 
	 * @param tagName
	 *            The name of the element type to instantiate. For XML, this is
	 *            case-sensitive, otherwise it depends on the case-sensitivity
	 *            of the markup language in use. In that case, the name is
	 *            mapped to the canonical form of that markup by the DOM
	 *            implementation.
	 * @return A new <code>Element</code> object with the <code>nodeName</code>
	 *         attribute set to <code>tagName</code>, and <code>localName</code>
	 *         , <code>prefix</code>, and <code>namespaceURI</code> set to
	 *         <code>null</code>.
	 * @exception DOMException
	 *                INVALID_CHARACTER_ERR: Raised if the specified name is not
	 *                an XML name according to the XML version in use specified
	 *                in the <code>Document.xmlVersion</code> attribute.
	 */
	public Element createElement(String tagName) throws DOMException;

	/**
	 * Creates an empty <code>DocumentFragment</code> object.
	 * 
	 * @return A new <code>DocumentFragment</code>.
	 */
	public DocumentFragment createDocumentFragment();

	/**
	 * Creates a <code>Text</code> node given the specified string.
	 * 
	 * @param data
	 *            The data for the node.
	 * @return The new <code>Text</code> object.
	 */
	public Text createTextNode(String data);

	/**
	 * Creates a <code>Comment</code> node given the specified string.
	 * 
	 * @param data
	 *            The data for the node.
	 * @return The new <code>Comment</code> object.
	 */
	public Comment createComment(String data);

	/**
	 * Creates a <code>CDATASection</code> node whose value is the specified
	 * string.
	 * 
	 * @param data
	 *            The data for the <code>CDATASection</code> contents.
	 * @return The new <code>CDATASection</code> object.
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: Raised if this document is an HTML
	 *                document.
	 */
	public CDATASection createCDATASection(String data) throws DOMException;

	/**
	 * Creates a <code>ProcessingInstruction</code> node given the specified
	 * name and data strings.
	 * 
	 * @param target
	 *            The target part of the processing instruction.Unlike
	 *            <code>Document.createElementNS</code> or
	 *            <code>Document.createAttributeNS</code>, no namespace
	 *            well-formed checking is done on the target name. Applications
	 *            should invoke <code>Document.normalizeDocument()</code> with
	 *            the parameter " namespaces" set to <code>true</code> in order
	 *            to ensure that the target name is namespace well-formed.
	 * @param data
	 *            The data for the node.
	 * @return The new <code>ProcessingInstruction</code> object.
	 * @exception DOMException
	 *                INVALID_CHARACTER_ERR: Raised if the specified target is
	 *                not an XML name according to the XML version in use
	 *                specified in the <code>Document.xmlVersion</code>
	 *                attribute. <br>
	 *                NOT_SUPPORTED_ERR: Raised if this document is an HTML
	 *                document.
	 */
	public ProcessingInstruction createProcessingInstruction(String target,
			String data) throws DOMException;

	/**
	 * Creates an <code>Attr</code> of the given name. Note that the
	 * <code>Attr</code> instance can then be set on an <code>Element</code>
	 * using the <code>setAttributeNode</code> method. <br>
	 * To create an attribute with a qualified name and namespace URI, use the
	 * <code>createAttributeNS</code> method.
	 * 
	 * @param name
	 *            The name of the attribute.
	 * @return A new <code>Attr</code> object with the <code>nodeName</code>
	 *         attribute set to <code>name</code>, and <code>localName</code>,
	 *         <code>prefix</code>, and <code>namespaceURI</code> set to
	 *         <code>null</code>. The value of the attribute is the empty
	 *         string.
	 * @exception DOMException
	 *                INVALID_CHARACTER_ERR: Raised if the specified name is not
	 *                an XML name according to the XML version in use specified
	 *                in the <code>Document.xmlVersion</code> attribute.
	 */
	public Attr createAttribute(String name) throws DOMException;

	/**
	 * Creates an <code>EntityReference</code> object. In addition, if the
	 * referenced entity is known, the child list of the
	 * <code>EntityReference</code> node is made the same as that of the
	 * corresponding <code>Entity</code> node.
	 * <p >
	 * <b>Note:</b> If any descendant of the <code>Entity</code> node has an
	 * unbound namespace prefix, the corresponding descendant of the created
	 * <code>EntityReference</code> node is also unbound; (its
	 * <code>namespaceURI</code> is <code>null</code>). The DOM Level 2 and 3 do
	 * not support any mechanism to resolve namespace prefixes in this case.
	 * 
	 * @param name
	 *            The name of the entity to reference.Unlike
	 *            <code>Document.createElementNS</code> or
	 *            <code>Document.createAttributeNS</code>, no namespace
	 *            well-formed checking is done on the entity name. Applications
	 *            should invoke <code>Document.normalizeDocument()</code> with
	 *            the parameter " namespaces" set to <code>true</code> in order
	 *            to ensure that the entity name is namespace well-formed.
	 * @return The new <code>EntityReference</code> object.
	 * @exception DOMException
	 *                INVALID_CHARACTER_ERR: Raised if the specified name is not
	 *                an XML name according to the XML version in use specified
	 *                in the <code>Document.xmlVersion</code> attribute. <br>
	 *                NOT_SUPPORTED_ERR: Raised if this document is an HTML
	 *                document.
	 */
	public EntityReference createEntityReference(String name)
			throws DOMException;

	/**
	 * Returns a <code>NodeList</code> of all the <code>Elements</code> in
	 * document order with a given tag name and are contained in the document.
	 * 
	 * @param tagname
	 *            The name of the tag to match on. The special value "*" matches
	 *            all tags. For XML, the <code>tagname</code> parameter is
	 *            case-sensitive, otherwise it depends on the case-sensitivity
	 *            of the markup language in use.
	 * @return A new <code>NodeList</code> object containing all the matched
	 *         <code>Elements</code>.
	 */
	public NodeList getElementsByTagName(String tagname);

	/**
	 * Imports a node from another document to this document, without altering
	 * or removing the source node from the original document; this method
	 * creates a new copy of the source node. The returned node has no parent; (
	 * <code>parentNode</code> is <code>null</code>). <br>
	 * For all nodes, importing a node creates a node object owned by the
	 * importing document, with attribute values identical to the source node's
	 * <code>nodeName</code> and <code>nodeType</code>, plus the attributes
	 * related to namespaces (<code>prefix</code>, <code>localName</code>, and
	 * <code>namespaceURI</code>). As in the <code>cloneNode</code> operation,
	 * the source node is not altered. User data associated to the imported node
	 * is not carried over. However, if any <code>UserDataHandlers</code> has
	 * been specified along with the associated data these handlers will be
	 * called with the appropriate parameters before this method returns. <br>
	 * Additional information is copied as appropriate to the
	 * <code>nodeType</code>, attempting to mirror the behavior expected if a
	 * fragment of XML or HTML source was copied from one document to another,
	 * recognizing that the two documents may have different DTDs in the XML
	 * case. The following list describes the specifics for each type of node.
	 * <dl>
	 * <dt>ATTRIBUTE_NODE</dt>
	 * <dd>The <code>ownerElement</code> attribute is set to <code>null</code>
	 * and the <code>specified</code> flag is set to <code>true</code> on the
	 * generated <code>Attr</code>. The descendants of the source
	 * <code>Attr</code> are recursively imported and the resulting nodes
	 * reassembled to form the corresponding subtree. Note that the
	 * <code>deep</code> parameter has no effect on <code>Attr</code> nodes;
	 * they always carry their children with them when imported.</dd>
	 * <dt>DOCUMENT_FRAGMENT_NODE</dt>
	 * <dd>If the <code>deep</code> option was set to <code>true</code>, the
	 * descendants of the source <code>DocumentFragment</code> are recursively
	 * imported and the resulting nodes reassembled under the imported
	 * <code>DocumentFragment</code> to form the corresponding subtree.
	 * Otherwise, this simply generates an empty <code>DocumentFragment</code>.</dd>
	 * <dt>DOCUMENT_NODE</dt>
	 * <dd><code>Document</code> nodes cannot be imported.</dd>
	 * <dt>DOCUMENT_TYPE_NODE</dt>
	 * <dd><code>DocumentType</code> nodes cannot be imported.</dd>
	 * <dt>ELEMENT_NODE</dt>
	 * <dd><em>Specified</em> attribute nodes of the source element are
	 * imported, and the generated <code>Attr</code> nodes are attached to the
	 * generated <code>Element</code>. Default attributes are <em>not</em>
	 * copied, though if the document being imported into defines default
	 * attributes for this element name, those are assigned. If the
	 * <code>importNode</code> <code>deep</code> parameter was set to
	 * <code>true</code>, the descendants of the source element are recursively
	 * imported and the resulting nodes reassembled to form the corresponding
	 * subtree.</dd>
	 * <dt>ENTITY_NODE</dt>
	 * <dd><code>Entity</code> nodes can be imported, however in the current
	 * release of the DOM the <code>DocumentType</code> is readonly. Ability to
	 * add these imported nodes to a <code>DocumentType</code> will be
	 * considered for addition to a future release of the DOM.On import, the
	 * <code>publicId</code>, <code>systemId</code>, and
	 * <code>notationName</code> attributes are copied. If a <code>deep</code>
	 * import is requested, the descendants of the the source
	 * <code>Entity</code> are recursively imported and the resulting nodes
	 * reassembled to form the corresponding subtree.</dd>
	 * <dt>
	 * ENTITY_REFERENCE_NODE</dt>
	 * <dd>Only the <code>EntityReference</code> itself is copied, even if a
	 * <code>deep</code> import is requested, since the source and destination
	 * documents might have defined the entity differently. If the document
	 * being imported into provides a definition for this entity name, its value
	 * is assigned.</dd>
	 * <dt>NOTATION_NODE</dt>
	 * <dd>
	 * <code>Notation</code> nodes can be imported, however in the current
	 * release of the DOM the <code>DocumentType</code> is readonly. Ability to
	 * add these imported nodes to a <code>DocumentType</code> will be
	 * considered for addition to a future release of the DOM.On import, the
	 * <code>publicId</code> and <code>systemId</code> attributes are copied.
	 * Note that the <code>deep</code> parameter has no effect on this type of
	 * nodes since they cannot have any children.</dd>
	 * <dt>
	 * PROCESSING_INSTRUCTION_NODE</dt>
	 * <dd>The imported node copies its <code>target</code> and
	 * <code>data</code> values from those of the source node.Note that the
	 * <code>deep</code> parameter has no effect on this type of nodes since
	 * they cannot have any children.</dd>
	 * <dt>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE</dt>
	 * <dd>These three types of nodes inheriting from <code>CharacterData</code>
	 * copy their <code>data</code> and <code>length</code> attributes from
	 * those of the source node.Note that the <code>deep</code> parameter has no
	 * effect on these types of nodes since they cannot have any children.</dd>
	 * </dl>
	 * 
	 * @param importedNode
	 *            The node to import.
	 * @param deep
	 *            If <code>true</code>, recursively import the subtree under the
	 *            specified node; if <code>false</code>, import only the node
	 *            itself, as explained above. This has no effect on nodes that
	 *            cannot have any children, and on <code>Attr</code>, and
	 *            <code>EntityReference</code> nodes.
	 * @return The imported node that belongs to this <code>Document</code>.
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: Raised if the type of node being
	 *                imported is not supported. <br>
	 *                INVALID_CHARACTER_ERR: Raised if one of the imported names
	 *                is not an XML name according to the XML version in use
	 *                specified in the <code>Document.xmlVersion</code>
	 *                attribute. This may happen when importing an XML 1.1 [<a
	 *                href='http://www.w3.org/TR/2004/REC-xml11-20040204/'>XML
	 *                1.1</a>] element into an XML 1.0 document, for instance.
	 * @since DOM Level 2
	 */
	public Node importNode(Node importedNode, boolean deep) throws DOMException;

	/**
	 * Creates an element of the given qualified name and namespace URI. <br>
	 * Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 * Namespaces</a>] , applications must use the value <code>null</code> as
	 * the namespaceURI parameter for methods if they wish to have no namespace.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the element to create.
	 * @param qualifiedName
	 *            The qualified name of the element type to instantiate.
	 * @return A new <code>Element</code> object with the following attributes:
	 *         <table border='1' cellpadding='3'>
	 *         <tr>
	 *         <th>Attribute</th>
	 *         <th>Value</th>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Node.nodeName</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>qualifiedName</code></td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Node.namespaceURI</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>namespaceURI</code></td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'><code>Node.prefix</code>
	 *         </td>
	 *         <td valign='top' rowspan='1' colspan='1'>prefix, extracted from
	 *         <code>qualifiedName</code>, or <code>null</code> if there is no
	 *         prefix</td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Node.localName</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>local name, extracted
	 *         from <code>qualifiedName</code></td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Element.tagName</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>qualifiedName</code></td>
	 *         </tr>
	 *         </table>
	 * @exception DOMException
	 *                INVALID_CHARACTER_ERR: Raised if the specified
	 *                <code>qualifiedName</code> is not an XML name according to
	 *                the XML version in use specified in the
	 *                <code>Document.xmlVersion</code> attribute. <br>
	 *                NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
	 *                a malformed qualified name, if the
	 *                <code>qualifiedName</code> has a prefix and the
	 *                <code>namespaceURI</code> is <code>null</code>, or if the
	 *                <code>qualifiedName</code> has a prefix that is "xml" and
	 *                the <code>namespaceURI</code> is different from "<a
	 *                href='http://www.w3.org/XML/1998/namespace'>
	 *                http://www.w3.org/XML/1998/namespace</a>" [<a href=
	 *                'http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 *                Namespaces</a>] , or if the <code>qualifiedName</code> or
	 *                its prefix is "xmlns" and the <code>namespaceURI</code> is
	 *                different from
	 *                "<a href='http://www.w3.org/2000/xmlns/'>http://www.w3.org/2000/xmlns/</a>"
	 *                , or if the <code>namespaceURI</code> is
	 *                "<a href='http://www.w3.org/2000/xmlns/'>http://www.w3.org/2000/xmlns/</a>"
	 *                and neither the <code>qualifiedName</code> nor its prefix
	 *                is "xmlns". <br>
	 *                NOT_SUPPORTED_ERR: Always thrown if the current document
	 *                does not support the <code>"XML"</code> feature, since
	 *                namespaces were defined by XML.
	 * @since DOM Level 2
	 */
	public Element createElementNS(String namespaceURI, String qualifiedName)
			throws DOMException;

	/**
	 * Creates an attribute of the given qualified name and namespace URI. <br>
	 * Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 * Namespaces</a>] , applications must use the value <code>null</code> as
	 * the <code>namespaceURI</code> parameter for methods if they wish to have
	 * no namespace.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the attribute to create.
	 * @param qualifiedName
	 *            The qualified name of the attribute to instantiate.
	 * @return A new <code>Attr</code> object with the following attributes:
	 *         <table border='1' cellpadding='3'>
	 *         <tr>
	 *         <th>
	 *         Attribute</th>
	 *         <th>Value</th>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Node.nodeName</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>qualifiedName</td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Node.namespaceURI</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>namespaceURI</code></td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Node.prefix</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>prefix, extracted from
	 *         <code>qualifiedName</code>, or <code>null</code> if there is no
	 *         prefix</td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Node.localName</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>local name, extracted
	 *         from <code>qualifiedName</code></td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'><code>Attr.name</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>qualifiedName</code></td>
	 *         </tr>
	 *         <tr>
	 *         <td valign='top' rowspan='1' colspan='1'>
	 *         <code>Node.nodeValue</code></td>
	 *         <td valign='top' rowspan='1' colspan='1'>the empty string</td>
	 *         </tr>
	 *         </table>
	 * @exception DOMException
	 *                INVALID_CHARACTER_ERR: Raised if the specified
	 *                <code>qualifiedName</code> is not an XML name according to
	 *                the XML version in use specified in the
	 *                <code>Document.xmlVersion</code> attribute. <br>
	 *                NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
	 *                a malformed qualified name, if the
	 *                <code>qualifiedName</code> has a prefix and the
	 *                <code>namespaceURI</code> is <code>null</code>, if the
	 *                <code>qualifiedName</code> has a prefix that is "xml" and
	 *                the <code>namespaceURI</code> is different from "<a
	 *                href='http://www.w3.org/XML/1998/namespace'>
	 *                http://www.w3.org/XML/1998/namespace</a>", if the
	 *                <code>qualifiedName</code> or its prefix is "xmlns" and
	 *                the <code>namespaceURI</code> is different from
	 *                "<a href='http://www.w3.org/2000/xmlns/'>http://www.w3.org/2000/xmlns/</a>"
	 *                , or if the <code>namespaceURI</code> is
	 *                "<a href='http://www.w3.org/2000/xmlns/'>http://www.w3.org/2000/xmlns/</a>"
	 *                and neither the <code>qualifiedName</code> nor its prefix
	 *                is "xmlns". <br>
	 *                NOT_SUPPORTED_ERR: Always thrown if the current document
	 *                does not support the <code>"XML"</code> feature, since
	 *                namespaces were defined by XML.
	 * @since DOM Level 2
	 */
	public Attr createAttributeNS(String namespaceURI, String qualifiedName)
			throws DOMException;

	/**
	 * Returns a <code>NodeList</code> of all the <code>Elements</code> with a
	 * given local name and namespace URI in document order.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the elements to match on. The special
	 *            value <code>"*"</code> matches all namespaces.
	 * @param localName
	 *            The local name of the elements to match on. The special value
	 *            "*" matches all local names.
	 * @return A new <code>NodeList</code> object containing all the matched
	 *         <code>Elements</code>.
	 * @since DOM Level 2
	 */
	public NodeList getElementsByTagNameNS(String namespaceURI, String localName);

	/**
	 * Returns the <code>Element</code> that has an ID attribute with the given
	 * value. If no such element exists, this returns <code>null</code> . If
	 * more than one element has an ID attribute with that value, what is
	 * returned is undefined. <br>
	 * The DOM implementation is expected to use the attribute
	 * <code>Attr.isId</code> to determine if an attribute is of type ID.
	 * <p >
	 * <b>Note:</b> Attributes with the name "ID" or "id" are not of type ID
	 * unless so defined.
	 * 
	 * @param elementId
	 *            The unique <code>id</code> value for an element.
	 * @return The matching element or <code>null</code> if there is none.
	 * @since DOM Level 2
	 */
	public Element getElementById(String elementId);

	/**
	 * An attribute specifying the encoding used for this document at the time
	 * of the parsing. This is <code>null</code> when it is not known, such as
	 * when the <code>Document</code> was created in memory.
	 * 
	 * @since DOM Level 3
	 */
	public String getInputEncoding();

	/**
	 * An attribute specifying, as part of the <a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML
	 * declaration</a>, the encoding of this document. This is <code>null</code>
	 * when unspecified or when it is not known, such as when the
	 * <code>Document</code> was created in memory.
	 * 
	 * @since DOM Level 3
	 */
	public String getXmlEncoding();

	/**
	 * An attribute specifying, as part of the <a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML
	 * declaration</a>, whether this document is standalone. This is
	 * <code>false</code> when unspecified.
	 * <p >
	 * <b>Note:</b> No verification is done on the value when setting this
	 * attribute. Applications should use
	 * <code>Document.normalizeDocument()</code> with the "validate" parameter
	 * to verify if the value matches the <a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204#sec-rmd'>validity
	 * constraint for standalone document declaration</a> as defined in [<a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>].
	 * 
	 * @since DOM Level 3
	 */
	public boolean getXmlStandalone();

	/**
	 * An attribute specifying, as part of the <a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML
	 * declaration</a>, whether this document is standalone. This is
	 * <code>false</code> when unspecified.
	 * <p >
	 * <b>Note:</b> No verification is done on the value when setting this
	 * attribute. Applications should use
	 * <code>Document.normalizeDocument()</code> with the "validate" parameter
	 * to verify if the value matches the <a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204#sec-rmd'>validity
	 * constraint for standalone document declaration</a> as defined in [<a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>].
	 * 
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: Raised if this document does not
	 *                support the "XML" feature.
	 * @since DOM Level 3
	 */
	public void setXmlStandalone(boolean xmlStandalone) throws DOMException;

	/**
	 * An attribute specifying, as part of the <a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML
	 * declaration</a>, the version number of this document. If there is no
	 * declaration and if this document supports the "XML" feature, the value is
	 * <code>"1.0"</code>. If this document does not support the "XML" feature,
	 * the value is always <code>null</code>. Changing this attribute will
	 * affect methods that check for invalid characters in XML names.
	 * Application should invoke <code>Document.normalizeDocument()</code> in
	 * order to check for invalid characters in the <code>Node</code>s that are
	 * already part of this <code>Document</code>. <br>
	 * DOM applications may use the
	 * <code>DOMImplementation.hasFeature(feature, version)</code> method with
	 * parameter values "XMLVersion" and "1.0" (respectively) to determine if an
	 * implementation supports [<a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>]. DOM
	 * applications may use the same method with parameter values "XMLVersion"
	 * and "1.1" (respectively) to determine if an implementation supports [<a
	 * href='http://www.w3.org/TR/2004/REC-xml11-20040204/'>XML 1.1</a>]. In
	 * both cases, in order to support XML, an implementation must also support
	 * the "XML" feature defined in this specification. <code>Document</code>
	 * objects supporting a version of the "XMLVersion" feature must not raise a
	 * <code>NOT_SUPPORTED_ERR</code> exception for the same version number when
	 * using <code>Document.xmlVersion</code>.
	 * 
	 * @since DOM Level 3
	 */
	public String getXmlVersion();

	/**
	 * An attribute specifying, as part of the <a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML
	 * declaration</a>, the version number of this document. If there is no
	 * declaration and if this document supports the "XML" feature, the value is
	 * <code>"1.0"</code>. If this document does not support the "XML" feature,
	 * the value is always <code>null</code>. Changing this attribute will
	 * affect methods that check for invalid characters in XML names.
	 * Application should invoke <code>Document.normalizeDocument()</code> in
	 * order to check for invalid characters in the <code>Node</code>s that are
	 * already part of this <code>Document</code>. <br>
	 * DOM applications may use the
	 * <code>DOMImplementation.hasFeature(feature, version)</code> method with
	 * parameter values "XMLVersion" and "1.0" (respectively) to determine if an
	 * implementation supports [<a
	 * href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>]. DOM
	 * applications may use the same method with parameter values "XMLVersion"
	 * and "1.1" (respectively) to determine if an implementation supports [<a
	 * href='http://www.w3.org/TR/2004/REC-xml11-20040204/'>XML 1.1</a>]. In
	 * both cases, in order to support XML, an implementation must also support
	 * the "XML" feature defined in this specification. <code>Document</code>
	 * objects supporting a version of the "XMLVersion" feature must not raise a
	 * <code>NOT_SUPPORTED_ERR</code> exception for the same version number when
	 * using <code>Document.xmlVersion</code>.
	 * 
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: Raised if the version is set to a value
	 *                that is not supported by this <code>Document</code> or if
	 *                this document does not support the "XML" feature.
	 * @since DOM Level 3
	 */
	public void setXmlVersion(String xmlVersion) throws DOMException;

	/**
	 * An attribute specifying whether error checking is enforced or not. When
	 * set to <code>false</code>, the implementation is free to not test every
	 * possible error case normally defined on DOM operations, and not raise any
	 * <code>DOMException</code> on DOM operations or report errors while using
	 * <code>Document.normalizeDocument()</code>. In case of error, the behavior
	 * is undefined. This attribute is <code>true</code> by default.
	 * 
	 * @since DOM Level 3
	 */
	public boolean getStrictErrorChecking();

	/**
	 * An attribute specifying whether error checking is enforced or not. When
	 * set to <code>false</code>, the implementation is free to not test every
	 * possible error case normally defined on DOM operations, and not raise any
	 * <code>DOMException</code> on DOM operations or report errors while using
	 * <code>Document.normalizeDocument()</code>. In case of error, the behavior
	 * is undefined. This attribute is <code>true</code> by default.
	 * 
	 * @since DOM Level 3
	 */
	public void setStrictErrorChecking(boolean strictErrorChecking);

	/**
	 * The location of the document or <code>null</code> if undefined or if the
	 * <code>Document</code> was created using
	 * <code>DOMImplementation.createDocument</code>. No lexical checking is
	 * performed when setting this attribute; this could result in a
	 * <code>null</code> value returned when using <code>Node.baseURI</code> . <br>
	 * Beware that when the <code>Document</code> supports the feature "HTML"
	 * [<a href='http://www.w3.org/TR/2003/REC-DOM-Level-2-HTML-20030109'>DOM
	 * Level 2 HTML</a>] , the href attribute of the HTML BASE element takes
	 * precedence over this attribute when computing <code>Node.baseURI</code>.
	 * 
	 * @since DOM Level 3
	 */
	public String getDocumentURI();

	/**
	 * The location of the document or <code>null</code> if undefined or if the
	 * <code>Document</code> was created using
	 * <code>DOMImplementation.createDocument</code>. No lexical checking is
	 * performed when setting this attribute; this could result in a
	 * <code>null</code> value returned when using <code>Node.baseURI</code> . <br>
	 * Beware that when the <code>Document</code> supports the feature "HTML"
	 * [<a href='http://www.w3.org/TR/2003/REC-DOM-Level-2-HTML-20030109'>DOM
	 * Level 2 HTML</a>] , the href attribute of the HTML BASE element takes
	 * precedence over this attribute when computing <code>Node.baseURI</code>.
	 * 
	 * @since DOM Level 3
	 */
	public void setDocumentURI(String documentURI);

	/**
	 * Attempts to adopt a node from another document to this document. If
	 * supported, it changes the <code>ownerDocument</code> of the source node,
	 * its children, as well as the attached attribute nodes if there are any.
	 * If the source node has a parent it is first removed from the child list
	 * of its parent. This effectively allows moving a subtree from one document
	 * to another (unlike <code>importNode()</code> which create a copy of the
	 * source node instead of moving it). When it fails, applications should use
	 * <code>Document.importNode()</code> instead. Note that if the adopted node
	 * is already part of this document (i.e. the source and target document are
	 * the same), this method still has the effect of removing the source node
	 * from the child list of its parent, if any. The following list describes
	 * the specifics for each type of node.
	 * <dl>
	 * <dt>ATTRIBUTE_NODE</dt>
	 * <dd>The <code>ownerElement</code> attribute is set to <code>null</code>
	 * and the <code>specified</code> flag is set to <code>true</code> on the
	 * adopted <code>Attr</code>. The descendants of the source
	 * <code>Attr</code> are recursively adopted.</dd>
	 * <dt>DOCUMENT_FRAGMENT_NODE</dt>
	 * <dd>The descendants of the source node are recursively adopted.</dd>
	 * <dt>DOCUMENT_NODE</dt>
	 * <dd>
	 * <code>Document</code> nodes cannot be adopted.</dd>
	 * <dt>DOCUMENT_TYPE_NODE</dt>
	 * <dd>
	 * <code>DocumentType</code> nodes cannot be adopted.</dd>
	 * <dt>ELEMENT_NODE</dt>
	 * <dd><em>Specified</em> attribute nodes of the source element are adopted.
	 * Default attributes are discarded, though if the document being adopted
	 * into defines default attributes for this element name, those are
	 * assigned. The descendants of the source element are recursively adopted.</dd>
	 * <dt>ENTITY_NODE</dt>
	 * <dd>
	 * <code>Entity</code> nodes cannot be adopted.</dd>
	 * <dt>ENTITY_REFERENCE_NODE</dt>
	 * <dd>Only the <code>EntityReference</code> node itself is adopted, the
	 * descendants are discarded, since the source and destination documents
	 * might have defined the entity differently. If the document being imported
	 * into provides a definition for this entity name, its value is assigned.</dd>
	 * <dt>NOTATION_NODE</dt>
	 * <dd><code>Notation</code> nodes cannot be adopted.</dd>
	 * <dt>PROCESSING_INSTRUCTION_NODE, TEXT_NODE, CDATA_SECTION_NODE,
	 * COMMENT_NODE</dt>
	 * <dd>These nodes can all be adopted. No specifics.</dd>
	 * </dl>
	 * <p >
	 * <b>Note:</b> Since it does not create new nodes unlike the
	 * <code>Document.importNode()</code> method, this method does not raise an
	 * <code>INVALID_CHARACTER_ERR</code> exception, and applications should use
	 * the <code>Document.normalizeDocument()</code> method to check if an
	 * imported name is not an XML name according to the XML version in use.
	 * 
	 * @param source
	 *            The node to move into this document.
	 * @return The adopted node, or <code>null</code> if this operation fails,
	 *         such as when the source node comes from a different
	 *         implementation.
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: Raised if the source node is of type
	 *                <code>DOCUMENT</code>, <code>DOCUMENT_TYPE</code>. <br>
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised when the source node
	 *                is readonly.
	 * @since DOM Level 3
	 */
	public Node adoptNode(Node source) throws DOMException;

	/**
	 * The configuration used when <code>Document.normalizeDocument()</code> is
	 * invoked.
	 * 
	 * @since DOM Level 3
	 */
	public DOMConfiguration getDomConfig();

	/**
	 * This method acts as if the document was going through a save and load
	 * cycle, putting the document in a "normal" form. As a consequence, this
	 * method updates the replacement tree of <code>EntityReference</code> nodes
	 * and normalizes <code>Text</code> nodes, as defined in the method
	 * <code>Node.normalize()</code>. <br>
	 * Otherwise, the actual result depends on the features being set on the
	 * <code>Document.domConfig</code> object and governing what operations
	 * actually take place. Noticeably this method could also make the document
	 * namespace well-formed according to the algorithm described in , check the
	 * character normalization, remove the <code>CDATASection</code> nodes, etc.
	 * See <code>DOMConfiguration</code> for details.
	 * 
	 * <pre>
	 * // Keep in the document 
	 * the information defined // in the XML Information Set (Java example) 
	 * DOMConfiguration docConfig = myDocument.getDomConfig(); 
	 * docConfig.setParameter("infoset", Boolean.TRUE); 
	 * myDocument.normalizeDocument();
	 * </pre>
	 * 
	 * <br>
	 * Mutation events, when supported, are generated to reflect the changes
	 * occurring on the document. <br>
	 * If errors occur during the invocation of this method, such as an attempt
	 * to update a read-only node or a <code>Node.nodeName</code> contains an
	 * invalid character according to the XML version in use, errors or warnings
	 * (<code>DOMError.SEVERITY_ERROR</code> or
	 * <code>DOMError.SEVERITY_WARNING</code>) will be reported using the
	 * <code>DOMErrorHandler</code> object associated with the "error-handler "
	 * parameter. Note this method might also report fatal errors (
	 * <code>DOMError.SEVERITY_FATAL_ERROR</code>) if an implementation cannot
	 * recover from an error.
	 * 
	 * @since DOM Level 3
	 */
	public void normalizeDocument();

	/**
	 * Rename an existing node of type <code>ELEMENT_NODE</code> or
	 * <code>ATTRIBUTE_NODE</code>. <br>
	 * When possible this simply changes the name of the given node, otherwise
	 * this creates a new node with the specified name and replaces the existing
	 * node with the new node as described below. <br>
	 * If simply changing the name of the given node is not possible, the
	 * following operations are performed: a new node is created, any registered
	 * event listener is registered on the new node, any user data attached to
	 * the old node is removed from that node, the old node is removed from its
	 * parent if it has one, the children are moved to the new node, if the
	 * renamed node is an <code>Element</code> its attributes are moved to the
	 * new node, the new node is inserted at the position the old node used to
	 * have in its parent's child nodes list if it has one, the user data that
	 * was attached to the old node is attached to the new node. <br>
	 * When the node being renamed is an <code>Element</code> only the specified
	 * attributes are moved, default attributes originated from the DTD are
	 * updated according to the new element name. In addition, the
	 * implementation may update default attributes from other schemas.
	 * Applications should use <code>Document.normalizeDocument()</code> to
	 * guarantee these attributes are up-to-date. <br>
	 * When the node being renamed is an <code>Attr</code> that is attached to
	 * an <code>Element</code>, the node is first removed from the
	 * <code>Element</code> attributes map. Then, once renamed, either by
	 * modifying the existing node or creating a new one as described above, it
	 * is put back. <br>
	 * In addition,
	 * <ul>
	 * <li>a user data event <code>NODE_RENAMED</code> is fired,</li>
	 * <li>
	 * when the implementation supports the feature "MutationNameEvents", each
	 * mutation operation involved in this method fires the appropriate event,
	 * and in the end the event { <code>http://www.w3.org/2001/xml-events</code>, <code>DOMElementNameChanged</code> or {
	 * <code>http://www.w3.org/2001/xml-events</code>,
	 * <code>DOMAttributeNameChanged</code> is fired.</li>
	 * </ul>
	 * 
	 * @param n
	 *            The node to rename.
	 * @param namespaceURI
	 *            The new namespace URI.
	 * @param qualifiedName
	 *            The new qualified name.
	 * @return The renamed node. This is either the specified node or the new
	 *         node that was created to replace the specified node.
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: Raised when the type of the specified
	 *                node is neither <code>ELEMENT_NODE</code> nor
	 *                <code>ATTRIBUTE_NODE</code>, or if the implementation does
	 *                not support the renaming of the document element. <br>
	 *                INVALID_CHARACTER_ERR: Raised if the new qualified name is
	 *                not an XML name according to the XML version in use
	 *                specified in the <code>Document.xmlVersion</code>
	 *                attribute. <br>
	 *                WRONG_DOCUMENT_ERR: Raised when the specified node was
	 *                created from a different document than this document. <br>
	 *                NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
	 *                a malformed qualified name, if the
	 *                <code>qualifiedName</code> has a prefix and the
	 *                <code>namespaceURI</code> is <code>null</code>, or if the
	 *                <code>qualifiedName</code> has a prefix that is "xml" and
	 *                the <code>namespaceURI</code> is different from "<a
	 *                href='http://www.w3.org/XML/1998/namespace'>
	 *                http://www.w3.org/XML/1998/namespace</a>" [<a href=
	 *                'http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 *                Namespaces</a>] . Also raised, when the node being renamed
	 *                is an attribute, if the <code>qualifiedName</code>, or its
	 *                prefix, is "xmlns" and the <code>namespaceURI</code> is
	 *                different from
	 *                "<a href='http://www.w3.org/2000/xmlns/'>http://www.w3.org/2000/xmlns/</a>"
	 *                .
	 * @since DOM Level 3
	 */
	public Node renameNode(Node n, String namespaceURI, String qualifiedName)
			throws DOMException;

} public interface Element extends Node {
	/**
	 * The name of the element. If <code>Node.localName</code> is different from
	 * <code>null</code>, this attribute is a qualified name. For example, in:
	 * 
	 * <pre>
	 * &lt;elementExample id="demo"&gt; ... 
	 * &lt;/elementExample&gt; ,
	 * </pre>
	 * 
	 * <code>tagName</code> has the value <code>"elementExample"</code>. Note
	 * that this is case-preserving in XML, as are all of the operations of the
	 * DOM. The HTML DOM returns the <code>tagName</code> of an HTML element in
	 * the canonical uppercase form, regardless of the case in the source HTML
	 * document.
	 */
	public String getTagName();

	/**
	 * Retrieves an attribute value by name.
	 * 
	 * @param name
	 *            The name of the attribute to retrieve.
	 * @return The <code>Attr</code> value as a string, or the empty string if
	 *         that attribute does not have a specified or default value.
	 */
	public String getAttribute(String name);

	/**
	 * Adds a new attribute. If an attribute with that name is already present
	 * in the element, its value is changed to be that of the value parameter.
	 * This value is a simple string; it is not parsed as it is being set. So
	 * any markup (such as syntax to be recognized as an entity reference) is
	 * treated as literal text, and needs to be appropriately escaped by the
	 * implementation when it is written out. In order to assign an attribute
	 * value that contains entity references, the user must create an
	 * <code>Attr</code> node plus any <code>Text</code> and
	 * <code>EntityReference</code> nodes, build the appropriate subtree, and
	 * use <code>setAttributeNode</code> to assign it as the value of an
	 * attribute. <br>
	 * To set an attribute with a qualified name and namespace URI, use the
	 * <code>setAttributeNS</code> method.
	 * 
	 * @param name
	 *            The name of the attribute to create or alter.
	 * @param value
	 *            Value to set in string form.
	 * @exception DOMException
	 *                INVALID_CHARACTER_ERR: Raised if the specified name is not
	 *                an XML name according to the XML version in use specified
	 *                in the <code>Document.xmlVersion</code> attribute. <br>
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly.
	 */
	public void setAttribute(String name, String value) throws DOMException;

	/**
	 * Removes an attribute by name. If a default value for the removed
	 * attribute is defined in the DTD, a new attribute immediately appears with
	 * the default value as well as the corresponding namespace URI, local name,
	 * and prefix when applicable. The implementation may handle default values
	 * from other schemas similarly but applications should use
	 * <code>Document.normalizeDocument()</code> to guarantee this information
	 * is up-to-date. <br>
	 * If no attribute with this name is found, this method has no effect. <br>
	 * To remove an attribute by local name and namespace URI, use the
	 * <code>removeAttributeNS</code> method.
	 * 
	 * @param name
	 *            The name of the attribute to remove.
	 * @exception DOMException
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly.
	 */
	public void removeAttribute(String name) throws DOMException;

	/**
	 * Retrieves an attribute node by name. <br>
	 * To retrieve an attribute node by qualified name and namespace URI, use
	 * the <code>getAttributeNodeNS</code> method.
	 * 
	 * @param name
	 *            The name (<code>nodeName</code>) of the attribute to retrieve.
	 * @return The <code>Attr</code> node with the specified name (
	 *         <code>nodeName</code>) or <code>null</code> if there is no such
	 *         attribute.
	 */
	public Attr getAttributeNode(String name);

	/**
	 * Adds a new attribute node. If an attribute with that name (
	 * <code>nodeName</code>) is already present in the element, it is replaced
	 * by the new one. Replacing an attribute node by itself has no effect. <br>
	 * To add a new attribute node with a qualified name and namespace URI, use
	 * the <code>setAttributeNodeNS</code> method.
	 * 
	 * @param newAttr
	 *            The <code>Attr</code> node to add to the attribute list.
	 * @return If the <code>newAttr</code> attribute replaces an existing
	 *         attribute, the replaced <code>Attr</code> node is returned,
	 *         otherwise <code>null</code> is returned.
	 * @exception DOMException
	 *                WRONG_DOCUMENT_ERR: Raised if <code>newAttr</code> was
	 *                created from a different document than the one that
	 *                created the element. <br>
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly. <br>
	 *                INUSE_ATTRIBUTE_ERR: Raised if <code>newAttr</code> is
	 *                already an attribute of another <code>Element</code>
	 *                object. The DOM user must explicitly clone
	 *                <code>Attr</code> nodes to re-use them in other elements.
	 */
	public Attr setAttributeNode(Attr newAttr) throws DOMException;

	/**
	 * Removes the specified attribute node. If a default value for the removed
	 * <code>Attr</code> node is defined in the DTD, a new node immediately
	 * appears with the default value as well as the corresponding namespace
	 * URI, local name, and prefix when applicable. The implementation may
	 * handle default values from other schemas similarly but applications
	 * should use <code>Document.normalizeDocument()</code> to guarantee this
	 * information is up-to-date.
	 * 
	 * @param oldAttr
	 *            The <code>Attr</code> node to remove from the attribute list.
	 * @return The <code>Attr</code> node that was removed.
	 * @exception DOMException
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly. <br>
	 *                NOT_FOUND_ERR: Raised if <code>oldAttr</code> is not an
	 *                attribute of the element.
	 */
	public Attr removeAttributeNode(Attr oldAttr) throws DOMException;

	/**
	 * Returns a <code>NodeList</code> of all descendant <code>Elements</code>
	 * with a given tag name, in document order.
	 * 
	 * @param name
	 *            The name of the tag to match on. The special value "*" matches
	 *            all tags.
	 * @return A list of matching <code>Element</code> nodes.
	 */
	public NodeList getElementsByTagName(String name);

	/**
	 * Retrieves an attribute value by local name and namespace URI. <br>
	 * Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 * Namespaces</a>] , applications must use the value <code>null</code> as
	 * the <code>namespaceURI</code> parameter for methods if they wish to have
	 * no namespace.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the attribute to retrieve.
	 * @param localName
	 *            The local name of the attribute to retrieve.
	 * @return The <code>Attr</code> value as a string, or the empty string if
	 *         that attribute does not have a specified or default value.
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: May be raised if the implementation
	 *                does not support the feature <code>"XML"</code> and the
	 *                language exposed through the Document does not support XML
	 *                Namespaces (such as [<a href=
	 *                'http://www.w3.org/TR/1999/REC-html401-19991224/'>HTML
	 *                4.01</a>]).
	 * @since DOM Level 2
	 */
	public String getAttributeNS(String namespaceURI, String localName)
			throws DOMException;

	/**
	 * Adds a new attribute. If an attribute with the same local name and
	 * namespace URI is already present on the element, its prefix is changed to
	 * be the prefix part of the <code>qualifiedName</code>, and its value is
	 * changed to be the <code>value</code> parameter. This value is a simple
	 * string; it is not parsed as it is being set. So any markup (such as
	 * syntax to be recognized as an entity reference) is treated as literal
	 * text, and needs to be appropriately escaped by the implementation when it
	 * is written out. In order to assign an attribute value that contains
	 * entity references, the user must create an <code>Attr</code> node plus
	 * any <code>Text</code> and <code>EntityReference</code> nodes, build the
	 * appropriate subtree, and use <code>setAttributeNodeNS</code> or
	 * <code>setAttributeNode</code> to assign it as the value of an attribute. <br>
	 * Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 * Namespaces</a>] , applications must use the value <code>null</code> as
	 * the <code>namespaceURI</code> parameter for methods if they wish to have
	 * no namespace.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the attribute to create or alter.
	 * @param qualifiedName
	 *            The qualified name of the attribute to create or alter.
	 * @param value
	 *            The value to set in string form.
	 * @exception DOMException
	 *                INVALID_CHARACTER_ERR: Raised if the specified qualified
	 *                name is not an XML name according to the XML version in
	 *                use specified in the <code>Document.xmlVersion</code>
	 *                attribute. <br>
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly. <br>
	 *                NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
	 *                malformed per the Namespaces in XML specification, if the
	 *                <code>qualifiedName</code> has a prefix and the
	 *                <code>namespaceURI</code> is <code>null</code>, if the
	 *                <code>qualifiedName</code> has a prefix that is "xml" and
	 *                the <code>namespaceURI</code> is different from "<a
	 *                href='http://www.w3.org/XML/1998/namespace'>
	 *                http://www.w3.org/XML/1998/namespace</a>", if the
	 *                <code>qualifiedName</code> or its prefix is "xmlns" and
	 *                the <code>namespaceURI</code> is different from
	 *                "<a href='http://www.w3.org/2000/xmlns/'>http://www.w3.org/2000/xmlns/</a>"
	 *                , or if the <code>namespaceURI</code> is
	 *                "<a href='http://www.w3.org/2000/xmlns/'>http://www.w3.org/2000/xmlns/</a>"
	 *                and neither the <code>qualifiedName</code> nor its prefix
	 *                is "xmlns". <br>
	 *                NOT_SUPPORTED_ERR: May be raised if the implementation
	 *                does not support the feature <code>"XML"</code> and the
	 *                language exposed through the Document does not support XML
	 *                Namespaces (such as [<a href=
	 *                'http://www.w3.org/TR/1999/REC-html401-19991224/'>HTML
	 *                4.01</a>]).
	 * @since DOM Level 2
	 */
	public void setAttributeNS(String namespaceURI, String qualifiedName,
			String value) throws DOMException;

	/**
	 * Removes an attribute by local name and namespace URI. If a default value
	 * for the removed attribute is defined in the DTD, a new attribute
	 * immediately appears with the default value as well as the corresponding
	 * namespace URI, local name, and prefix when applicable. The implementation
	 * may handle default values from other schemas similarly but applications
	 * should use <code>Document.normalizeDocument()</code> to guarantee this
	 * information is up-to-date. <br>
	 * If no attribute with this local name and namespace URI is found, this
	 * method has no effect. <br>
	 * Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 * Namespaces</a>] , applications must use the value <code>null</code> as
	 * the <code>namespaceURI</code> parameter for methods if they wish to have
	 * no namespace.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the attribute to remove.
	 * @param localName
	 *            The local name of the attribute to remove.
	 * @exception DOMException
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly. <br>
	 *                NOT_SUPPORTED_ERR: May be raised if the implementation
	 *                does not support the feature <code>"XML"</code> and the
	 *                language exposed through the Document does not support XML
	 *                Namespaces (such as [<a href=
	 *                'http://www.w3.org/TR/1999/REC-html401-19991224/'>HTML
	 *                4.01</a>]).
	 * @since DOM Level 2
	 */
	public void removeAttributeNS(String namespaceURI, String localName)
			throws DOMException;

	/**
	 * Retrieves an <code>Attr</code> node by local name and namespace URI. <br>
	 * Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 * Namespaces</a>] , applications must use the value <code>null</code> as
	 * the <code>namespaceURI</code> parameter for methods if they wish to have
	 * no namespace.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the attribute to retrieve.
	 * @param localName
	 *            The local name of the attribute to retrieve.
	 * @return The <code>Attr</code> node with the specified attribute local
	 *         name and namespace URI or <code>null</code> if there is no such
	 *         attribute.
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: May be raised if the implementation
	 *                does not support the feature <code>"XML"</code> and the
	 *                language exposed through the Document does not support XML
	 *                Namespaces (such as [<a href=
	 *                'http://www.w3.org/TR/1999/REC-html401-19991224/'>HTML
	 *                4.01</a>]).
	 * @since DOM Level 2
	 */
	public Attr getAttributeNodeNS(String namespaceURI, String localName)
			throws DOMException;

	/**
	 * Adds a new attribute. If an attribute with that local name and that
	 * namespace URI is already present in the element, it is replaced by the
	 * new one. Replacing an attribute node by itself has no effect. <br>
	 * Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 * Namespaces</a>] , applications must use the value <code>null</code> as
	 * the <code>namespaceURI</code> parameter for methods if they wish to have
	 * no namespace.
	 * 
	 * @param newAttr
	 *            The <code>Attr</code> node to add to the attribute list.
	 * @return If the <code>newAttr</code> attribute replaces an existing
	 *         attribute with the same local name and namespace URI, the
	 *         replaced <code>Attr</code> node is returned, otherwise
	 *         <code>null</code> is returned.
	 * @exception DOMException
	 *                WRONG_DOCUMENT_ERR: Raised if <code>newAttr</code> was
	 *                created from a different document than the one that
	 *                created the element. <br>
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly. <br>
	 *                INUSE_ATTRIBUTE_ERR: Raised if <code>newAttr</code> is
	 *                already an attribute of another <code>Element</code>
	 *                object. The DOM user must explicitly clone
	 *                <code>Attr</code> nodes to re-use them in other elements. <br>
	 *                NOT_SUPPORTED_ERR: May be raised if the implementation
	 *                does not support the feature <code>"XML"</code> and the
	 *                language exposed through the Document does not support XML
	 *                Namespaces (such as [<a href=
	 *                'http://www.w3.org/TR/1999/REC-html401-19991224/'>HTML
	 *                4.01</a>]).
	 * @since DOM Level 2
	 */
	public Attr setAttributeNodeNS(Attr newAttr) throws DOMException;

	/**
	 * Returns a <code>NodeList</code> of all the descendant
	 * <code>Elements</code> with a given local name and namespace URI in
	 * document order.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the elements to match on. The special
	 *            value "*" matches all namespaces.
	 * @param localName
	 *            The local name of the elements to match on. The special value
	 *            "*" matches all local names.
	 * @return A new <code>NodeList</code> object containing all the matched
	 *         <code>Elements</code>.
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: May be raised if the implementation
	 *                does not support the feature <code>"XML"</code> and the
	 *                language exposed through the Document does not support XML
	 *                Namespaces (such as [<a href=
	 *                'http://www.w3.org/TR/1999/REC-html401-19991224/'>HTML
	 *                4.01</a>]).
	 * @since DOM Level 2
	 */
	public NodeList getElementsByTagNameNS(String namespaceURI, String localName)
			throws DOMException;

	/**
	 * Returns <code>true</code> when an attribute with a given name is
	 * specified on this element or has a default value, <code>false</code>
	 * otherwise.
	 * 
	 * @param name
	 *            The name of the attribute to look for.
	 * @return <code>true</code> if an attribute with the given name is
	 *         specified on this element or has a default value,
	 *         <code>false</code> otherwise.
	 * @since DOM Level 2
	 */
	public boolean hasAttribute(String name);

	/**
	 * Returns <code>true</code> when an attribute with a given local name and
	 * namespace URI is specified on this element or has a default value,
	 * <code>false</code> otherwise. <br>
	 * Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML
	 * Namespaces</a>] , applications must use the value <code>null</code> as
	 * the <code>namespaceURI</code> parameter for methods if they wish to have
	 * no namespace.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the attribute to look for.
	 * @param localName
	 *            The local name of the attribute to look for.
	 * @return <code>true</code> if an attribute with the given local name and
	 *         namespace URI is specified or has a default value on this
	 *         element, <code>false</code> otherwise.
	 * @exception DOMException
	 *                NOT_SUPPORTED_ERR: May be raised if the implementation
	 *                does not support the feature <code>"XML"</code> and the
	 *                language exposed through the Document does not support XML
	 *                Namespaces (such as [<a href=
	 *                'http://www.w3.org/TR/1999/REC-html401-19991224/'>HTML
	 *                4.01</a>]).
	 * @since DOM Level 2
	 */
	public boolean hasAttributeNS(String namespaceURI, String localName)
			throws DOMException;

	/**
	 * The type information associated with this element.
	 * 
	 * @since DOM Level 3
	 */
	public TypeInfo getSchemaTypeInfo();

	/**
	 * If the parameter <code>isId</code> is <code>true</code>, this method
	 * declares the specified attribute to be a user-determined ID attribute .
	 * This affects the value of <code>Attr.isId</code> and the behavior of
	 * <code>Document.getElementById</code>, but does not change any schema that
	 * may be in use, in particular this does not affect the
	 * <code>Attr.schemaTypeInfo</code> of the specified <code>Attr</code> node.
	 * Use the value <code>false</code> for the parameter <code>isId</code> to
	 * undeclare an attribute for being a user-determined ID attribute. <br>
	 * To specify an attribute by local name and namespace URI, use the
	 * <code>setIdAttributeNS</code> method.
	 * 
	 * @param name
	 *            The name of the attribute.
	 * @param isId
	 *            Whether the attribute is a of type ID.
	 * @exception DOMException
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly. <br>
	 *                NOT_FOUND_ERR: Raised if the specified node is not an
	 *                attribute of this element.
	 * @since DOM Level 3
	 */
	public void setIdAttribute(String name, boolean isId) throws DOMException;

	/**
	 * If the parameter <code>isId</code> is <code>true</code>, this method
	 * declares the specified attribute to be a user-determined ID attribute .
	 * This affects the value of <code>Attr.isId</code> and the behavior of
	 * <code>Document.getElementById</code>, but does not change any schema that
	 * may be in use, in particular this does not affect the
	 * <code>Attr.schemaTypeInfo</code> of the specified <code>Attr</code> node.
	 * Use the value <code>false</code> for the parameter <code>isId</code> to
	 * undeclare an attribute for being a user-determined ID attribute.
	 * 
	 * @param namespaceURI
	 *            The namespace URI of the attribute.
	 * @param localName
	 *            The local name of the attribute.
	 * @param isId
	 *            Whether the attribute is a of type ID.
	 * @exception DOMException
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly. <br>
	 *                NOT_FOUND_ERR: Raised if the specified node is not an
	 *                attribute of this element.
	 * @since DOM Level 3
	 */
	public void setIdAttributeNS(String namespaceURI, String localName,
			boolean isId) throws DOMException;

	/**
	 * If the parameter <code>isId</code> is <code>true</code>, this method
	 * declares the specified attribute to be a user-determined ID attribute .
	 * This affects the value of <code>Attr.isId</code> and the behavior of
	 * <code>Document.getElementById</code>, but does not change any schema that
	 * may be in use, in particular this does not affect the
	 * <code>Attr.schemaTypeInfo</code> of the specified <code>Attr</code> node.
	 * Use the value <code>false</code> for the parameter <code>isId</code> to
	 * undeclare an attribute for being a user-determined ID attribute.
	 * 
	 * @param idAttr
	 *            The attribute node.
	 * @param isId
	 *            Whether the attribute is a of type ID.
	 * @exception DOMException
	 *                NO_MODIFICATION_ALLOWED_ERR: Raised if this node is
	 *                readonly. <br>
	 *                NOT_FOUND_ERR: Raised if the specified node is not an
	 *                attribute of this element.
	 * @since DOM Level 3
	 */
	public void setIdAttributeNode(Attr idAttr, boolean isId)
			throws DOMException;

}
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.onesocialweb.gwt.model.GwtActivityDomReader;
import org.onesocialweb.gwt.model.GwtActivityDomWriter;
import org.onesocialweb.gwt.model.GwtRelationDomReader;
import org.onesocialweb.gwt.model.GwtRelationDomWriter;
import org.onesocialweb.gwt.model.GwtVCard4DomReader;
import org.onesocialweb.gwt.model.GwtVCard4DomWriter;
import org.onesocialweb.gwt.model.vcard4.GwtProfileFactory;
import org.onesocialweb.gwt.service.OswService;
import org.onesocialweb.gwt.service.RequestCallback;
import org.onesocialweb.gwt.service.Roster;
import org.onesocialweb.gwt.service.RosterItem;
import org.onesocialweb.gwt.service.Stream;
import org.onesocialweb.gwt.service.UpdateCallback;
import org.onesocialweb.gwt.service.UploadStatus;
import org.onesocialweb.gwt.service.RosterItem.Presence;
import org.onesocialweb.gwt.xml.DocumentAdapter;
import org.onesocialweb.gwt.xml.ElementAdapter;
import org.onesocialweb.model.acl.AclFactory;
import org.onesocialweb.model.acl.DefaultAclFactory;
import org.onesocialweb.model.activity.ActivityEntry;
import org.onesocialweb.model.activity.ActivityFactory;
import org.onesocialweb.model.activity.DefaultActivityFactory;
import org.onesocialweb.model.atom.AtomFactory;
import org.onesocialweb.model.atom.DefaultAtomFactory;
import org.onesocialweb.model.relation.DefaultRelationFactory;
import org.onesocialweb.model.relation.Relation;
import org.onesocialweb.model.relation.RelationFactory;
import org.onesocialweb.model.vcard4.Profile;
import org.onesocialweb.model.vcard4.VCard4Factory;
import org.onesocialweb.xml.dom.ActivityDomReader;
import org.onesocialweb.xml.dom.ActivityDomWriter;
import org.onesocialweb.xml.dom.RelationDomReader;
import org.onesocialweb.xml.dom.RelationDomWriter;
import org.onesocialweb.xml.dom.VCard4DomReader;
import org.onesocialweb.xml.dom.VCard4DomWriter;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import com.allen_sauer.gwt.log.client.Log;
import com.calclab.emite.core.client.bosh.BoshSettings;
import com.calclab.emite.core.client.bosh.Connection;
import com.calclab.emite.core.client.packet.IPacket;
import com.calclab.emite.core.client.packet.Packet;
import com.calclab.emite.core.client.packet.gwt.GWTPacket;
import com.calclab.emite.core.client.xmpp.session.Session;
import com.calclab.emite.core.client.xmpp.session.Session.State;
import com.calclab.emite.core.client.xmpp.stanzas.IQ;
import com.calclab.emite.core.client.xmpp.stanzas.Message;
import com.calclab.emite.core.client.xmpp.stanzas.XmppURI;
import com.calclab.emite.core.client.xmpp.stanzas.Presence.Show;
import com.calclab.emite.im.client.presence.PresenceManager;
import com.calclab.emite.im.client.presence.PresenceManagerImpl;
import com.calclab.emite.im.client.roster.RosterImpl;
import com.calclab.suco.client.Suco;
import com.calclab.suco.client.events.Listener;
import com.google.gwt.xml.client.XMLParser;
/*
 *  Copyright 2010 Vodafone Group Services Ltd.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *    
 */
package org.onesocialweb.gwt.service.imp;




public class GwtOswService implements OswService {

	private static GwtOswService instance;

	private final Session session = Suco.get(Session.class);

	private final ActivityFactory activityFactory = new DefaultActivityFactory();

	private final AclFactory aclFactory = new DefaultAclFactory();

	private final AtomFactory atomFactory = new DefaultAtomFactory();

	private final VCard4Factory profileFactory = new GwtProfileFactory();

	private final RelationFactory relationFactory = new DefaultRelationFactory();

	private final Map<String, Object> cache = new HashMap<String, Object>();

	private final GwtInbox inbox = new GwtInbox();

	private final QueryCache queryCache = new QueryCache();

	private RequestCallback<?> loginCallback;

	private RequestCallback<?> logoutCallback;

	private Map<String, UpdateCallback<UploadStatus>> uploadCallbacks = new HashMap<String, UpdateCallback<UploadStatus>>();

	private String domain;

	private Roster roster;

	private PresenceManager presenceManager;

	public static GwtOswService getInstance() {
		if (instance == null) {
			instance = new GwtOswService();
		}
		return instance;
	}

	@Override
	public AclFactory getAclFactory() {
		return aclFactory;
	}

	@Override
	public ActivityFactory getActivityFactory() {
		return activityFactory;
	}

	@Override
	public AtomFactory getAtomFactory() {
		return atomFactory;
	}

	@Override
	public VCard4Factory getProfileFactory() {
		return profileFactory;
	}

	@Override
	public RelationFactory getRelationFactory() {
		return relationFactory;
	}

	@Override
	public void setup(String httpBase, String hostname, String domain) {
		Suco.get(Connection.class).setSettings(
				new BoshSettings(httpBase, hostname));
		session.onStateChanged(new StateChangedListener());
		session.onMessage(new MessageListener());
		this.domain = domain;
	}

	@Override
	public void login(String username, String password,
			RequestCallback<Object> callback) {
		if (logoutCallback == null && loginCallback == null) {
			loginCallback = callback;
			RosterImpl rosterImpl = new RosterImpl(session);
			roster = new GwtRoster(rosterImpl);
			presenceManager = new PresenceManagerImpl(session, rosterImpl);
			session.login(XmppURI.uri(username + "@" + domain), password);
		}
	}

	@Override
	public void logout(RequestCallback<Object> callback) {
		if (logoutCallback == null && loginCallback == null) {
			logoutCallback = callback;
			session.logout();
		}
	}

	@Override
	public boolean isLoggedIn() {
		return session.isLoggedIn();
	}

	@Override
	public Stream<ActivityEntry> getInbox() {
		return inbox;
	}

	@Override
	public void getProfile(final String jid,
			final RequestCallback<Profile> callback) {
		// Hit the cache
		if (cache.containsKey("profile_" + jid)) {
			Object value = cache.get("profile_" + jid);
			if (value != null && value instanceof Profile) {
				callback.onSuccess((Profile) value);
			} else {
				callback.onFailure();
			}
			return;
		}

		// Check if ongoing query
		if (queryCache.hasQuery("profile_" + jid)) {
			queryCache.addCallback("profile_" + jid, new QueryCallback() {

				@Override
				public void onFailure() {
					callback.onFailure();
				}

				@Override
				public void onResult(Object result) {
					if (result != null && result instanceof Profile) {
						callback.onSuccess((Profile) result);
					} else {
						callback.onFailure();
					}
				}
			});
			return;
		}

		// No cache, new query
		queryCache.addQuery("profile_" + jid);
		IQ iq = new IQ(IQ.Type.get);
		iq.addQuery("http://onesocialweb.org/spec/1.0/vcard4#query");
		iq.setTo(XmppURI.jid(jid));
		session.sendIQ("osw", iq, new Listener<IPacket>() {

			public void onEvent(IPacket packet) {
				// Packet should not be an error
				if (IQ.isSuccess(packet)) {
					// Parse the packet and check if a proper query request
					final IPacket query = packet.getFirstChild("query");
					Profile profile = null;
					if (query != null && query.getChildrenCount() > 0) {
						// Parse the packet and return the profile
						IPacket item = query.getFirstChild("vcard");
						if (item instanceof GWTPacket) {
							GWTPacket i_packet = (GWTPacket) item;
							Element element = new ElementAdapter(i_packet