Use of instanceof pattern match in XmlElement

[netconf.git] / netconf / netconf-api / src / main / java / org / opendaylight / netconf / api / xml / XmlElement.java

diff --git a/netconf/netconf-api/src/main/java/org/opendaylight/netconf/api/xml/XmlElement.java b/netconf/netconf-api/src/main/java/org/opendaylight/netconf/api/xml/XmlElement.java
index d19ce378b8016a060b9b489483f27c13e2d8e0c8..caba82a5157e41e98a20bd8bbf34acded64fe8ad 100644 (file)
--- a/netconf/netconf-api/src/main/java/org/opendaylight/netconf/api/xml/XmlElement.java
+++ b/netconf/netconf-api/src/main/java/org/opendaylight/netconf/api/xml/XmlElement.java
@@ -21,6 +21,8 @@ import java.util.Optional;
 import javax.xml.XMLConstants;
 import org.opendaylight.netconf.api.DocumentedException;
 import org.opendaylight.yangtools.yang.common.ErrorSeverity;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.w3c.dom.Attr;
@@ -86,9 +88,7 @@ public final class XmlElement {
                 } else {
                     if (!attribKey.startsWith(XMLConstants.XMLNS_ATTRIBUTE + ":")) {
                         throw new DocumentedException("Attribute doesn't start with :",
-                                DocumentedException.ErrorType.APPLICATION,
-                                DocumentedException.ErrorTag.INVALID_VALUE,
-                                ErrorSeverity.ERROR);
+                                ErrorType.APPLICATION, ErrorTag.INVALID_VALUE, ErrorSeverity.ERROR);
                     }
                     prefix = attribKey.substring(XMLConstants.XMLNS_ATTRIBUTE.length() + 1);
                 }
