| Method from com.sun.xml.internal.messaging.saaj.soap.impl.ElementImpl Detail: |
|---|
 public SOAPElement addAttribute(Name name,
String value) throws SOAPException {
addAttributeBare(name, value);
if (!"".equals(name.getURI())) {
ensureNamespaceIsDeclared(name.getPrefix(), name.getURI());
}
return this;
}
|
public SOAPElement addAttribute(QName qname,
String value) throws SOAPException {
addAttributeBare(qname, value);
if (!"".equals(qname.getNamespaceURI())) {
ensureNamespaceIsDeclared(qname.getPrefix(), qname.getNamespaceURI());
}
return this;
} |
protected SOAPElement addCDATA(String text) throws SOAPException {
org.w3c.dom.Text cdata =
(org.w3c.dom.Text) getOwnerDocument().createCDATASection(text);
addNode(cdata);
return this;
} |
public SOAPElement addChildElement(Name name) throws SOAPException {
return addElement(name);
} |
public SOAPElement addChildElement(QName qname) throws SOAPException {
return addElement(qname);
} |
public SOAPElement addChildElement(String localName) throws SOAPException {
return (SOAPElement) addChildElement(
NameImpl.createFromUnqualifiedName(localName));
} |
public SOAPElement addChildElement(SOAPElement element) throws SOAPException {
// check if Element falls in SOAP 1.1 or 1.2 namespace.
String elementURI = element.getElementName().getURI();
String localName = element.getLocalName();
if ((SOAPConstants.URI_NS_SOAP_ENVELOPE).equals(elementURI)
|| (SOAPConstants.URI_NS_SOAP_1_2_ENVELOPE).equals(elementURI)) {
if ("Envelope".equalsIgnoreCase(localName) ||
"Header".equalsIgnoreCase(localName) || "Body".equalsIgnoreCase(localName)) {
log.severe("SAAJ0103.impl.cannot.add.fragements");
throw new SOAPExceptionImpl(
"Cannot add fragments which contain elements "
+ "which are in the SOAP namespace");
}
if ("Fault".equalsIgnoreCase(localName) && !"Body".equalsIgnoreCase(this.getLocalName())) {
log.severe("SAAJ0154.impl.adding.fault.to.nonbody");
throw new SOAPExceptionImpl("Cannot add a SOAPFault as a child of " + this.getLocalName());
}
if ("Detail".equalsIgnoreCase(localName) && !"Fault".equalsIgnoreCase(this.getLocalName())) {
log.severe("SAAJ0155.impl.adding.detail.nonfault");
throw new SOAPExceptionImpl("Cannot add a Detail as a child of " + this.getLocalName());
}
if ("Fault".equalsIgnoreCase(localName)) {
// if body is not empty throw an exception
if (!elementURI.equals(this.getElementName().getURI())) {
log.severe("SAAJ0158.impl.version.mismatch.fault");
throw new SOAPExceptionImpl("SOAP Version mismatch encountered when trying to add SOAPFault to SOAPBody");
}
Iterator it = this.getChildElements();
if (it.hasNext()) {
log.severe("SAAJ0156.impl.adding.fault.error");
throw new SOAPExceptionImpl("Cannot add SOAPFault as a child of a non-Empty SOAPBody");
}
}
}
// preserve the encodingStyle attr as it may get lost in the import
String encodingStyle = element.getEncodingStyle();
ElementImpl importedElement = (ElementImpl) importElement(element);
addNode(importedElement);
if (encodingStyle != null)
importedElement.setEncodingStyle(encodingStyle);
return convertToSoapElement(importedElement);
} |
public SOAPElement addChildElement(String localName,
String prefix) throws SOAPException {
String uri = getNamespaceURI(prefix);
if (uri == null) {
log.log(
Level.SEVERE,
"SAAJ0101.impl.parent.of.body.elem.mustbe.body",
new String[] { prefix });
throw new SOAPExceptionImpl(
"Unable to locate namespace for prefix " + prefix);
}
return addChildElement(localName, prefix, uri);
} |
public SOAPElement addChildElement(String localName,
String prefix,
String uri) throws SOAPException {
SOAPElement newElement = createElement(NameImpl.create(localName, prefix, uri));
addNode(newElement);
return convertToSoapElement(newElement);
} |
protected SOAPElement addElement(Name name) throws SOAPException {
SOAPElement newElement = createElement(name);
addNode(newElement);
return circumventBug5034339(newElement);
} |
protected SOAPElement addElement(QName name) throws SOAPException {
SOAPElement newElement = createElement(name);
addNode(newElement);
return circumventBug5034339(newElement);
} |
public SOAPElement addNamespaceDeclaration(String prefix,
String uri) throws SOAPException {
if (prefix.length() > 0) {
setAttributeNS(NamespaceContext.XMLNS_URI, "xmlns:" + prefix, uri);
} else {
setAttributeNS(NamespaceContext.XMLNS_URI, "xmlns", uri);
}
tryToFindEncodingStyleAttributeName();
return this;
} |
protected void addNode(Node newElement) throws SOAPException {
insertBefore(newElement, null);
if (getOwnerDocument() instanceof DocumentFragment)
return;
if (newElement instanceof ElementImpl) {
ElementImpl element = (ElementImpl) newElement;
QName elementName = element.getElementQName();
if (!"".equals(elementName.getNamespaceURI())) {
element.ensureNamespaceIsDeclared(
elementName.getPrefix(), elementName.getNamespaceURI());
}
}
} |
protected SOAPElement addText(String text) throws SOAPException {
org.w3c.dom.Text textNode =
(org.w3c.dom.Text) getOwnerDocument().createTextNode(text);
addNode(textNode);
return this;
} |
public SOAPElement addTextNode(String text) throws SOAPException {
if (text.startsWith(CDATAImpl.cdataUC)
|| text.startsWith(CDATAImpl.cdataLC))
return addCDATA(
text.substring(CDATAImpl.cdataUC.length(), text.length() - 3));
return addText(text);
} |
protected SOAPElement circumventBug5034339(SOAPElement element) {
Name elementName = element.getElementName();
if (!isNamespaceQualified(elementName)) {
String prefix = elementName.getPrefix();
String defaultNamespace = getNamespaceURI(prefix);
if (defaultNamespace != null) {
Name newElementName =
NameImpl.create(
elementName.getLocalName(),
elementName.getPrefix(),
defaultNamespace);
SOAPElement newElement = createElement(newElementName);
replaceChild(newElement, element);
return newElement;
}
}
return element;
} |
protected SOAPElement convertToSoapElement(Element element) {
if (element instanceof SOAPElement) {
return (SOAPElement) element;
} else {
return replaceElementWithSOAPElement(
element,
(ElementImpl) createElement(NameImpl.copyElementName(element)));
}
} |
protected SOAPElement createElement(Name name) {
if (isNamespaceQualified(name)) {
return (SOAPElement)
getOwnerDocument().createElementNS(
name.getURI(),
name.getQualifiedName());
} else {
return (SOAPElement)
getOwnerDocument().createElement(name.getQualifiedName());
}
} |
protected SOAPElement createElement(QName name) {
if (isNamespaceQualified(name)) {
return (SOAPElement)
getOwnerDocument().createElementNS(
name.getNamespaceURI(),
getQualifiedName(name));
} else {
return (SOAPElement)
getOwnerDocument().createElement(getQualifiedName(name));
}
} |
public QName createQName(String localName,
String prefix) throws SOAPException {
String uri = getNamespaceURI(prefix);
if (uri == null) {
log.log(Level.SEVERE, "SAAJ0102.impl.cannot.locate.ns",
new Object[] {prefix});
throw new SOAPException("Unable to locate namespace for prefix "
+ prefix);
}
return new QName(uri, localName, prefix);
} |
public void detachNode() {
Node parent = getParentNode();
if (parent != null) {
parent.removeChild(this);
}
encodingStyleAttribute.clearName();
tryToFindEncodingStyleAttributeName();
} |
protected Iterator doGetNamespacePrefixes(boolean deep) {
return new Iterator() {
String next = null;
String last = null;
NamespaceContextIterator eachNamespace =
getNamespaceContextNodes(deep);
void findNext() {
while (next == null && eachNamespace.hasNext()) {
String attributeKey =
eachNamespace.nextNamespaceAttr().getNodeName();
if (attributeKey.startsWith("xmlns:")) {
next = attributeKey.substring("xmlns:".length());
}
}
}
public boolean hasNext() {
findNext();
return next != null;
}
public Object next() {
findNext();
if (next == null) {
throw new NoSuchElementException();
}
last = next;
next = null;
return last;
}
public void remove() {
if (last == null) {
throw new IllegalStateException();
}
eachNamespace.remove();
next = null;
last = null;
}
};
} |
public void ensureNamespaceIsDeclared(String prefix,
String uri) {
String alreadyDeclaredUri = getNamespaceURI(prefix);
if (alreadyDeclaredUri == null || !alreadyDeclaredUri.equals(uri)) {
try {
addNamespaceDeclaration(prefix, uri);
} catch (SOAPException e) { /*ignore*/
}
}
} |
protected SOAPElement findChild(NameImpl name) {
Iterator eachChild = getChildElementNodes();
while (eachChild.hasNext()) {
SOAPElement child = (SOAPElement) eachChild.next();
if (child.getElementName().equals(name)) {
return child;
}
}
return null;
} |
protected void findEncodingStyleAttributeName() throws SOAPException {
String soapNamespace = getSOAPNamespace();
if (soapNamespace != null) {
String soapNamespacePrefix = getNamespacePrefix(soapNamespace);
if (soapNamespacePrefix != null) {
setEncodingStyleNamespace(soapNamespace, soapNamespacePrefix);
}
}
} |
public Iterator getAllAttributes() {
Iterator i = getAllAttributesFrom(this);
ArrayList list = new ArrayList();
while (i.hasNext()) {
Name name = (Name) i.next();
if (!"xmlns".equalsIgnoreCase(name.getPrefix()))
list.add(name);
}
return list.iterator();
} |
public Iterator getAllAttributesAsQNames() {
Iterator i = getAllAttributesFrom(this);
ArrayList list = new ArrayList();
while (i.hasNext()) {
Name name = (Name) i.next();
if (!"xmlns".equalsIgnoreCase(name.getPrefix())) {
list.add(NameImpl.convertToQName(name));
}
}
return list.iterator();
} |
protected static Iterator getAllAttributesFrom(Element element) {
final NamedNodeMap attributes = element.getAttributes();
return new Iterator() {
int attributesLength = attributes.getLength();
int attributeIndex = 0;
String currentName;
public boolean hasNext() {
return attributeIndex < attributesLength;
}
public Object next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
Node current = attributes.item(attributeIndex++);
currentName = current.getNodeName();
String prefix = NameImpl.getPrefixFromTagName(currentName);
if (prefix.length() == 0) {
return NameImpl.createFromUnqualifiedName(currentName);
} else {
Name attributeName =
NameImpl.createFromQualifiedName(
currentName,
current.getNamespaceURI());
return attributeName;
}
}
public void remove() {
if (currentName == null) {
throw new IllegalStateException();
}
attributes.removeNamedItem(currentName);
}
};
} |
public String getAttributeValue(Name name) {
return getAttributeValueFrom(this, name);
} |
public String getAttributeValue(QName qname) {
return getAttributeValueFrom(
this,
qname.getNamespaceURI(),
qname.getLocalPart(),
qname.getPrefix(),
getQualifiedName(qname));
} |
protected static String getAttributeValueFrom(Element element,
Name name) {
return getAttributeValueFrom(
element,
name.getURI(),
name.getLocalName(),
name.getPrefix(),
name.getQualifiedName());
} |
protected Iterator getChildElementNodes() {
return new Iterator() {
Iterator eachNode = getChildElements();
Node next = null;
Node last = null;
public boolean hasNext() {
if (next == null) {
while (eachNode.hasNext()) {
Node node = (Node) eachNode.next();
if (node instanceof SOAPElement) {
next = node;
break;
}
}
}
return next != null;
}
public Object next() {
if (hasNext()) {
last = next;
next = null;
return last;
}
throw new NoSuchElementException();
}
public void remove() {
if (last == null) {
throw new IllegalStateException();
}
Node target = last;
last = null;
removeChild(target);
}
};
} |
public Iterator getChildElements() {
return getChildElementsFrom(this);
} |
public Iterator getChildElements(Name name) {
return getChildElements(name.getURI(), name.getLocalName());
} |
public Iterator getChildElements(QName qname) {
return getChildElements(qname.getNamespaceURI(), qname.getLocalPart());
} |
protected static Iterator getChildElementsFrom(Element element) {
return new Iterator() {
Node next = element.getFirstChild();
Node nextNext = null;
Node last = null;
public boolean hasNext() {
if (next != null) {
return true;
}
if (next == null && nextNext != null) {
next = nextNext;
}
return next != null;
}
public Object next() {
if (hasNext()) {
last = next;
next = null;
if ((element instanceof ElementImpl)
&& (last instanceof Element)) {
last =
((ElementImpl) element).convertToSoapElement(
(Element) last);
}
nextNext = last.getNextSibling();
return last;
}
throw new NoSuchElementException();
}
public void remove() {
if (last == null) {
throw new IllegalStateException();
}
Node target = last;
last = null;
element.removeChild(target);
}
};
} |
public Name getElementName() {
return NameImpl.convertToName(elementQName);
} |
public QName getElementQName() {
return elementQName;
} |
public String getEncodingStyle() {
String encodingStyle = encodingStyleAttribute.getValue();
if (encodingStyle != null)
return encodingStyle;
String soapNamespace = getSOAPNamespace();
if (soapNamespace != null) {
Attr attr = getAttributeNodeNS(soapNamespace, "encodingStyle");
if (attr != null) {
encodingStyle = attr.getValue();
try {
setEncodingStyle(encodingStyle);
} catch (SOAPException se) {
// has to be ignored
}
return encodingStyle;
}
}
return null;
} |
public static String getLocalPart(String qualifiedName) {
if (qualifiedName == null) {
// Log
throw new IllegalArgumentException("Cannot get local name for a \"null\" qualified name");
}
int index = qualifiedName.indexOf(':");
if (index < 0)
return qualifiedName;
else
return qualifiedName.substring(index + 1);
} |
protected Attr getNamespaceAttr(String prefix) {
NamespaceContextIterator eachNamespace = getNamespaceContextNodes();
if (!"".equals(prefix))
prefix = ":"+prefix;
while (eachNamespace.hasNext()) {
org.w3c.dom.Attr namespaceDecl = eachNamespace.nextNamespaceAttr();
if (!"".equals(prefix)) {
if (namespaceDecl.getNodeName().endsWith(prefix))
return namespaceDecl;
} else {
if (namespaceDecl.getNodeName().equals("xmlns"))
return namespaceDecl;
}
}
return null;
} |
protected static Attr getNamespaceAttrFrom(Element element,
String prefix) {
NamespaceContextIterator eachNamespace =
new NamespaceContextIterator(element);
while (eachNamespace.hasNext()) {
org.w3c.dom.Attr namespaceDecl = eachNamespace.nextNamespaceAttr();
String declaredPrefix =
NameImpl.getLocalNameFromTagName(namespaceDecl.getNodeName());
if (declaredPrefix.equals(prefix)) {
return namespaceDecl;
}
}
return null;
} |
public NamespaceContextIterator getNamespaceContextNodes() {
return getNamespaceContextNodes(true);
} |
public NamespaceContextIterator getNamespaceContextNodes(boolean traverseStack) {
return new NamespaceContextIterator(this, traverseStack);
} |
public String getNamespacePrefix(String uri) {
NamespaceContextIterator eachNamespace = getNamespaceContextNodes();
while (eachNamespace.hasNext()) {
org.w3c.dom.Attr namespaceDecl = eachNamespace.nextNamespaceAttr();
if (namespaceDecl.getNodeValue().equals(uri)) {
String candidatePrefix = namespaceDecl.getLocalName();
if ("xmlns".equals(candidatePrefix))
return "";
else
return candidatePrefix;
}
}
// Find if any of the ancestors' name has this uri
org.w3c.dom.Node currentAncestor = this;
while (currentAncestor != null &&
!(currentAncestor instanceof Document)) {
if (uri.equals(currentAncestor.getNamespaceURI()))
return currentAncestor.getPrefix();
currentAncestor = currentAncestor.getParentNode();
}
return null;
} |
public Iterator getNamespacePrefixes() {
return doGetNamespacePrefixes(false);
} |
public String getNamespaceURI(String prefix) {
if ("xmlns".equals(prefix)) {
return NamespaceContext.XMLNS_URI;
}
if("xml".equals(prefix)) {
return NamespaceContext.XML_URI;
}
if ("".equals(prefix)) {
org.w3c.dom.Node currentAncestor = this;
while (currentAncestor != null &&
!(currentAncestor instanceof Document)) {
if (currentAncestor instanceof ElementImpl) {
QName name = ((ElementImpl) currentAncestor).getElementQName();
/*
if (prefix.equals(name.getPrefix())) {
String uri = name.getNamespaceURI();
if ("".equals(uri)) {
return null;
}
else {
return uri;
}
}*/
if (((Element) currentAncestor).hasAttributeNS(
NamespaceContext.XMLNS_URI, "xmlns")) {
String uri =
((Element) currentAncestor).getAttributeNS(
NamespaceContext.XMLNS_URI, "xmlns");
if ("".equals(uri))
return null;
else {
return uri;
}
}
}
currentAncestor = currentAncestor.getParentNode();
}
} else if (prefix != null) {
// Find if there's an ancester whose name contains this prefix
org.w3c.dom.Node currentAncestor = this;
while (currentAncestor != null &&
!(currentAncestor instanceof Document)) {
/*
if (prefix.equals(currentAncestor.getPrefix())) {
String uri = currentAncestor.getNamespaceURI();
// this is because the javadoc says getNamespaceURI() is not a computed value
// and URI for a non-empty prefix cannot be null
if (uri != null)
return uri;
}*/
if (((Element) currentAncestor).hasAttributeNS(
NamespaceContext.XMLNS_URI, prefix)) {
return ((Element) currentAncestor).getAttributeNS(
NamespaceContext.XMLNS_URI, prefix);
}
currentAncestor = currentAncestor.getParentNode();
}
}
return null;
} |
public Document getOwnerDocument() {
SOAPDocument ownerSOAPDocument =
((SOAPDocument) super.getOwnerDocument());
if (ownerSOAPDocument == null) {
return null;
}
return ownerSOAPDocument.getDocument();
} |
public SOAPElement getParentElement() {
Node parentNode = getParentNode();
if (parentNode instanceof SOAPDocument) {
return null;
}
return (SOAPElement) parentNode;
} |
public static String getPrefix(String qualifiedName) {
if (qualifiedName == null) {
// Log
throw new IllegalArgumentException("Cannot get prefix for a \"null\" qualified name");
}
int index = qualifiedName.indexOf(':");
if (index < 0)
return "";
else
return qualifiedName.substring(0, index);
} |
public static String getQualifiedName(QName name) {
String prefix = name.getPrefix();
String localName = name.getLocalPart();
String qualifiedName = null;
if (prefix != null && prefix.length() > 0) {
qualifiedName = prefix + ":" + localName;
} else {
qualifiedName = localName;
}
return qualifiedName;
} |
protected String getSOAPNamespace() {
String soapNamespace = null;
SOAPElement antecedent = this;
while (antecedent != null) {
Name antecedentName = antecedent.getElementName();
String antecedentNamespace = antecedentName.getURI();
if (NameImpl.SOAP11_NAMESPACE.equals(antecedentNamespace)
|| NameImpl.SOAP12_NAMESPACE.equals(antecedentNamespace)) {
soapNamespace = antecedentNamespace;
break;
}
antecedent = antecedent.getParentElement();
}
return soapNamespace;
} |
public String getValue() {
javax.xml.soap.Node valueNode = getValueNode();
return valueNode == null ? null : valueNode.getValue();
} |
protected Node getValueNode() {
Iterator i = getChildElements();
while (i.hasNext()) {
javax.xml.soap.Node n = (javax.xml.soap.Node) i.next();
if (n.getNodeType() == org.w3c.dom.Node.TEXT_NODE ||
n.getNodeType() == org.w3c.dom.Node.CDATA_SECTION_NODE) {
// TODO: Hack to fix text node split into multiple lines.
normalize();
// Should remove the normalization step when this gets fixed in
// DOM/Xerces.
return (javax.xml.soap.Node) n;
}
}
return null;
} |
protected Node getValueNodeStrict() {
Node node = getFirstChild();
if (node != null) {
if (node.getNextSibling() == null
&& node.getNodeType() == org.w3c.dom.Node.TEXT_NODE) {
return node;
} else {
log.severe("SAAJ0107.impl.elem.child.not.single.text");
throw new IllegalStateException();
}
}
return null;
} |
public Iterator getVisibleNamespacePrefixes() {
return doGetNamespacePrefixes(true);
} |
protected Element importElement(Element element) {
Document document = getOwnerDocument();
Document oldDocument = element.getOwnerDocument();
if (!oldDocument.equals(document)) {
return (Element) document.importNode(element, true);
} else {
return element;
}
} |
protected boolean isNamespaceQualified(Name name) {
return !"".equals(name.getURI());
} |
protected boolean isNamespaceQualified(QName name) {
return !"".equals(name.getNamespaceURI());
} |
public void recycleNode() {
detachNode();
// TBD
// - add this to the factory so subsequent
// creations can reuse this object.
} |
public boolean removeAttribute(Name name) {
return removeAttribute(name.getURI(), name.getLocalName());
} |
public boolean removeAttribute(QName name) {
return removeAttribute(name.getNamespaceURI(), name.getLocalPart());
} |
public void removeContents() {
Node currentChild = getFirstChild();
while (currentChild != null) {
Node temp = currentChild.getNextSibling();
if (currentChild instanceof javax.xml.soap.Node) {
((javax.xml.soap.Node) currentChild).detachNode();
} else {
Node parent = currentChild.getParentNode();
if (parent != null) {
parent.removeChild(currentChild);
}
}
currentChild = temp;
}
} |
public boolean removeNamespaceDeclaration(String prefix) {
org.w3c.dom.Attr declaration = getNamespaceAttr(prefix);
if (declaration == null) {
return false;
}
try {
removeAttributeNode(declaration);
} catch (DOMException de) {
// ignore
}
return true;
} |
protected static SOAPElement replaceElementWithSOAPElement(Element element,
ElementImpl copy) {
Iterator eachAttribute = getAllAttributesFrom(element);
while (eachAttribute.hasNext()) {
Name name = (Name) eachAttribute.next();
copy.addAttributeBare(name, getAttributeValueFrom(element, name));
}
Iterator eachChild = getChildElementsFrom(element);
while (eachChild.hasNext()) {
Node nextChild = (Node) eachChild.next();
copy.insertBefore(nextChild, null);
}
Node parent = element.getParentNode();
if (parent != null) {
parent.replaceChild(copy, element);
} // XXX else throw an exception?
return copy;
} |
public void setAttributeNS(String namespaceURI,
String qualifiedName,
String value) {
int index = qualifiedName.indexOf(':");
String prefix, localName;
if (index < 0) {
prefix = null;
localName = qualifiedName;
}
else {
prefix = qualifiedName.substring(0, index);
localName = qualifiedName.substring(index + 1);
}
super.setAttributeNS(namespaceURI,qualifiedName,value);
//String tmpLocalName = this.getLocalName();
String tmpURI = this.getNamespaceURI();
boolean isIDNS = false;
if( tmpURI != null && (tmpURI.equals(DSIG_NS) || tmpURI.equals(XENC_NS))){
isIDNS = true;
}
//No need to check for Signature/encryption element
//just check for namespace.
if(localName.equals("Id")){
if(namespaceURI == null || namespaceURI.equals("")){
setIdAttribute(localName,true);
}else if(isIDNS || WSU_NS.equals(namespaceURI)){
setIdAttributeNS(namespaceURI,localName,true);
}
}
} |
public SOAPElement setElementQName(QName newName) throws SOAPException {
ElementImpl copy =
new ElementImpl((SOAPDocumentImpl) getOwnerDocument(), newName);
return replaceElementWithSOAPElement(this,copy);
} |
public void setEncodingStyle(String encodingStyle) throws SOAPException {
if (!"".equals(encodingStyle)) {
try {
JaxmURI uri = new JaxmURI(encodingStyle);
} catch (JaxmURI.MalformedURIException m) {
log.log(
Level.SEVERE,
"SAAJ0105.impl.encoding.style.mustbe.valid.URI",
new String[] { encodingStyle });
throw new IllegalArgumentException(
"Encoding style (" + encodingStyle + ") should be a valid URI");
}
}
encodingStyleAttribute.setValue(encodingStyle);
tryToFindEncodingStyleAttributeName();
} |
protected void setEncodingStyleNamespace(String soapNamespace,
String soapNamespacePrefix) throws SOAPException {
Name encodingStyleAttributeName =
NameImpl.create(
"encodingStyle",
soapNamespacePrefix,
soapNamespace);
encodingStyleAttribute.setName(encodingStyleAttributeName);
} |
public void setParentElement(SOAPElement element) throws SOAPException {
if (element == null) {
log.severe("SAAJ0106.impl.no.null.to.parent.elem");
throw new SOAPException("Cannot pass NULL to setParentElement");
}
element.addChildElement(this);
findEncodingStyleAttributeName();
} |
public void setValue(String value) {
Node valueNode = getValueNodeStrict();
if (valueNode != null) {
valueNode.setNodeValue(value);
} else {
try {
addTextNode(value);
} catch (SOAPException e) {
throw new RuntimeException(e.getMessage());
}
}
} |
public void tryToFindEncodingStyleAttributeName() {
try {
findEncodingStyleAttributeName();
} catch (SOAPException e) { /*okay to fail*/
}
} |
com.sun.org.apache.xerces.internal.dom.NodeImpl
Save This Page