From: Robert Varga Date: Mon, 4 May 2015 12:05:13 +0000 (+0000) Subject: Merge "Removed unused dependency." X-Git-Tag: release/beryllium~511 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=7fedd460044be8d15547f65b713ecbeec0f74296;hp=96c94e819397c03fbb3c329431389d115af92700;p=yangtools.git Merge "Removed unused dependency." --- diff --git a/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/BenchmarkModel.java b/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/BenchmarkModel.java index e8cf728b45..3acdfb2525 100644 --- a/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/BenchmarkModel.java +++ b/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/BenchmarkModel.java @@ -1,3 +1,10 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ package org.opendaylight.yangtools.yang.data.impl.tree; import java.io.InputStream; @@ -10,7 +17,7 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl; /** - * @author Lukas Sedlak + * @author Lukas Sedlak <lsedlak@cisco.com> */ public class BenchmarkModel { diff --git a/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java b/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java index 4cf95a73ac..4e22bd15d8 100644 --- a/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java +++ b/benchmarks/src/main/java/org/opendaylight/yangtools/yang/data/impl/tree/InMemoryDataTreeBenchmark.java @@ -31,7 +31,7 @@ import org.openjdk.jmh.runner.options.OptionsBuilder; * * JMH is used for microbenchmarking. * - * @author Lukas Sedlak + * @author Lukas Sedlak <lsedlak@cisco.com> * * @see JMH */ diff --git a/code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.java b/code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.java index 66f3bc0424..15b818e43d 100644 --- a/code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.java +++ b/code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.java @@ -38,6 +38,7 @@ import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; +import org.opendaylight.yangtools.sal.binding.generator.impl.YangTemplate; import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil; import org.opendaylight.yangtools.binding.generator.util.BindingTypes; import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl; diff --git a/common/util/src/main/java/org/opendaylight/yangtools/util/ClassLoaderUtils.java b/common/util/src/main/java/org/opendaylight/yangtools/util/ClassLoaderUtils.java index 6f84ef81ff..44dfc4526e 100644 --- a/common/util/src/main/java/org/opendaylight/yangtools/util/ClassLoaderUtils.java +++ b/common/util/src/main/java/org/opendaylight/yangtools/util/ClassLoaderUtils.java @@ -12,7 +12,6 @@ import static com.google.common.base.Preconditions.checkNotNull; import com.google.common.base.Joiner; import com.google.common.base.Preconditions; import com.google.common.base.Supplier; - import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.ParameterizedType; @@ -20,7 +19,6 @@ import java.lang.reflect.Type; import java.util.Arrays; import java.util.List; import java.util.concurrent.Callable; - import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -104,16 +102,19 @@ public final class ClassLoaderUtils { if ("char[]".equals(name)) { return char[].class; } + return loadClass0(cls,name); + } + private static Class loadClass0(final ClassLoader cls, final String name) throws ClassNotFoundException { try { return cls.loadClass(name); - } catch (ClassNotFoundException e) { - String[] components = name.split("\\."); - String potentialOuter; - int length = components.length; - if (length > 2 && (potentialOuter = components[length - 2]) != null && Character.isUpperCase(potentialOuter.charAt(0))) { - String outerName = Joiner.on(".").join(Arrays.asList(components).subList(0, length - 1)); - String innerName = outerName + "$" + components[length-1]; + } catch (final ClassNotFoundException e) { + final String[] components = name.split("\\."); + + if (isInnerClass(components)) { + final int length = components.length; + final String outerName = Joiner.on(".").join(Arrays.asList(components).subList(0, length - 1)); + final String innerName = outerName + "$" + components[length-1]; return cls.loadClass(innerName); } else { throw e; @@ -121,6 +122,18 @@ public final class ClassLoaderUtils { } } + private static boolean isInnerClass(final String[] components) { + final int length = components.length; + if(length < 2) { + return false; + } + final String potentialOuter = components[length - 2]; + if(potentialOuter == null) { + return false; + } + return Character.isUpperCase(potentialOuter.charAt(0)); + } + public static Class loadClassWithTCCL(final String name) throws ClassNotFoundException { return loadClass(Thread.currentThread().getContextClassLoader(), name); } @@ -128,7 +141,7 @@ public final class ClassLoaderUtils { public static Class tryToLoadClassWithTCCL(final String fullyQualifiedName) { try { return loadClassWithTCCL(fullyQualifiedName); - } catch (ClassNotFoundException e) { + } catch (final ClassNotFoundException e) { LOG.debug("Failed to load class {}", fullyQualifiedName, e); return null; } @@ -156,7 +169,7 @@ public final class ClassLoaderUtils { Preconditions.checkNotNull(subclass); Preconditions.checkNotNull(genericType); - for (Type type : subclass.getGenericInterfaces()) { + for (final Type type : subclass.getGenericInterfaces()) { if (type instanceof ParameterizedType && genericType.equals(((ParameterizedType) type).getRawType())) { return (ParameterizedType) type; } diff --git a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/QName.java b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/QName.java index bfdfdadc80..9d8a5e8e43 100644 --- a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/QName.java +++ b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/QName.java @@ -109,7 +109,7 @@ public final class QName implements Immutable, Serializable, Comparable { throw new IllegalArgumentException("Parameter 'localName' must be a non-empty string."); } - for (char c : ILLEGAL_CHARACTERS) { + for (final char c : ILLEGAL_CHARACTERS) { if (localName.indexOf(c) != -1) { throw new IllegalArgumentException(String.format( "Parameter 'localName':'%s' contains illegal character '%s'", localName, c)); @@ -121,20 +121,20 @@ public final class QName implements Immutable, Serializable, Comparable { public static QName create(final String input) { Matcher matcher = QNAME_PATTERN_FULL.matcher(input); if (matcher.matches()) { - String namespace = matcher.group(1); - String revision = matcher.group(2); - String localName = matcher.group(3); + final String namespace = matcher.group(1); + final String revision = matcher.group(2); + final String localName = matcher.group(3); return create(namespace, revision, localName); } matcher = QNAME_PATTERN_NO_REVISION.matcher(input); if (matcher.matches()) { - URI namespace = URI.create(matcher.group(1)); - String localName = matcher.group(2); + final URI namespace = URI.create(matcher.group(1)); + final String localName = matcher.group(2); return new QName(namespace, localName); } matcher = QNAME_PATTERN_NO_NAMESPACE_NO_REVISION.matcher(input); if (matcher.matches()) { - String localName = matcher.group(1); + final String localName = matcher.group(1); return new QName((URI) null, localName); } throw new IllegalArgumentException("Invalid input:" + input); @@ -273,8 +273,7 @@ public final class QName implements Immutable, Serializable, Comparable { * revision is not according to format * YYYY-mm-dd. */ - public static QName create(final String namespace, final String revision, final String localName) - throws IllegalArgumentException { + public static QName create(final String namespace, final String revision, final String localName) { final URI namespaceUri = parseNamespace(namespace); final Date revisionDate = parseRevision(revision); return create(namespaceUri, revisionDate, localName); @@ -283,7 +282,7 @@ public final class QName implements Immutable, Serializable, Comparable { private static URI parseNamespace(final String namespace) { try { return new URI(namespace); - } catch (URISyntaxException ue) { + } catch (final URISyntaxException ue) { throw new IllegalArgumentException(String.format("Namespace '%s' is not a valid URI", namespace), ue); } } @@ -301,13 +300,13 @@ public final class QName implements Immutable, Serializable, Comparable { * @throws IllegalArgumentException * If namespace is not valid URI. */ - public static QName create(final String namespace, final String localName) throws IllegalArgumentException { + public static QName create(final String namespace, final String localName) { return create(parseNamespace(namespace), null, localName); } @Override public String toString() { - StringBuilder sb = new StringBuilder(); + final StringBuilder sb = new StringBuilder(); if (getNamespace() != null) { sb.append(QNAME_LEFT_PARENTHESIS + getNamespace()); diff --git a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/QNameModule.java b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/QNameModule.java index cd6c0e9ef8..def8da86cb 100644 --- a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/QNameModule.java +++ b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/QNameModule.java @@ -12,6 +12,7 @@ import java.io.Serializable; import java.net.URI; import java.net.URISyntaxException; import java.util.Date; +import java.util.Objects; import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.objcache.ObjectCache; import org.opendaylight.yangtools.objcache.ObjectCacheFactory; @@ -114,18 +115,10 @@ public final class QNameModule implements Immutable, Serializable { return false; } final QNameModule other = (QNameModule) obj; - if (revision == null) { - if (other.revision != null) { - return false; - } - } else if (!revision.equals(other.revision)) { + if (!Objects.equals(revision, other.revision)) { return false; } - if (namespace == null) { - if (other.namespace != null) { - return false; - } - } else if (!namespace.equals(other.namespace)) { + if (!Objects.equals(namespace, other.namespace)) { return false; } return true; @@ -157,7 +150,7 @@ public final class QNameModule implements Immutable, Serializable { try { compositeURI = new URI(namespace.getScheme(), namespace.getUserInfo(), namespace.getHost(), namespace.getPort(), namespace.getPath(), query, namespace.getFragment()); - } catch (URISyntaxException e) { + } catch (final URISyntaxException e) { LOG.error("", e); } return compositeURI; diff --git a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/SimpleDateFormatUtil.java b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/SimpleDateFormatUtil.java index 303ef4f2e0..9d11685a6d 100644 --- a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/SimpleDateFormatUtil.java +++ b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/SimpleDateFormatUtil.java @@ -17,16 +17,16 @@ public final class SimpleDateFormatUtil { private static final String REVISION_SIMPLE_DATE = "yyyy-MM-dd"; private static final String DEFAULT_DATE = "1970-01-01"; - public static Date DEFAULT_DATE_REV; - public static Date DEFAULT_DATE_IMP; + public static final Date DEFAULT_DATE_REV; + public static final Date DEFAULT_DATE_IMP; static { - SimpleDateFormat simpleDateFormat = new SimpleDateFormat(REVISION_SIMPLE_DATE); + final SimpleDateFormat simpleDateFormat = new SimpleDateFormat(REVISION_SIMPLE_DATE); try { DEFAULT_DATE_REV = simpleDateFormat.parse(DEFAULT_DATE); DEFAULT_DATE_IMP = simpleDateFormat.parse(DEFAULT_DATE); - } catch (ParseException e) { + } catch (final ParseException e) { throw new ExceptionInInitializerError(e); } } @@ -43,7 +43,7 @@ public final class SimpleDateFormatUtil { } @Override - public void set(SimpleDateFormat value) { + public void set(final SimpleDateFormat value) { throw new UnsupportedOperationException(); } diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java index 44f24c2a70..e1636ae77e 100644 --- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java @@ -8,6 +8,9 @@ package org.opendaylight.yangtools.yang.data.api.schema.tree; import com.google.common.annotations.Beta; +import com.google.common.base.Preconditions; +import java.util.Collection; +import java.util.Iterator; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; @Beta @@ -19,4 +22,66 @@ public final class DataTreeCandidateNodes { public static DataTreeCandidateNode fromNormalizedNode(final NormalizedNode node) { return new NormalizedNodeDataTreeCandidateNode(node); } + + public static void applyToCursor(final DataTreeModificationCursor cursor, final DataTreeCandidateNode node) { + switch (node.getModificationType()) { + case DELETE: + cursor.delete(node.getIdentifier()); + break; + case SUBTREE_MODIFIED: + cursor.enter(node.getIdentifier()); + NodeIterator iterator = new NodeIterator(null, node.getChildNodes().iterator()); + do { + iterator = iterator.next(cursor); + } while (iterator != null); + break; + case UNMODIFIED: + // No-op + break; + case WRITE: + cursor.write(node.getIdentifier(), node.getDataAfter().get()); + break; + default: + throw new IllegalArgumentException("Unsupported modification " + node.getModificationType()); + } + } + + private static final class NodeIterator { + private final Iterator iterator; + private final NodeIterator parent; + + NodeIterator(final NodeIterator parent, final Iterator iterator) { + this.parent = Preconditions.checkNotNull(parent); + this.iterator = Preconditions.checkNotNull(iterator); + } + + NodeIterator next(final DataTreeModificationCursor cursor) { + while (iterator.hasNext()) { + final DataTreeCandidateNode node = iterator.next(); + switch (node.getModificationType()) { + case DELETE: + cursor.delete(node.getIdentifier()); + break; + case SUBTREE_MODIFIED: + final Collection children = node.getChildNodes(); + if (!children.isEmpty()) { + cursor.enter(node.getIdentifier()); + return new NodeIterator(this, children.iterator()); + } + break; + case UNMODIFIED: + // No-op + break; + case WRITE: + cursor.write(node.getIdentifier(), node.getDataAfter().get()); + break; + default: + throw new IllegalArgumentException("Unsupported modification " + node.getModificationType()); + } + } + + cursor.exit(); + return parent; + } + } } diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidates.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidates.java index 99256397b0..1b242918dd 100644 --- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidates.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidates.java @@ -8,6 +8,8 @@ package org.opendaylight.yangtools.yang.data.api.schema.tree; import com.google.common.annotations.Beta; +import com.google.common.base.Preconditions; +import java.util.Iterator; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; @@ -31,17 +33,20 @@ public final class DataTreeCandidates { return new DefaultDataTreeCandidate(rootPath, new NormalizedNodeDataTreeCandidateNode(node)); } + public static void applyToCursor(final DataTreeModificationCursor cursor, final DataTreeCandidate candidate) { + DataTreeCandidateNodes.applyToCursor(cursor, candidate.getRootNode()); + } + public static void applyToModification(final DataTreeModification modification, final DataTreeCandidate candidate) { if (modification instanceof CursorAwareDataTreeModification) { try (DataTreeModificationCursor cursor = ((CursorAwareDataTreeModification) modification).createCursor(candidate.getRootPath())) { - applyNode(cursor, candidate.getRootNode()); + applyToCursor(cursor, candidate); } - } else { - applyNode(modification, candidate.getRootPath(), candidate.getRootNode()); + return; } - } - private static void applyNode(final DataTreeModification modification, final YangInstanceIdentifier path, final DataTreeCandidateNode node) { + final DataTreeCandidateNode node = candidate.getRootNode(); + final YangInstanceIdentifier path = candidate.getRootPath(); switch (node.getModificationType()) { case DELETE: modification.delete(path); @@ -49,9 +54,11 @@ public final class DataTreeCandidates { break; case SUBTREE_MODIFIED: LOG.debug("Modification {} modified path {}", modification, path); - for (DataTreeCandidateNode child : node.getChildNodes()) { - applyNode(modification, path.node(child.getIdentifier()), child); - } + + NodeIterator iterator = new NodeIterator(null, path, node.getChildNodes().iterator()); + do { + iterator = iterator.next(modification); + } while (iterator != null); break; case UNMODIFIED: LOG.debug("Modification {} unmodified path {}", modification, path); @@ -66,26 +73,44 @@ public final class DataTreeCandidates { } } - private static void applyNode(final DataTreeModificationCursor cursor, final DataTreeCandidateNode node) { - switch (node.getModificationType()) { - case DELETE: - cursor.delete(node.getIdentifier()); - break; - case SUBTREE_MODIFIED: - cursor.enter(node.getIdentifier()); - for (DataTreeCandidateNode child : node.getChildNodes()) { - applyNode(cursor, child); + private static final class NodeIterator { + private final Iterator iterator; + private final YangInstanceIdentifier path; + private final NodeIterator parent; + + public NodeIterator(final NodeIterator parent, final YangInstanceIdentifier path, final Iterator iterator) { + this.iterator = Preconditions.checkNotNull(iterator); + this.parent = Preconditions.checkNotNull(parent); + this.path = Preconditions.checkNotNull(path); + } + + NodeIterator next(final DataTreeModification modification) { + while (iterator.hasNext()) { + final DataTreeCandidateNode node = iterator.next(); + final YangInstanceIdentifier child = path.node(node.getIdentifier()); + + switch (node.getModificationType()) { + case DELETE: + modification.delete(child); + LOG.debug("Modification {} deleted path {}", modification, child); + break; + case SUBTREE_MODIFIED: + LOG.debug("Modification {} modified path {}", modification, child); + return new NodeIterator(this, child, node.getChildNodes().iterator()); + case UNMODIFIED: + LOG.debug("Modification {} unmodified path {}", modification, child); + // No-op + break; + case WRITE: + modification.write(child, node.getDataAfter().get()); + LOG.debug("Modification {} written path {}", modification, child); + break; + default: + throw new IllegalArgumentException("Unsupported modification " + node.getModificationType()); + } } - cursor.exit(); - break; - case UNMODIFIED: - // No-op - break; - case WRITE: - cursor.write(node.getIdentifier(), node.getDataAfter().get()); - break; - default: - throw new IllegalArgumentException("Unsupported modification " + node.getModificationType()); + + return parent; } } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/SchemaTracker.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/SchemaTracker.java index 7ff31d6935..5c02d7eb39 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/SchemaTracker.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/SchemaTracker.java @@ -91,15 +91,15 @@ public final class SchemaTracker { root = (DataNodeContainer) current; } - private Optional tryFindGroupings(final SchemaContext ctx, final QName qname) { + private static Optional tryFindGroupings(final SchemaContext ctx, final QName qname) { return Optional. fromNullable(Iterables.find(ctx.getGroupings(), new SchemaNodePredicate(qname), null)); } - private Optional tryFindRpc(final SchemaContext ctx, final QName qname) { + private static Optional tryFindRpc(final SchemaContext ctx, final QName qname) { return Optional.fromNullable(Iterables.find(ctx.getOperations(), new SchemaNodePredicate(qname), null)); } - private Optional tryFindNotification(final SchemaContext ctx, final QName qname) { + private static Optional tryFindNotification(final SchemaContext ctx, final QName qname) { return Optional.fromNullable(Iterables.find(ctx.getNotifications(), new SchemaNodePredicate(qname), null)); } @@ -155,7 +155,7 @@ public final class SchemaTracker { return schema; } - private SchemaNode findChildInCases(final ChoiceSchemaNode parent, final QName qname) { + private static SchemaNode findChildInCases(final ChoiceSchemaNode parent, final QName qname) { DataSchemaNode schema = null; for(final ChoiceCaseNode caze : parent.getCases()) { final DataSchemaNode potential = caze.getDataChildByName(qname); @@ -167,7 +167,7 @@ public final class SchemaTracker { return schema; } - private SchemaNode findCaseByChild(final ChoiceSchemaNode parent, final QName qname) { + private static SchemaNode findCaseByChild(final ChoiceSchemaNode parent, final QName qname) { DataSchemaNode schema = null; for(final ChoiceCaseNode caze : parent.getCases()) { final DataSchemaNode potential = caze.getDataChildByName(qname); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlDocumentUtils.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlDocumentUtils.java index a4812c7316..19122a00cb 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlDocumentUtils.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlDocumentUtils.java @@ -23,15 +23,12 @@ import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import org.w3c.dom.Attr; import org.w3c.dom.Document; import org.w3c.dom.Element; public final class XmlDocumentUtils { public static final QName OPERATION_ATTRIBUTE_QNAME = QName.create(SchemaContext.NAME, "operation"); - private static final Logger LOG = LoggerFactory.getLogger(XmlDocumentUtils.class); private XmlDocumentUtils() { throw new UnsupportedOperationException("Utility class should not be instantiated"); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/leafref/LeafRefValidatation.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/leafref/LeafRefValidatation.java index 42006157e5..c8bf9ccc99 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/leafref/LeafRefValidatation.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/leafref/LeafRefValidatation.java @@ -144,7 +144,7 @@ public class LeafRefValidatation { } - private LeafRefContext getReferencingCtxChild( + private static LeafRefContext getReferencingCtxChild( final LeafRefContext referencingCtx, final DataTreeCandidateNode childNode) { LeafRefContext childReferencingCtx = null; @@ -167,7 +167,7 @@ public class LeafRefValidatation { return childReferencingCtx; } - private LeafRefContext getReferencedByCtxChild( + private static LeafRefContext getReferencedByCtxChild( final LeafRefContext referencedByCtx, final DataTreeCandidateNode childNode) { LeafRefContext childReferencedByCtx = null; @@ -318,7 +318,7 @@ public class LeafRefValidatation { // FIXME if(node instance of UnkeyedListNode ... } - private LeafRefContext findReferencingCtxUnderChoice( + private static LeafRefContext findReferencingCtxUnderChoice( final LeafRefContext referencingCtx, final QName qname) { final Map referencingChilds = referencingCtx @@ -335,7 +335,7 @@ public class LeafRefValidatation { return null; } - private LeafRefContext findReferencedByCtxUnderChoice( + private static LeafRefContext findReferencedByCtxUnderChoice( final LeafRefContext referencedByCtx, final QName qname) { final Map referencedByChilds = referencedByCtx @@ -436,14 +436,13 @@ public class LeafRefValidatation { validatedLeafRefCtx.add(referencedByCtx); } - private StringBuilder createInvalidTargetMessage(final NormalizedNode leaf, + private static StringBuilder createInvalidTargetMessage(final NormalizedNode leaf, final HashSet leafRefTargetNodeValues, final LeafRefContext leafRefContext, final Object leafRefsValue) { final StringBuilder sb = new StringBuilder(); sb.append("Invalid leafref value ["); sb.append(leafRefsValue); - sb.append("]"); - sb.append(" allowed values "); + sb.append("] allowed values "); sb.append(leafRefTargetNodeValues); sb.append(" by validation of leafref TARGET node: "); sb.append(leaf.getNodeType()); @@ -458,13 +457,16 @@ public class LeafRefValidatation { final LeafRefContext referencingCtx, final ModificationType modificationType, final YangInstanceIdentifier current) { - final StringBuilder header_log = new StringBuilder(); + final StringBuilder headerLog = new StringBuilder(); final StringBuilder log = new StringBuilder(); - header_log.append("Operation [" + modificationType - + "] validate data of LEAFREF node: name[" - + referencingCtx.getNodeName() + "] = value[" - + leaf.getValue() + "]"); + headerLog.append("Operation ["); + headerLog.append(modificationType); + headerLog.append("] validate data of LEAFREF node: name["); + headerLog.append(referencingCtx.getNodeName()); + headerLog.append("] = value["); + headerLog.append(leaf.getValue()); + headerLog.append(']'); final HashSet values = new HashSet<>(); final LeafRefPath targetPath = referencingCtx.getAbsoluteLeafRefTargetPath(); @@ -479,25 +481,25 @@ public class LeafRefValidatation { referencingCtx, values); errorsMessages.add(sb.toString()); - header_log.append(" -> FAILED"); + headerLog.append(" -> FAILED"); log.append(sb.toString()); } else { - header_log.append(" -> OK"); + headerLog.append(" -> OK"); } - LOG.debug(header_log.toString()); - if (!log.toString().equals("")) + LOG.debug(headerLog.toString()); + if (log.length() != 0) { LOG.debug(log.toString()); + } } - private StringBuilder createInvalidLeafRefMessage( + private static StringBuilder createInvalidLeafRefMessage( final NormalizedNode leaf, final LeafRefContext referencingCtx, final Set values) { final StringBuilder sb = new StringBuilder(); sb.append("Invalid leafref value ["); sb.append(leaf.getValue()); - sb.append("]"); - sb.append(" allowed values "); + sb.append("] allowed values "); sb.append(values); sb.append(" of LEAFREF node: "); sb.append(leaf.getNodeType()); @@ -615,8 +617,7 @@ public class LeafRefValidatation { } } - private Iterable getChoiceNodes( - final DataContainerNode dataContainerNode) { + private static Iterable getChoiceNodes(final DataContainerNode dataContainerNode) { final LinkedList choiceNodes = new LinkedList(); @@ -630,7 +631,7 @@ public class LeafRefValidatation { return choiceNodes; } - private boolean isMatchingPredicate(final MapEntryNode mapEntryNode, + private static boolean isMatchingPredicate(final MapEntryNode mapEntryNode, final Map> allowedKeyValues) { final NodeIdentifierWithPredicates identifier = mapEntryNode.getIdentifier(); @@ -671,7 +672,7 @@ public class LeafRefValidatation { return values; } - private Optional> findParentNode( + private static Optional> findParentNode( final Optional> root, final YangInstanceIdentifier path) { Optional> currentNode = root; final Iterator pathIterator = path.getPathArguments() @@ -688,12 +689,11 @@ public class LeafRefValidatation { return Optional.absent(); } - private Iterable nextLevel( - final Iterable path) { + private static Iterable nextLevel(final Iterable path) { return Iterables.skip(path, 1); } - private PathArgument toPathArgument(final QName qName) { + private static PathArgument toPathArgument(final QName qName) { return YangInstanceIdentifier.of(qName).getLastPathArgument(); } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToCompositeNodes.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToCompositeNodes.java index 28e8d892f0..69618f5128 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToCompositeNodes.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToCompositeNodes.java @@ -9,7 +9,6 @@ package org.opendaylight.yangtools.yang.data.impl.schema; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; - import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableMap; @@ -110,7 +109,6 @@ abstract class InstanceIdToCompositeNodes createBuilder(final YangInstanceIdentifier.PathArgument compositeNode); static abstract class DataContainerNormalizationOperation extends diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/NormalizedNodeResult.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/NormalizedNodeResult.java index 76b28e93aa..47723fd788 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/NormalizedNodeResult.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/NormalizedNodeResult.java @@ -7,7 +7,6 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema; -import com.google.common.base.Preconditions; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; /** @@ -33,7 +32,9 @@ public class NormalizedNodeResult { } void setResult(final NormalizedNode result) { - Preconditions.checkState(!this.finished, "Result was already set."); + if (finished) { + throw new ResultAlreadySetException("Normalized Node result was already set.", this.result); + } this.finished = true; this.result = result; } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ResultAlreadySetException.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ResultAlreadySetException.java new file mode 100644 index 0000000000..f066f29f6c --- /dev/null +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ResultAlreadySetException.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.data.impl.schema; + +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; + +public class ResultAlreadySetException extends IllegalStateException { + private static final long serialVersionUID = 1L; + private final NormalizedNode resultData; + + public ResultAlreadySetException(final String message, final NormalizedNode resultData) { + this(message, resultData, null); + } + + public ResultAlreadySetException(final String message, final NormalizedNode resultData, final Throwable cause) { + super(message, cause); + this.resultData = resultData; + } + + public NormalizedNode getResultData() { + return resultData; + } +} diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/SchemaUtils.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/SchemaUtils.java index a5c5148548..755a228c91 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/SchemaUtils.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/SchemaUtils.java @@ -23,7 +23,6 @@ import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; -import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; @@ -34,6 +33,7 @@ import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; public final class SchemaUtils { private SchemaUtils() { + throw new UnsupportedOperationException(); } /** diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/ToNormalizedNodeParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/ToNormalizedNodeParser.java index a300cc07d4..04c4ed8f73 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/ToNormalizedNodeParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/ToNormalizedNodeParser.java @@ -7,6 +7,7 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform; +import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; /** @@ -33,5 +34,6 @@ public interface ToNormalizedNodeParser, S> { * @param schema * @return NormalizedNode as a result of parsing list of E elements with schema S */ + @Nullable N parse(Iterable xmlDom, S schema); } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/AugmentationNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/AugmentationNodeBaseParser.java index 7c3938fe08..bd7853a5dd 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/AugmentationNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/AugmentationNodeBaseParser.java @@ -26,7 +26,13 @@ import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; * @param type of elements to be parsed */ public abstract class AugmentationNodeBaseParser extends - BaseDispatcherParser { + BaseDispatcherParser { + + public AugmentationNodeBaseParser(final BuildingStrategy buildingStrategy) { + super(buildingStrategy); + } + + public AugmentationNodeBaseParser() {} @Override protected final DataContainerNodeBuilder getBuilder(final AugmentationSchema schema) { diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/BaseDispatcherParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/BaseDispatcherParser.java index a594e5d763..9d52ba4b15 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/BaseDispatcherParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/BaseDispatcherParser.java @@ -14,30 +14,42 @@ import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Set; +import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.AttributesBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema; /** * Abstract(base) Parser for DataContainerNodes e.g. ContainerNode, AugmentationNode. */ -public abstract class BaseDispatcherParser, S> - implements ToNormalizedNodeParser { +public abstract class BaseDispatcherParser, S> + implements ExtensibleParser { + + private final BuildingStrategy buildingStrategy; + + public BaseDispatcherParser(final BuildingStrategy buildingStrategy) { + this.buildingStrategy = buildingStrategy; + } + + public BaseDispatcherParser() { + this.buildingStrategy = new SimpleBuildingStrategy<>(); + } /** * * @param schema * @return New(empty) instance of a builder to build node identified by schema. */ - protected abstract DataContainerNodeBuilder getBuilder(S schema); + protected abstract DataContainerNodeBuilder getBuilder(S schema); /** * @@ -88,12 +100,19 @@ public abstract class BaseDispatcherParser, S> */ protected abstract NodeParserDispatcher getDispatcher(); + /** + * can return null only if you override ParsingStrategy and explicitely return null + * @param elements + * @param schema + * @return + */ + @Nullable @Override public N parse(final Iterable elements, final S schema) { checkAtLeastOneNode(schema, elements); - DataContainerNodeBuilder containerBuilder = getBuilder(schema); + DataContainerNodeBuilder containerBuilder = getBuilder(schema); // Map child nodes to QName LinkedListMultimap mappedChildElements = mapChildElements(elements); @@ -106,6 +125,36 @@ public abstract class BaseDispatcherParser, S> Map mappedChoiceChildNodes = mapChildElementsFromChoices(schema); LinkedListMultimap choicesToElements = LinkedListMultimap.create(); + Map attributes = getAttributes(elements.iterator().next()); + if (containerBuilder instanceof AttributesBuilder) { + final int size = Iterables.size(elements); + Preconditions.checkArgument(size == 1, "Unexpected number of elements: %s, should be 1 for: %s", + size, schema); + ((AttributesBuilder) containerBuilder).withAttributes(attributes); + } + + //parse keys first + if (schema instanceof ListSchemaNode) { + for (QName qname : ((ListSchemaNode) schema).getKeyDefinition()) { + if(mappedChildElements.get(qname.withoutRevision()).isEmpty()) { + continue; + } + + DataSchemaNode childSchema = getSchemaForChild(schema, qname); + List childrenForQName = mappedChildElements.removeAll(qname.withoutRevision()); + + + DataContainerChild optionalChildNode = getDispatcher() + .dispatchChildElement(childSchema, childrenForQName); + if (optionalChildNode != null) { + containerBuilder.withChild(optionalChildNode); + } + } + } + + //stage attribues for strategy before going deeper in the recursion + buildingStrategy.prepareAttributes(attributes, containerBuilder); + // process Child nodes for (QName childPartialQName : mappedChildElements.keySet()) { DataSchemaNode childSchema = getSchemaForChild(schema, childPartialQName); @@ -125,32 +174,39 @@ public abstract class BaseDispatcherParser, S> choicesToElements.putAll(choiceSchema, childrenForQName); // Regular child nodes } else { - DataContainerChild builtChildNode = getDispatcher() + DataContainerChild optionalChildNode = getDispatcher() .dispatchChildElement(childSchema, childrenForQName); - containerBuilder.withChild(builtChildNode); + if (optionalChildNode != null) { + containerBuilder.withChild(optionalChildNode); + } } } // TODO ordering is not preserved for choice and augment elements for (ChoiceSchemaNode choiceSchema : choicesToElements.keySet()) { - containerBuilder.withChild(getDispatcher().dispatchChildElement(choiceSchema, - choicesToElements.get(choiceSchema))); + DataContainerChild optionalChild = getDispatcher() + .dispatchChildElement(choiceSchema, choicesToElements.get(choiceSchema)); + if (optionalChild != null) { + containerBuilder.withChild(optionalChild); + } } for (AugmentationSchema augmentSchema : augmentsToElements.keySet()) { Set realChildSchemas = getRealSchemasForAugment(schema, augmentSchema); EffectiveAugmentationSchema augSchemaProxy = new EffectiveAugmentationSchema(augmentSchema, realChildSchemas); - containerBuilder.withChild(getDispatcher().dispatchChildElement(augSchemaProxy, augmentsToElements.get(augmentSchema))); + DataContainerChild optionalChild = getDispatcher() + .dispatchChildElement(augSchemaProxy, augmentsToElements.get(augmentSchema)); + if (optionalChild != null) { + containerBuilder.withChild(optionalChild); + } } - if (containerBuilder instanceof AttributesBuilder) { - final int size = Iterables.size(elements); - Preconditions.checkArgument(size == 1, "Unexpected number of elements: %s, should be 1 for: %s", - size, schema); - ((AttributesBuilder) containerBuilder).withAttributes(getAttributes(elements.iterator().next())); - } + return buildingStrategy.build(containerBuilder); + } - return containerBuilder.build(); + @Override + public BuildingStrategy getBuildingStrategy() { + return buildingStrategy; } protected Map getAttributes(final E e) { @@ -161,7 +217,7 @@ public abstract class BaseDispatcherParser, S> return true; } - private boolean isMarkedAs(final Map mappedAugmentChildNodes, final QName qName) { + private static boolean isMarkedAs(final Map mappedAugmentChildNodes, final QName qName) { return mappedAugmentChildNodes.containsKey(qName); } @@ -175,4 +231,16 @@ public abstract class BaseDispatcherParser, S> Preconditions.checkArgument(!Iterables.isEmpty(childNodes), "Node detected 0 times, should be at least 1, identified by: %s, found: %s", schema, childNodes); } + + public static class SimpleBuildingStrategy

> implements BuildingStrategy { + @Override + public N build(final NormalizedNodeBuilder builder) { + return builder.build(); + } + + @Override + public void prepareAttributes(final Map attributes, final NormalizedNodeBuilder containerBuilder) { + // NOOP + } + } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ChoiceNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ChoiceNodeBaseParser.java index a82f71685a..371c59c355 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ChoiceNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ChoiceNodeBaseParser.java @@ -28,7 +28,13 @@ import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; * * @param type of elements to be parsed */ -public abstract class ChoiceNodeBaseParser extends BaseDispatcherParser { +public abstract class ChoiceNodeBaseParser extends BaseDispatcherParser { + + protected ChoiceNodeBaseParser() {} + + protected ChoiceNodeBaseParser(final BuildingStrategy buildingStrategy) { + super(buildingStrategy); + } @Override protected final DataContainerNodeBuilder getBuilder( diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ContainerNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ContainerNodeBaseParser.java index f7cca88155..99801cf3a1 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ContainerNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ContainerNodeBaseParser.java @@ -27,7 +27,13 @@ import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; * @param type of elements to be parsed */ public abstract class ContainerNodeBaseParser extends - BaseDispatcherParser { + BaseDispatcherParser { + + public ContainerNodeBaseParser() {} + + public ContainerNodeBaseParser(final BuildingStrategy buildingStrategy) { + super(buildingStrategy); + } @Override protected final DataContainerNodeBuilder getBuilder( @@ -63,4 +69,5 @@ public abstract class ContainerNodeBaseParser extends @Override protected abstract Map getAttributes(E e); + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ExtensibleParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ExtensibleParser.java new file mode 100644 index 0000000000..e2b5ec7e6d --- /dev/null +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ExtensibleParser.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser; + +import java.util.Map; +import javax.annotation.Nullable; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder; +import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; + +/** + * Extensible parser allows its subclasses to customize the building process of normalized nodes + * + * @param

+ * @param + * @param + * @param + */ +public interface ExtensibleParser

, S> + extends ToNormalizedNodeParser { + + /** + * Provide building strategy + */ + BuildingStrategy getBuildingStrategy(); + + /** + * Building strategy serves as a set of hooks into the parsing process. + * + * @param

+ * @param + */ + interface BuildingStrategy

> { + + /** + * Build normalized node from its builder + * + * @param builder filled builder for node + * @return built normalized node or null if the node should not be built + */ + @Nullable N build(NormalizedNodeBuilder builder); + + /** + * Hook for subclasses to handle attributes associated with current node. This is called before the build method + * and allows subclasses to react to node's attributes e.g. modification operation + * + * @param attributes attributes for node + * @param containerBuilder builder created for node. Can be modified according to attributes e.g. remove attribute + */ + void prepareAttributes(Map attributes, NormalizedNodeBuilder containerBuilder); + } +} diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafNodeBaseParser.java index 4056d1da18..f5dc67e1a3 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafNodeBaseParser.java @@ -7,27 +7,36 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser; +import com.google.common.base.Preconditions; +import com.google.common.collect.Iterables; import java.util.Map; - import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; -import com.google.common.base.Preconditions; -import com.google.common.collect.Iterables; - /** * Abstract(base) parser for LeafNodes, parses elements of type E. * * @param type of elements to be parsed */ -public abstract class LeafNodeBaseParser implements - ToNormalizedNodeParser, LeafSchemaNode> { +public abstract class LeafNodeBaseParser implements ExtensibleParser, LeafSchemaNode> { + + private final BuildingStrategy> buildingStrategy; + + public LeafNodeBaseParser() { + buildingStrategy = new SimpleLeafBuildingStrategy(); + } + public LeafNodeBaseParser(final BuildingStrategy> buildingStrategy) { + this.buildingStrategy = buildingStrategy; + } + + @SuppressWarnings("unchecked") @Override public final LeafNode parse(Iterable elements, LeafSchemaNode schema) { final int size = Iterables.size(elements); @@ -36,11 +45,13 @@ public abstract class LeafNodeBaseParser implements final E e = elements.iterator().next(); Object value = parseLeaf(e, schema); - NormalizedNodeAttrBuilder> leafBuilder = Builders.leafBuilder(schema); + NormalizedNodeAttrBuilder> leafBuilder = + Builders.leafBuilder(schema); leafBuilder.withAttributes(getAttributes(e)); - return leafBuilder.withValue(value).build(); + final BuildingStrategy rawBuildingStrat = buildingStrategy; + return (LeafNode) rawBuildingStrat.build(leafBuilder.withValue(value)); } /** @@ -59,4 +70,21 @@ public abstract class LeafNodeBaseParser implements * @return attributes mapped to QNames */ protected abstract Map getAttributes(E e); + + @Override + public BuildingStrategy> getBuildingStrategy() { + return buildingStrategy; + } + + public static class SimpleLeafBuildingStrategy implements BuildingStrategy> { + @Override + public LeafNode build(final NormalizedNodeBuilder> builder) { + return builder.build(); + } + + @Override + public void prepareAttributes(final Map attributes, final NormalizedNodeBuilder> containerBuilder) { + // NOOP + } + } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafSetEntryNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafSetEntryNodeBaseParser.java index 526cdf8615..7006c269ad 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafSetEntryNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafSetEntryNodeBaseParser.java @@ -7,29 +7,38 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser; +import com.google.common.base.Preconditions; +import com.google.common.collect.Iterables; import java.util.Map; - import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue; import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder; import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; -import com.google.common.base.Preconditions; -import com.google.common.collect.Iterables; - /** * Abstract(base) parser for LeafSetEntryNodes, parses elements of type E. * * @param type of elements to be parsed */ -public abstract class LeafSetEntryNodeBaseParser implements - ToNormalizedNodeParser, LeafListSchemaNode> { +public abstract class LeafSetEntryNodeBaseParser implements ExtensibleParser, LeafListSchemaNode> { + + private final BuildingStrategy> buildingStrategy; + + public LeafSetEntryNodeBaseParser() { + buildingStrategy = new SimpleLeafSetEntryBuildingStrategy(); + } + public LeafSetEntryNodeBaseParser(final BuildingStrategy> buildingStrategy) { + this.buildingStrategy = buildingStrategy; + } + + @SuppressWarnings("unchecked") @Override - public final LeafSetEntryNode parse(Iterable elements, LeafListSchemaNode schema) { + public final LeafSetEntryNode parse(Iterable elements, LeafListSchemaNode schema) { final int size = Iterables.size(elements); Preconditions.checkArgument(size == 1, "Xml elements mapped to leaf node illegal count: %s", size); @@ -39,8 +48,15 @@ public abstract class LeafSetEntryNodeBaseParser implements NormalizedNodeAttrBuilder> leafEntryBuilder = Builders .leafSetEntryBuilder(schema); leafEntryBuilder.withAttributes(getAttributes(e)); + leafEntryBuilder.withValue(value); + + final BuildingStrategy rawBuildingStrat = buildingStrategy; + return (LeafSetEntryNode) rawBuildingStrat.build(leafEntryBuilder); + } - return leafEntryBuilder.withValue(value).build(); + @Override + public BuildingStrategy> getBuildingStrategy() { + return buildingStrategy; } /** @@ -60,4 +76,15 @@ public abstract class LeafSetEntryNodeBaseParser implements */ protected abstract Map getAttributes(E e); + public static class SimpleLeafSetEntryBuildingStrategy implements BuildingStrategy> { + + @Override + public LeafSetEntryNode build(final NormalizedNodeBuilder> builder) { + return builder.build(); + } + + @Override + public void prepareAttributes(final Map attributes, final NormalizedNodeBuilder> containerBuilder) { + } + } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafSetNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafSetNodeBaseParser.java index 4cdae37f35..3669cba16b 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafSetNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/LeafSetNodeBaseParser.java @@ -8,7 +8,6 @@ package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser; import java.util.Collections; - import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ListEntryNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ListEntryNodeBaseParser.java index dfa34abcc7..cd0b478ec0 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ListEntryNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ListEntryNodeBaseParser.java @@ -10,6 +10,7 @@ package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser; import java.util.Map; import java.util.Set; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; @@ -24,8 +25,15 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; * @param * type of elements to be parsed */ -public abstract class ListEntryNodeBaseParser> extends - BaseDispatcherParser { +public abstract class ListEntryNodeBaseParser

> extends + BaseDispatcherParser { + + public ListEntryNodeBaseParser(final BuildingStrategy buildingStrategy) { + super(buildingStrategy); + } + + public ListEntryNodeBaseParser() { + } @Override protected final Set getRealSchemasForAugment(final ListSchemaNode schema, final AugmentationSchema augmentSchema) { diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ListNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ListNodeBaseParser.java index 67c97a767d..f8bc9c120b 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ListNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/ListNodeBaseParser.java @@ -8,9 +8,12 @@ package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser; import java.util.Collections; +import java.util.Map; +import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; @@ -21,17 +24,32 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; * type of elements to be parsed */ public abstract class ListNodeBaseParser, O extends NormalizedNode, S extends ListSchemaNode> - implements ToNormalizedNodeParser { + implements ExtensibleParser { + + private final BuildingStrategy buildingStrategy; + + public ListNodeBaseParser() { + buildingStrategy = new SimpleListNodeBuildingStrategy<>(); + } + + public ListNodeBaseParser(final BuildingStrategy buildingStrategy) { + this.buildingStrategy = buildingStrategy; + } @Override - public final O parse(Iterable childNodes, S schema) { + public O parse(Iterable childNodes, S schema) { CollectionNodeBuilder listBuilder = provideBuilder(schema); + + buildingStrategy.prepareAttributes(Collections.emptyMap(), listBuilder); + for (E childNode : childNodes) { N listChild = getListEntryNodeParser().parse(Collections.singletonList(childNode), schema); - listBuilder.withChild(listChild); + if (listChild != null) { + listBuilder.withChild(listChild); + } } - return listBuilder.build(); + return buildingStrategy.build(listBuilder); } /** @@ -46,4 +64,21 @@ public abstract class ListNodeBaseParser, O ex * @return prepares builder which will contain entries of list according to concrete list type */ protected abstract CollectionNodeBuilder provideBuilder(S schema); + + @Override + public BuildingStrategy getBuildingStrategy() { + return buildingStrategy; + } + + public static class SimpleListNodeBuildingStrategy> implements BuildingStrategy { + @Override + public O build(final NormalizedNodeBuilder builder) { + return builder.build(); + } + + @Override + public void prepareAttributes(final Map attributes, final NormalizedNodeBuilder containerBuilder) { + // NOOP + } + } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/MapNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/MapNodeBaseParser.java index a57a694e12..8056340465 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/MapNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/MapNodeBaseParser.java @@ -7,6 +7,7 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.MapNode; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; @@ -21,6 +22,13 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; */ public abstract class MapNodeBaseParser extends ListNodeBaseParser { + public MapNodeBaseParser() { + } + + public MapNodeBaseParser(final BuildingStrategy buildingStrategy) { + super(buildingStrategy); + } + protected CollectionNodeBuilder provideBuilder(ListSchemaNode schema) { return Builders.mapBuilder(schema); } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/OrderedListNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/OrderedListNodeBaseParser.java index 6278accb61..a2ca255ce8 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/OrderedListNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/OrderedListNodeBaseParser.java @@ -7,6 +7,7 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; @@ -21,8 +22,17 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; */ public abstract class OrderedListNodeBaseParser extends ListNodeBaseParser { + + public OrderedListNodeBaseParser() { + } + + public OrderedListNodeBaseParser(final BuildingStrategy buildingStrategy) { + super(buildingStrategy); + } + @Override protected CollectionNodeBuilder provideBuilder(ListSchemaNode schema) { return Builders.orderedMapBuilder(schema); } + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/UnkeyedListNodeBaseParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/UnkeyedListNodeBaseParser.java index 14d47890cf..73e7f39052 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/UnkeyedListNodeBaseParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/base/parser/UnkeyedListNodeBaseParser.java @@ -22,6 +22,14 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; */ public abstract class UnkeyedListNodeBaseParser extends ListNodeBaseParser { + + public UnkeyedListNodeBaseParser(final BuildingStrategy buildingStrategy) { + super(buildingStrategy); + } + + public UnkeyedListNodeBaseParser() { + } + @Override protected CollectionNodeBuilder provideBuilder(ListSchemaNode schema) { CollectionNodeBuilder listBuilder = Builders.unkeyedListBuilder(); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/AugmentationNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/AugmentationNodeDomParser.java index 73167f407a..3fed808ad9 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/AugmentationNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/AugmentationNodeDomParser.java @@ -7,15 +7,16 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import com.google.common.base.Preconditions; +import com.google.common.collect.LinkedListMultimap; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.AugmentationNodeBaseParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher; import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils; import org.w3c.dom.Element; -import com.google.common.base.Preconditions; -import com.google.common.collect.LinkedListMultimap; - final class AugmentationNodeDomParser extends AugmentationNodeBaseParser { private final NodeParserDispatcher dispatcher; @@ -31,6 +32,13 @@ final class AugmentationNodeDomParser extends AugmentationNodeBaseParser buildingStrategy, + final NodeParserDispatcher dispatcher, final boolean strictParsing) { + super(buildingStrategy); + this.dispatcher = Preconditions.checkNotNull(dispatcher); + this.strictParsing = strictParsing; + } + @Override protected LinkedListMultimap mapChildElements(Iterable elements) { return DomUtils.mapChildElements(elements); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ChoiceNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ChoiceNodeDomParser.java index 97e8a6171c..2c2ccc6ad7 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ChoiceNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ChoiceNodeDomParser.java @@ -7,25 +7,31 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import com.google.common.base.Preconditions; +import com.google.common.collect.LinkedListMultimap; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ChoiceNodeBaseParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher; import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils; import org.w3c.dom.Element; -import com.google.common.base.Preconditions; -import com.google.common.collect.LinkedListMultimap; - final class ChoiceNodeDomParser extends ChoiceNodeBaseParser { private final NodeParserDispatcher dispatcher; - ChoiceNodeDomParser(NodeParserDispatcher dispatcher) { + ChoiceNodeDomParser(final NodeParserDispatcher dispatcher) { + this.dispatcher = Preconditions.checkNotNull(dispatcher); + } + + ChoiceNodeDomParser(final NodeParserDispatcher dispatcher, final BuildingStrategy buildingStrategy) { + super(buildingStrategy); this.dispatcher = Preconditions.checkNotNull(dispatcher); } @Override - protected LinkedListMultimap mapChildElements(Iterable xml) { + protected LinkedListMultimap mapChildElements(final Iterable xml) { return DomUtils.mapChildElements(xml); } @@ -33,4 +39,5 @@ final class ChoiceNodeDomParser extends ChoiceNodeBaseParser { protected NodeParserDispatcher getDispatcher() { return dispatcher; } + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ContainerNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ContainerNodeDomParser.java index ed4f2772ed..397df436a5 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ContainerNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ContainerNodeDomParser.java @@ -7,17 +7,17 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import com.google.common.base.Preconditions; +import com.google.common.collect.LinkedListMultimap; import java.util.Map; - import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ContainerNodeBaseParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher; import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils; import org.w3c.dom.Element; -import com.google.common.base.Preconditions; -import com.google.common.collect.LinkedListMultimap; - final class ContainerNodeDomParser extends ContainerNodeBaseParser { private final NodeParserDispatcher dispatcher; @@ -25,10 +25,16 @@ final class ContainerNodeDomParser extends ContainerNodeBaseParser { ContainerNodeDomParser(final NodeParserDispatcher dispatcher) { this.dispatcher = Preconditions.checkNotNull(dispatcher); - this.strictParsing = super.strictParsing(); + strictParsing = super.strictParsing(); + } + + public ContainerNodeDomParser(final NodeParserDispatcher dispatcher, final boolean strictParsing) { + this.dispatcher = dispatcher; + this.strictParsing = strictParsing; } - ContainerNodeDomParser(final NodeParserDispatcher dispatcher, final boolean strictParsing) { + ContainerNodeDomParser(final NodeParserDispatcher dispatcher, final BuildingStrategy parsingStrategy, final boolean strictParsing) { + super(parsingStrategy); this.dispatcher = Preconditions.checkNotNull(dispatcher); this.strictParsing = strictParsing; } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/DomToNormalizedNodeParserFactory.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/DomToNormalizedNodeParserFactory.java index 8e6381748e..b86289a7be 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/DomToNormalizedNodeParserFactory.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/DomToNormalizedNodeParserFactory.java @@ -7,6 +7,7 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode; import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode; import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode; @@ -22,6 +23,11 @@ import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode; import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider; import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParserFactory; +import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.BaseDispatcherParser; +import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ExtensibleParser; +import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.LeafNodeBaseParser; +import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.LeafSetEntryNodeBaseParser; +import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ListNodeBaseParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher; import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; @@ -34,6 +40,7 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.w3c.dom.Element; public final class DomToNormalizedNodeParserFactory implements ToNormalizedNodeParserFactory { + private final AugmentationNodeDomParser augmentationNodeParser; private final ChoiceNodeDomParser choiceNodeParser; private final ContainerNodeDomParser containerNodeParser; @@ -67,6 +74,31 @@ public final class DomToNormalizedNodeParserFactory implements ToNormalizedNodeP augmentationNodeParser = new AugmentationNodeDomParser(dispatcher, strictParsing); } + private DomToNormalizedNodeParserFactory(final XmlCodecProvider codecProvider, final SchemaContext schema, + final BuildingStrategyProvider buildingStratProvider, final boolean strictParsing) { + leafNodeParser = new LeafNodeDomParser(codecProvider, schema, buildingStratProvider.forLeaf()); + leafSetEntryNodeParser = new LeafSetEntryNodeDomParser(codecProvider, schema, buildingStratProvider.forLeafSetEntry()); + + // no buildingStrategy for Augment (no use case for now) + leafSetNodeParser = new LeafSetNodeDomParser(leafSetEntryNodeParser); + // no buildingStrategy for anyXml (probably not necessary) + anyXmlNodeParser = new AnyXmlDomParser(); + + final NodeParserDispatcher dispatcher = new NodeParserDispatcher.BaseNodeParserDispatcher(this) { + + }; + + containerNodeParser = new ContainerNodeDomParser(dispatcher, buildingStratProvider.forContainer(), strictParsing); + mapEntryNodeParser = new MapEntryNodeDomParser(dispatcher, buildingStratProvider.forMapEntry(), strictParsing); + mapNodeParser = new MapNodeDomParser(mapEntryNodeParser, buildingStratProvider.forMap()); + orderedListNodeParser = new OrderedListNodeDomParser(mapEntryNodeParser, buildingStratProvider.forOrderedList()); + unkeyedListEntryNodeParser = new UnkeyedListEntryNodeDomParser(buildingStratProvider.forUnkeyedListEntry(), dispatcher); + unkeyedListNodeParser = new UnkeyedListNodeDomParser(buildingStratProvider.forUnkeyedList(), unkeyedListEntryNodeParser); + choiceNodeParser = new ChoiceNodeDomParser(dispatcher, buildingStratProvider.forChoice()); + // no buildingStrategy for Augment (no use case for now) + augmentationNodeParser = new AugmentationNodeDomParser(buildingStratProvider.forAugmentation(), dispatcher, strictParsing); + } + @Deprecated private DomToNormalizedNodeParserFactory(final XmlCodecProvider codecProvider) { leafNodeParser = new LeafNodeDomParser(codecProvider); @@ -96,6 +128,17 @@ public final class DomToNormalizedNodeParserFactory implements ToNormalizedNodeP return new DomToNormalizedNodeParserFactory(codecProvider, schema, true); } + public static DomToNormalizedNodeParserFactory getInstance(final XmlCodecProvider codecProvider, final SchemaContext schema, + final BuildingStrategyProvider buildingStratProvider) { + return new DomToNormalizedNodeParserFactory(codecProvider, schema, buildingStratProvider, true); + } + + public static DomToNormalizedNodeParserFactory getInstance(final XmlCodecProvider codecProvider, final SchemaContext schema, + final BuildingStrategyProvider buildingStratProvider, + final boolean strictParsing) { + return new DomToNormalizedNodeParserFactory(codecProvider, schema, buildingStratProvider, strictParsing); + } + @Deprecated public static DomToNormalizedNodeParserFactory getInstance(final XmlCodecProvider codecProvider) { return new DomToNormalizedNodeParserFactory(codecProvider); @@ -160,4 +203,50 @@ public final class DomToNormalizedNodeParserFactory implements ToNormalizedNodeP public ToNormalizedNodeParser getAnyXmlNodeParser() { return anyXmlNodeParser; } + + /** + * Base provider of building strategies used for customizing parsing process + */ + public static abstract class BuildingStrategyProvider { + + protected ExtensibleParser.BuildingStrategy> forLeaf() { + return new LeafNodeBaseParser.SimpleLeafBuildingStrategy(); + } + + protected ExtensibleParser.BuildingStrategy> forLeafSetEntry() { + return new LeafSetEntryNodeBaseParser.SimpleLeafSetEntryBuildingStrategy(); + } + + protected ExtensibleParser.BuildingStrategy forContainer() { + return new BaseDispatcherParser.SimpleBuildingStrategy<>(); + } + + protected ExtensibleParser.BuildingStrategy forMapEntry() { + return new BaseDispatcherParser.SimpleBuildingStrategy<>(); + } + + protected ExtensibleParser.BuildingStrategy forMap() { + return new ListNodeBaseParser.SimpleListNodeBuildingStrategy<>(); + } + + protected ExtensibleParser.BuildingStrategy forOrderedList() { + return new ListNodeBaseParser.SimpleListNodeBuildingStrategy<>(); + } + + protected ExtensibleParser.BuildingStrategy forUnkeyedListEntry() { + return new BaseDispatcherParser.SimpleBuildingStrategy<>(); + } + + protected ExtensibleParser.BuildingStrategy forUnkeyedList() { + return new ListNodeBaseParser.SimpleListNodeBuildingStrategy<>(); + } + + protected ExtensibleParser.BuildingStrategy forChoice() { + return new BaseDispatcherParser.SimpleBuildingStrategy<>(); + } + + public ExtensibleParser.BuildingStrategy forAugmentation() { + return new BaseDispatcherParser.SimpleBuildingStrategy<>(); + } + } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/LeafNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/LeafNodeDomParser.java index 2e8ab87bd7..25b57ccf08 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/LeafNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/LeafNodeDomParser.java @@ -7,9 +7,11 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import com.google.common.base.Preconditions; import java.util.Map; - import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.LeafNodeBaseParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils; @@ -17,8 +19,6 @@ import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.w3c.dom.Element; -import com.google.common.base.Preconditions; - final class LeafNodeDomParser extends LeafNodeBaseParser { private final XmlCodecProvider codecProvider; @@ -29,6 +29,12 @@ final class LeafNodeDomParser extends LeafNodeBaseParser { this.codecProvider = Preconditions.checkNotNull(codecProvider); } + LeafNodeDomParser(XmlCodecProvider codecProvider, final SchemaContext schema, final BuildingStrategy> strategy) { + super(strategy); + this.ctx = schema; + this.codecProvider = Preconditions.checkNotNull(codecProvider); + } + @Deprecated LeafNodeDomParser(XmlCodecProvider codecProvider) { this(codecProvider, null); @@ -43,4 +49,5 @@ final class LeafNodeDomParser extends LeafNodeBaseParser { protected Map getAttributes(Element element) { return DomUtils.toAttributes(element.getAttributes()); } + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/LeafSetEntryNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/LeafSetEntryNodeDomParser.java index 0458cd5d10..decf901337 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/LeafSetEntryNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/LeafSetEntryNodeDomParser.java @@ -7,9 +7,11 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import com.google.common.base.Preconditions; import java.util.Map; - import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.LeafSetEntryNodeBaseParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils; @@ -17,15 +19,19 @@ import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.w3c.dom.Element; -import com.google.common.base.Preconditions; - final class LeafSetEntryNodeDomParser extends LeafSetEntryNodeBaseParser { private final XmlCodecProvider codecProvider; private final SchemaContext ctx; - LeafSetEntryNodeDomParser(XmlCodecProvider codecProvider, final SchemaContext schema) { - ctx = schema; + LeafSetEntryNodeDomParser(final XmlCodecProvider codecProvider, final SchemaContext schema) { + this.ctx = schema; + this.codecProvider = Preconditions.checkNotNull(codecProvider); + } + + LeafSetEntryNodeDomParser(final XmlCodecProvider codecProvider, final SchemaContext schema, final BuildingStrategy> strategy) { + super(strategy); + this.ctx = schema; this.codecProvider = Preconditions.checkNotNull(codecProvider); } @@ -43,4 +49,5 @@ final class LeafSetEntryNodeDomParser extends LeafSetEntryNodeBaseParser getAttributes(Element element) { return DomUtils.toAttributes(element.getAttributes()); } + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ListEntryNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ListEntryNodeDomParser.java index 92496d79f7..90aca17fd8 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ListEntryNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/ListEntryNodeDomParser.java @@ -11,13 +11,14 @@ import com.google.common.base.Preconditions; import com.google.common.collect.LinkedListMultimap; import java.util.Map; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ListEntryNodeBaseParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher; import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils; import org.w3c.dom.Element; -abstract class ListEntryNodeDomParser> extends ListEntryNodeBaseParser { +abstract class ListEntryNodeDomParser

> extends ListEntryNodeBaseParser { private final NodeParserDispatcher dispatcher; @@ -25,6 +26,11 @@ abstract class ListEntryNodeDomParser> extends Li this.dispatcher = Preconditions.checkNotNull(dispatcher); } + ListEntryNodeDomParser(final BuildingStrategy buildingStrategy, final NodeParserDispatcher dispatcher) { + super(buildingStrategy); + this.dispatcher = dispatcher; + } + @Override protected LinkedListMultimap mapChildElements(Iterable elements) { return DomUtils.mapChildElementsForSingletonNode(elements.iterator().next()); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/MapEntryNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/MapEntryNodeDomParser.java index a6c467c222..05a086476c 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/MapEntryNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/MapEntryNodeDomParser.java @@ -15,12 +15,14 @@ import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.No import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.w3c.dom.Element; -final class MapEntryNodeDomParser extends ListEntryNodeDomParser { +final class MapEntryNodeDomParser extends ListEntryNodeDomParser { private final boolean strictParsing; MapEntryNodeDomParser(final NodeParserDispatcher dispatcher) { super(dispatcher); + // TODO strict parsing attribute should be injected into superclass via a constructor + // WIth current approach (getter) we have to call super.strictParsing in constructor and cannot reuse constructors this.strictParsing = super.strictParsing(); } @@ -29,6 +31,12 @@ final class MapEntryNodeDomParser extends ListEntryNodeDomParser { this.strictParsing = strictParsing; } + MapEntryNodeDomParser(final NodeParserDispatcher dispatcher, final BuildingStrategy strategy, + final boolean strictParsing) { + super(strategy, dispatcher); + this.strictParsing = strictParsing; + } + @Override protected final DataContainerNodeBuilder getBuilder( ListSchemaNode schema) { diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/MapNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/MapNodeDomParser.java index 748564fdd1..0f1c822ae1 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/MapNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/MapNodeDomParser.java @@ -7,7 +7,9 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; +import org.opendaylight.yangtools.yang.data.api.schema.MapNode; import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.MapNodeBaseParser; import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; @@ -17,7 +19,12 @@ final class MapNodeDomParser extends MapNodeBaseParser { private final MapEntryNodeDomParser mapEntryParser; - MapNodeDomParser(MapEntryNodeDomParser mapEntryParser) { + MapNodeDomParser(final MapEntryNodeDomParser mapEntryParser) { + this.mapEntryParser = mapEntryParser; + } + + MapNodeDomParser(MapEntryNodeDomParser mapEntryParser, final BuildingStrategy strategy) { + super(strategy); this.mapEntryParser = mapEntryParser; } @@ -25,4 +32,5 @@ final class MapNodeDomParser extends MapNodeBaseParser { protected ToNormalizedNodeParser getListEntryNodeParser() { return mapEntryParser; } + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/OrderedListNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/OrderedListNodeDomParser.java index 787bff8856..920c30f342 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/OrderedListNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/OrderedListNodeDomParser.java @@ -7,7 +7,9 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; +import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode; import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.OrderedListNodeBaseParser; import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; @@ -17,7 +19,12 @@ final class OrderedListNodeDomParser extends OrderedListNodeBaseParser private final MapEntryNodeDomParser mapEntryNodeParser; - OrderedListNodeDomParser(MapEntryNodeDomParser mapEntryNodeParser) { + OrderedListNodeDomParser(final MapEntryNodeDomParser mapEntryNodeParser) { + this.mapEntryNodeParser = mapEntryNodeParser; + } + + OrderedListNodeDomParser(MapEntryNodeDomParser mapEntryNodeParser, final BuildingStrategy strategy) { + super(strategy); this.mapEntryNodeParser = mapEntryNodeParser; } @@ -25,4 +32,5 @@ final class OrderedListNodeDomParser extends OrderedListNodeBaseParser protected ToNormalizedNodeParser getListEntryNodeParser() { return mapEntryNodeParser; } + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/UnkeyedListEntryNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/UnkeyedListEntryNodeDomParser.java index 781f06cb71..79d478fb47 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/UnkeyedListEntryNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/UnkeyedListEntryNodeDomParser.java @@ -16,12 +16,16 @@ import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.No import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.w3c.dom.Element; -final class UnkeyedListEntryNodeDomParser extends ListEntryNodeDomParser { +final class UnkeyedListEntryNodeDomParser extends ListEntryNodeDomParser { UnkeyedListEntryNodeDomParser(final NodeParserDispatcher dispatcher) { super(dispatcher); } + UnkeyedListEntryNodeDomParser(final BuildingStrategy buildingStrategy, final NodeParserDispatcher dispatcher) { + super(buildingStrategy, dispatcher); + } + @Override protected final DataContainerNodeBuilder getBuilder( ListSchemaNode schema) { diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/UnkeyedListNodeDomParser.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/UnkeyedListNodeDomParser.java index 15eed32a2d..21ec64e5a5 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/UnkeyedListNodeDomParser.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/parser/UnkeyedListNodeDomParser.java @@ -7,7 +7,9 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode; +import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode; import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser; import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.UnkeyedListNodeBaseParser; import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; @@ -21,8 +23,14 @@ final class UnkeyedListNodeDomParser extends UnkeyedListNodeBaseParser this.unkeyedListEntryNodeParser = unkeyedListEntryNodeParser; } + UnkeyedListNodeDomParser(final BuildingStrategy buildingStrategy, final UnkeyedListEntryNodeDomParser unkeyedListEntryNodeParser) { + super(buildingStrategy); + this.unkeyedListEntryNodeParser = unkeyedListEntryNodeParser; + } + @Override protected ToNormalizedNodeParser getListEntryNodeParser() { return unkeyedListEntryNodeParser; } + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java index 93e0e671ed..6c947843cc 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java @@ -118,7 +118,7 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida return Verify.verifyNotNull(mod.getModificationType(), "Node %s does not have resolved modification type", mod); } - private Optional> optionalData(final TreeNode meta) { + private static Optional> optionalData(final TreeNode meta) { if (meta != null) { return Optional.>of(meta.getData()); } else { diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractReadyIterator.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractReadyIterator.java new file mode 100644 index 0000000000..5591192249 --- /dev/null +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractReadyIterator.java @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.data.impl.schema.tree; + +import com.google.common.base.Preconditions; +import java.util.Collection; +import java.util.Iterator; + +abstract class AbstractReadyIterator { + final Iterator children; + final ModifiedNode node; + + private AbstractReadyIterator(final ModifiedNode node, final Iterator children) { + this.children = Preconditions.checkNotNull(children); + this.node = Preconditions.checkNotNull(node); + } + + static AbstractReadyIterator create(final ModifiedNode root) { + return new RootReadyIterator(root, root.getChildren().iterator()); + } + + final AbstractReadyIterator process() { + // Walk all child nodes and remove any children which have not + // been modified. If a child + while (children.hasNext()) { + final ModifiedNode child = children.next(); + final Collection grandChildren = child.getChildren(); + if (grandChildren.isEmpty()) { + child.seal(); + if (child.getOperation() == LogicalOperation.NONE) { + children.remove(); + } + } else { + return new NestedReadyIterator(this, child, grandChildren.iterator()); + } + } + + node.seal(); + + // Remove from parent if we have one and this is a no-op + if (node.getOperation() == LogicalOperation.NONE) { + removeFromParent(); + } + return getParent(); + } + + abstract AbstractReadyIterator getParent(); + abstract void removeFromParent(); + + private static final class NestedReadyIterator extends AbstractReadyIterator { + private final AbstractReadyIterator parent; + + private NestedReadyIterator(final AbstractReadyIterator parent, final ModifiedNode node, final Iterator children) { + super(node, children); + this.parent = Preconditions.checkNotNull(parent); + } + + @Override + AbstractReadyIterator getParent() { + return parent; + } + + @Override + void removeFromParent() { + parent.children.remove(); + } + } + + private static final class RootReadyIterator extends AbstractReadyIterator { + private RootReadyIterator(final ModifiedNode node, final Iterator children) { + super(node, children); + } + + @Override + AbstractReadyIterator getParent() { + return null; + } + + @Override + void removeFromParent() { + // No-op, since root node cannot be removed + } + } + +} \ No newline at end of file diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/InMemoryDataTreeModification.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/InMemoryDataTreeModification.java index 2dda1b3f65..f86c71249b 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/InMemoryDataTreeModification.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/InMemoryDataTreeModification.java @@ -148,7 +148,7 @@ final class InMemoryDataTreeModification implements DataTreeModification { ModifiedNode modification = rootNode; int i = 1; - for(PathArgument pathArg : path.getPathArguments()) { + for (PathArgument pathArg : path.getPathArguments()) { Optional potential = operation.getChild(pathArg); if (!potential.isPresent()) { throw new IllegalArgumentException(String.format("Child %s is not present in schema tree.", @@ -163,14 +163,6 @@ final class InMemoryDataTreeModification implements DataTreeModification { return OperationWithModification.from(operation, modification); } - @Override - public void ready() { - final boolean wasRunning = UPDATER.compareAndSet(this, 0, 1); - Preconditions.checkState(wasRunning, "Attempted to seal an already-sealed Data Tree."); - - rootNode.seal(); - } - private void checkSealed() { Preconditions.checkState(sealed == 0, "Data Tree is sealed. No further modifications allowed."); } @@ -248,4 +240,16 @@ final class InMemoryDataTreeModification implements DataTreeModification { applyNode(cursor, child); } } + + @Override + public void ready() { + final boolean wasRunning = UPDATER.compareAndSet(this, 0, 1); + Preconditions.checkState(wasRunning, "Attempted to seal an already-sealed Data Tree."); + + AbstractReadyIterator current = AbstractReadyIterator.create(rootNode); + do { + current = current.process(); + } while (current != null); + } + } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/MinMaxElementsValidation.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/MinMaxElementsValidation.java index 306d9c8581..525ff55612 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/MinMaxElementsValidation.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/MinMaxElementsValidation.java @@ -37,7 +37,7 @@ final class MinMaxElementsValidation extends SchemaAwareApplyOperation { this.maxElements = maxElements; } - static final SchemaAwareApplyOperation from(final SchemaAwareApplyOperation delegate, final DataSchemaNode schema) { + static SchemaAwareApplyOperation from(final SchemaAwareApplyOperation delegate, final DataSchemaNode schema) { final ConstraintDefinition constraints = schema.getConstraints(); if (constraints == null || (constraints.getMinElements() == null && constraints.getMaxElements() == null)) { return delegate; @@ -46,6 +46,22 @@ final class MinMaxElementsValidation extends SchemaAwareApplyOperation { } + private static int findChildrenBefore(final Optional current) { + if (current.isPresent()) { + return numOfChildrenFromValue(current.get().getData()); + } else { + return 0; + } + } + + private static int findChildrenAfter(final ModifiedNode modification) { + if (modification.getWrittenValue() != null) { + return numOfChildrenFromValue(modification.getWrittenValue()); + } else { + return 0; + } + } + private void checkMinMaxElements(final YangInstanceIdentifier path, final NodeModification nodeMod, final Optional current) throws DataValidationFailedException { if (!(nodeMod instanceof ModifiedNode)) { @@ -53,19 +69,10 @@ final class MinMaxElementsValidation extends SchemaAwareApplyOperation { return; } final ModifiedNode modification = (ModifiedNode) nodeMod; - final int childrenBefore; - if (current.isPresent()) { - childrenBefore = numOfChildrenFromValue(current.get().getData()); - } else { - childrenBefore = 0; - } - final int childrenAfter; - if (modification.getWrittenValue() != null) { - childrenAfter = numOfChildrenFromValue(modification.getWrittenValue()); - } else { - childrenAfter = 0; - } + final int childrenBefore = findChildrenBefore(current); + + final int childrenAfter = findChildrenAfter(modification); final int childrenTotal = childrenBefore + childrenAfter + numOfChildrenFromChildMods(modification, current); if (minElements != null && minElements > childrenTotal) { diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java index dbb1f41920..cdd5de01db 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java @@ -13,7 +13,6 @@ import com.google.common.base.Predicate; import java.util.Collection; import java.util.Collections; import java.util.HashMap; -import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; import javax.annotation.Nonnull; @@ -233,24 +232,11 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode it = children.values().iterator(); - while (it.hasNext()) { - final ModifiedNode child = it.next(); - child.seal(); - - if (child.operation == LogicalOperation.NONE) { - it.remove(); - } - } - // A TOUCH node without any children is a no-op if (operation == LogicalOperation.TOUCH && children.isEmpty()) { updateOperationType(LogicalOperation.NONE); diff --git a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlStreamUtilsTest.java b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlStreamUtilsTest.java index 817afccc6a..a95366ae15 100644 --- a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlStreamUtilsTest.java +++ b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XmlStreamUtilsTest.java @@ -11,7 +11,6 @@ package org.opendaylight.yangtools.yang.data.impl.codec.xml; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; - import com.google.common.base.Optional; import com.google.common.collect.Maps; import java.io.ByteArrayOutputStream; @@ -143,7 +142,7 @@ public class XmlStreamUtilsTest { return targetBaseType; } - private Map mapPrefixed(final Iterable> prefixes) { + private static Map mapPrefixed(final Iterable> prefixes) { final Map mappedPrefixes = Maps.newHashMap(); for (final Map.Entry prefix : prefixes) { mappedPrefixes.put(prefix.getKey().toString(), prefix.getValue()); @@ -151,9 +150,8 @@ public class XmlStreamUtilsTest { return mappedPrefixes; } - private QName getAttrQName(final String namespace, final String revision, final String localName, final Optional prefix) { - - if(prefix.isPresent()) { + private static QName getAttrQName(final String namespace, final String revision, final String localName, final Optional prefix) { + if (prefix.isPresent()) { final QName moduleQName = QName.create(namespace, revision, "module"); final QNameModule module = QNameModule.create(moduleQName.getNamespace(), moduleQName.getRevision()); return QName.create(module, localName); @@ -179,7 +177,7 @@ public class XmlStreamUtilsTest { return null; } - private LeafrefTypeDefinition findLeafrefType(final LeafSchemaNode schemaNode) { + private static LeafrefTypeDefinition findLeafrefType(final LeafSchemaNode schemaNode) { final TypeDefinition type = schemaNode.getType(); if (type instanceof LeafrefTypeDefinition) { return (LeafrefTypeDefinition)type; diff --git a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/NormalizedDataBuilderTest.java b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/NormalizedDataBuilderTest.java index 9c69016e19..71440c23a9 100644 --- a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/NormalizedDataBuilderTest.java +++ b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/NormalizedDataBuilderTest.java @@ -185,7 +185,7 @@ public class NormalizedDataBuilderTest { // .build()); } - private AugmentationSchema getAugmentationSchemaForChild(final ContainerSchemaNode containerNode, final QName qName) { + private static AugmentationSchema getAugmentationSchemaForChild(final ContainerSchemaNode containerNode, final QName qName) { for (AugmentationSchema augmentationSchema : containerNode.getAvailableAugmentations()) { if (augmentationSchema.getDataChildByName(qName) != null) { return augmentationSchema; @@ -194,16 +194,16 @@ public class NormalizedDataBuilderTest { throw new IllegalStateException("Unable to find child augmentation in " + containerNode); } - private YangInstanceIdentifier.NodeWithValue getNodeWithValueIdentifier(final String localName, final Object value) { + private static YangInstanceIdentifier.NodeWithValue getNodeWithValueIdentifier(final String localName, final Object value) { return new YangInstanceIdentifier.NodeWithValue(getQName(localName), value); } - private QName getQName(final String localName) { + private static QName getQName(final String localName) { String namespace = "namespace"; return new QName(URI.create(namespace), localName); } - private YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName) { + private static YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName) { return new YangInstanceIdentifier.NodeIdentifier(getQName(localName)); } diff --git a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/serializer/NormalizedNodeXmlTranslationTest.java b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/serializer/NormalizedNodeXmlTranslationTest.java index 30a9db0fbf..63962eb910 100644 --- a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/serializer/NormalizedNodeXmlTranslationTest.java +++ b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/transform/dom/serializer/NormalizedNodeXmlTranslationTest.java @@ -278,7 +278,7 @@ public class NormalizedNodeXmlTranslationTest { XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false); } - private void writeNormalizedNode(final NormalizedNode normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext context) + private static void writeNormalizedNode(final NormalizedNode normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext context) throws IOException, XMLStreamException { NormalizedNodeWriter normalizedNodeWriter = null; NormalizedNodeStreamWriter normalizedNodeStreamWriter = null; @@ -304,7 +304,7 @@ public class NormalizedNodeXmlTranslationTest { } } - private Document loadDocument(final String xmlPath) throws Exception { + private static Document loadDocument(final String xmlPath) throws IOException, SAXException { final InputStream resourceAsStream = NormalizedDataBuilderTest.class.getResourceAsStream(xmlPath); final Document currentConfigElement = readXmlToDocument(resourceAsStream); @@ -323,7 +323,7 @@ public class NormalizedNodeXmlTranslationTest { BUILDERFACTORY = factory; } - private Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException { + private static Document readXmlToDocument(final InputStream xmlContent) throws IOException, SAXException { final DocumentBuilder dBuilder; try { dBuilder = BUILDERFACTORY.newDocumentBuilder(); diff --git a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ConcurrentTreeModificationTest.java b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ConcurrentTreeModificationTest.java index 6812122eb4..fade795913 100644 --- a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ConcurrentTreeModificationTest.java +++ b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ConcurrentTreeModificationTest.java @@ -60,7 +60,7 @@ public class ConcurrentTreeModificationTest { inMemoryDataTree.setSchemaContext(schemaContext); } - private ContainerNode createFooTestContainerNode() { + private static ContainerNode createFooTestContainerNode() { return ImmutableContainerNodeBuilder .create() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)) @@ -69,7 +69,7 @@ public class ConcurrentTreeModificationTest { .withChild(FOO_NODE).build()).build(); } - private ContainerNode createBarTestContainerNode() { + private static ContainerNode createBarTestContainerNode() { return ImmutableContainerNodeBuilder .create() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)) diff --git a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModificationMetadataTreeTest.java b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModificationMetadataTreeTest.java index 2896675c15..294bd9323c 100644 --- a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModificationMetadataTreeTest.java +++ b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModificationMetadataTreeTest.java @@ -15,7 +15,7 @@ import static org.junit.Assert.assertTrue; import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry; import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder; import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder; - +import com.google.common.base.Optional; import org.junit.Before; import org.junit.Test; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -32,13 +32,6 @@ import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder; import org.opendaylight.yangtools.yang.model.api.SchemaContext; -import com.google.common.base.Optional; - - - - - - /** * * Schema structure of document is @@ -133,7 +126,7 @@ public class ModificationMetadataTreeTest { } - private ContainerNode createTestContainer() { + private static ContainerNode createTestContainer() { return ImmutableContainerNodeBuilder .create() .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME)) diff --git a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/StoreTreeNodesTest.java b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/StoreTreeNodesTest.java index 20b35b3469..54dff7c1bd 100644 --- a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/StoreTreeNodesTest.java +++ b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/StoreTreeNodesTest.java @@ -78,7 +78,7 @@ public class StoreTreeNodesTest { } - private ContainerNode createTestContainer() { + private static ContainerNode createTestContainer() { return ImmutableContainerNodeBuilder .create() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)) diff --git a/yang/yang-data-operations/src/test/java/org/opendaylight/yangtools/yang/data/operations/YangDataOperationsTest.java b/yang/yang-data-operations/src/test/java/org/opendaylight/yangtools/yang/data/operations/YangDataOperationsTest.java index f05db1e5da..2fd5694c01 100644 --- a/yang/yang-data-operations/src/test/java/org/opendaylight/yangtools/yang/data/operations/YangDataOperationsTest.java +++ b/yang/yang-data-operations/src/test/java/org/opendaylight/yangtools/yang/data/operations/YangDataOperationsTest.java @@ -178,7 +178,7 @@ public class YangDataOperationsTest { Document currentConfigElement = readXmlToDocument(resourceAsStream); Preconditions.checkNotNull(currentConfigElement); - return Optional.of(DomToNormalizedNodeParserFactory.getInstance(DomUtils.defaultValueCodecProvider(), schema).getContainerNodeParser().parse( + return Optional.fromNullable(DomToNormalizedNodeParserFactory.getInstance(DomUtils.defaultValueCodecProvider(), schema).getContainerNodeParser().parse( Collections.singletonList(currentConfigElement.getDocumentElement()), containerNode)); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AnyXmlEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AnyXmlEffectiveStatementImpl.java index 07e503e76b..b2f469cb1b 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AnyXmlEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AnyXmlEffectiveStatementImpl.java @@ -131,32 +131,58 @@ public class AnyXmlEffectiveStatementImpl extends return result; } + private boolean checkQname(AnyXmlEffectiveStatementImpl other) { + if (qname == null) { + if (other.qname != null) { + return false; + } + } else if (!qname.equals(other.qname)) { + return false; + } + return true; + } + + private boolean checkPath(AnyXmlEffectiveStatementImpl other) { + if (path == null) { + if (other.path != null) { + return false; + } + } else if (!path.equals(other.path)) { + return false; + } + return true; + } + + private boolean checkObject(final Object obj) { + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + return true; + } + @Override public boolean equals(final Object obj) { if (this == obj) { return true; } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; + + if (!checkObject(obj)) { + return false; } + AnyXmlEffectiveStatementImpl other = (AnyXmlEffectiveStatementImpl) obj; - if (qname == null) { - if (other.qname != null) { - return false; - } - } else if (!qname.equals(other.qname)) { + + if (!checkQname(other)) { return false; } - if (path == null) { - if (other.path != null) { - return false; - } - } else if (!path.equals(other.path)) { + + if (!checkPath(other)) { return false; } + return true; } @@ -171,4 +197,4 @@ public class AnyXmlEffectiveStatementImpl extends return sb.toString(); } -} \ No newline at end of file +}