@@ -109,35 +109,27 @@ public final class XmlElement {
 
     public void checkName(final String expectedName) throws UnexpectedElementException {
         if (!getName().equals(expectedName)) {
-            throw new UnexpectedElementException(String.format("Expected %s xml element but was %s", expectedName,
-                    getName()),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.OPERATION_FAILED,
-                    ErrorSeverity.ERROR);
+            throw new UnexpectedElementException(
+                    String.format("Expected %s xml element but was %s", expectedName, getName()),
+                    ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED, ErrorSeverity.ERROR);
         }
     }
 
     public void checkNamespaceAttribute(final String expectedNamespace)
             throws UnexpectedNamespaceException, MissingNameSpaceException {
         if (!getNamespaceAttribute().equals(expectedNamespace)) {
-            throw new UnexpectedNamespaceException(String.format("Unexpected namespace %s should be %s",
-                    getNamespaceAttribute(),
-                    expectedNamespace),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.OPERATION_FAILED,
-                    ErrorSeverity.ERROR);
+            throw new UnexpectedNamespaceException(
+                    String.format("Unexpected namespace %s should be %s", getNamespaceAttribute(), expectedNamespace),
+                    ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED, ErrorSeverity.ERROR);
         }
     }
 
     public void checkNamespace(final String expectedNamespace)
             throws UnexpectedNamespaceException, MissingNameSpaceException {
         if (!getNamespace().equals(expectedNamespace)) {
-            throw new UnexpectedNamespaceException(String.format("Unexpected namespace %s should be %s",
-                    getNamespace(),
-                    expectedNamespace),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.OPERATION_FAILED,
-                    ErrorSeverity.ERROR);
+            throw new UnexpectedNamespaceException(
+                    String.format("Unexpected namespace %s should be %s", getNamespace(), expectedNamespace),
+                    ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED, ErrorSeverity.ERROR);
         }
     }
 
@@ -162,7 +154,7 @@ public final class XmlElement {
     }
 
     public void appendChild(final Element toAppend) {
-        this.element.appendChild(toAppend);
+        element.appendChild(toAppend);
     }
 
     public Element getDomElement() {
@@ -189,12 +181,8 @@ public final class XmlElement {
         NodeList childNodes = element.getChildNodes();
         final List<XmlElement> result = new ArrayList<>();
         for (int i = 0; i < childNodes.getLength(); i++) {
-            Node item = childNodes.item(i);
-            if (!(item instanceof Element)) {
-                continue;
-            }
-            if (strat.accept((Element) item)) {
-                result.add(new XmlElement((Element) item));
+            if (childNodes.item(i) instanceof Element elem && strat.accept(elem)) {
+                result.add(new XmlElement(elem));
             }
         }
 
@@ -298,9 +286,7 @@ public final class XmlElement {
         if (children.size() != 1) {
             throw new DocumentedException(String.format("One element %s:%s expected in %s but was %s", namespace,
                     childName, toString(), children.size()),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.INVALID_VALUE,
-                    ErrorSeverity.ERROR);
+                    ErrorType.APPLICATION, ErrorTag.INVALID_VALUE, ErrorSeverity.ERROR);
         }
 
         return children.get(0);
@@ -310,9 +296,7 @@ public final class XmlElement {
         List<XmlElement> nameElements = getChildElements(childName);
         if (nameElements.size() != 1) {
             throw new DocumentedException("One element " + childName + " expected in " + toString(),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.INVALID_VALUE,
-                    ErrorSeverity.ERROR);
+                    ErrorType.APPLICATION, ErrorTag.INVALID_VALUE, ErrorSeverity.ERROR);
         }
         return nameElements.get(0);
     }
@@ -320,11 +304,9 @@ public final class XmlElement {
     public XmlElement getOnlyChildElement() throws DocumentedException {
         List<XmlElement> children = getChildElements();
         if (children.size() != 1) {
-            throw new DocumentedException(String.format("One element expected in %s but was %s", toString(),
-                    children.size()),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.INVALID_VALUE,
-                    ErrorSeverity.ERROR);
+            throw new DocumentedException(
+                    String.format("One element expected in %s but was %s", toString(), children.size()),
+                    ErrorType.APPLICATION, ErrorTag.INVALID_VALUE, ErrorSeverity.ERROR);
         }
         return children.get(0);
     }
@@ -335,25 +317,19 @@ public final class XmlElement {
             return DEFAULT_NAMESPACE_PREFIX;
         }
         for (int i = 0; i < childNodes.getLength(); i++) {
-            Node textChild = childNodes.item(i);
-            if (textChild instanceof Text) {
-                String content = textChild.getTextContent();
-                return content.trim();
+            if (childNodes.item(i) instanceof Text textChild) {
+                return textChild.getTextContent().trim();
             }
         }
         throw new DocumentedException(getName() + " should contain text.",
-                DocumentedException.ErrorType.APPLICATION,
-                DocumentedException.ErrorTag.INVALID_VALUE,
-                ErrorSeverity.ERROR
-        );
+                ErrorType.APPLICATION, ErrorTag.INVALID_VALUE, ErrorSeverity.ERROR);
     }
 
     public Optional<String> getOnlyTextContentOptionally() {
         // only return text content if this node has exactly one Text child node
         if (element.getChildNodes().getLength() == 1) {
-            Node item = element.getChildNodes().item(0);
-            if (item instanceof Text) {
-                return Optional.of(((Text) item).getWholeText());
+            if (element.getChildNodes().item(0) instanceof Text textChild) {
+                return Optional.of(textChild.getWholeText());
             }
         }
         return Optional.empty();
@@ -362,11 +338,8 @@ public final class XmlElement {
     public String getNamespaceAttribute() throws MissingNameSpaceException {
         String attribute = element.getAttribute(XMLConstants.XMLNS_ATTRIBUTE);
         if (attribute.isEmpty() || attribute.equals(DEFAULT_NAMESPACE_PREFIX)) {
-            throw new MissingNameSpaceException(String.format("Element %s must specify namespace",
-                    toString()),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.OPERATION_FAILED,
-                    ErrorSeverity.ERROR);
+            throw new MissingNameSpaceException(String.format("Element %s must specify namespace", toString()),
+                    ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED, ErrorSeverity.ERROR);
         }
         return attribute;
     }
@@ -392,9 +365,7 @@ public final class XmlElement {
         Optional<String> namespaceURI = getNamespaceOptionally();
         if (namespaceURI.isEmpty()) {
             throw new MissingNameSpaceException(String.format("No namespace defined for %s", this),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.OPERATION_FAILED,
-                    ErrorSeverity.ERROR);
+                    ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED, ErrorSeverity.ERROR);
         }
         return namespaceURI.get();
     }
@@ -461,9 +432,7 @@ public final class XmlElement {
         }
         if (!childElements.isEmpty()) {
             throw new DocumentedException(String.format("Unrecognised elements %s in %s", childElements, this),
-                    DocumentedException.ErrorType.APPLICATION,
-                    DocumentedException.ErrorTag.INVALID_VALUE,
-                    ErrorSeverity.ERROR);
+                    ErrorType.APPLICATION, ErrorTag.INVALID_VALUE, ErrorSeverity.ERROR);
         }
     }