+++ /dev/null
-/*
- * 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.parser.spi.meta;
-
-import com.google.common.base.Preconditions;
-import java.util.Map;
-import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
-
-public abstract class DerivedNamespaceBehaviour<K, V, N extends IdentifierNamespace<K, V>, T extends IdentifierNamespace<?, ?>>
- extends NamespaceBehaviour<K, V, N> {
-
- private Class<T> derivedFrom;
-
- protected DerivedNamespaceBehaviour(Class<N> identifier, Class<T> derivedFrom) {
- super(identifier);
- this.derivedFrom = Preconditions.checkNotNull(derivedFrom);
- }
-
- public Class<T> getDerivedFrom() {
- return derivedFrom;
- }
-
- @Override
- public Map<K, V> getAllFrom(NamespaceStorageNode storage) {
- throw new UnsupportedOperationException("Virtual namespaces does not support provision of all items.");
- }
-
- @Override
- public abstract V getFrom(NamespaceBehaviour.NamespaceStorageNode storage, K key);
-
- @Override
- public void addTo(NamespaceStorageNode storage, K key, V value) {
- // Intentional noop
- }
-}
@Nonnull <T extends Mutable<?,?,?>> Prerequisite<T> mutatesEffectiveCtx(T stmt);
- @Nonnull <K,E extends EffectiveStatement<?,?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>> Prerequisite<Mutable<?,?,E>> mutatesEffectiveCtx(StmtContext<?,?,?> context,Class<N> namespace, K key);
+ @Nonnull <K,E extends EffectiveStatement<?,?>,N extends StatementNamespace<K, ?, ? extends E>> Prerequisite<Mutable<?,?,E>> mutatesEffectiveCtx(StmtContext<?,?,?> context,Class<N> namespace, K key);
void apply(InferenceAction action) throws InferenceException;
public abstract class NamespaceBehaviour<K, V, N extends IdentifierNamespace<K, V>> implements Identifiable<Class<N>> {
public enum StorageNodeType {
- GLOBAL, SOURCE_LOCAL_SPECIAL, STATEMENT_LOCAL, ROOT_STATEMENT_LOCAL
+ GLOBAL, SOURCE_LOCAL_SPECIAL, STATEMENT_LOCAL,
}
public interface Registry {
@Override
public V getFrom(final NamespaceStorageNode storage, final K key) {
- NamespaceStorageNode current = findClosestTowardsRoot(storage, storageType);
+ NamespaceStorageNode current = storage;
+ while (current.getStorageNodeType() != storageType) {
+ current = current.getParentNamespaceStorage();
+ }
return getFromLocalStorage(current, key);
}
@Override
public void addTo(NamespaceBehaviour.NamespaceStorageNode storage, K key, V value) {
- NamespaceStorageNode current = findClosestTowardsRoot(storage, storageType);
+ NamespaceStorageNode current = storage;
+ while (current.getStorageNodeType() != storageType) {
+ current = current.getParentNamespaceStorage();
+ }
addToStorage(current, key, value);
}
}
}
-
- protected static NamespaceStorageNode findClosestTowardsRoot(NamespaceStorageNode storage, StorageNodeType type) {
- NamespaceStorageNode current = storage;
- while(current != null && current.getStorageNodeType() != type) {
- current = current.getParentNamespaceStorage();
- }
- return current;
- }
}
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
-import com.google.common.base.Verify;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedNamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
if (potential == null) {
NamespaceBehaviour<K, V, N> potentialRaw = supports.get(currentPhase).getNamespaceBehaviour(type);
if(potentialRaw != null) {
- potential = createNamespaceContext(potentialRaw);
+ potential = new NamespaceBehaviourWithListeners<>(potentialRaw);
supportedNamespaces.put(type, potential);
- } else {
- throw new NamespaceNotAvailableException(
- "Namespace " + type + " is not available in phase " + currentPhase);
}
}
+ if (potential != null) {
+ Preconditions.checkState(type.equals(potential.getIdentifier()));
- Verify.verify(type.equals(potential.getIdentifier()));
/*
- * Safe cast, previous checkState checks equivalence of key from which type argument are
- * derived
- */
- return (NamespaceBehaviourWithListeners<K, V, N>) potential;
- }
-
- @SuppressWarnings({"unchecked", "rawtypes"})
- private <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> createNamespaceContext(
- NamespaceBehaviour<K, V, N> potentialRaw) {
- if (potentialRaw instanceof DerivedNamespaceBehaviour) {
- VirtualNamespaceContext derivedContext =
- new VirtualNamespaceContext<>(potentialRaw);
- getNamespaceBehaviour(((DerivedNamespaceBehaviour) potentialRaw).getDerivedFrom())
- .addDerivedNamespace(derivedContext);
- return derivedContext;
+ * Safe cast, previous checkState checks equivalence of key from
+ * which type argument are derived
+ */
+ return (NamespaceBehaviourWithListeners<K, V, N>) potential;
}
- return new SimpleNamespaceContext<>(potentialRaw);
+ throw new NamespaceNotAvailableException("Namespace " + type + " is not available in phase " + currentPhase);
}
public StatementDefinitionContext<?, ?, ?> getStatementDefinition(final QName name) {
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.EFFECTIVE_MODEL;
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.FULL_DECLARATION;
-
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import java.util.HashSet;
return new IllegalStateException("Source exception during registering prerequisite. This is probably bug.",e);
}
+ private void tryToResolve() throws InferenceException {
+ if(action == null || isApplied()) {
+ // Action was not yet defined
+ return;
+ }
+ if(removeSatisfied()) {
+ applyAction();
+ }
+ }
+
private boolean removeSatisfied() {
Iterator<AbstractPrerequisite<?>> prereq = unsatisfied.iterator();
boolean allSatisfied = true;
}
private void applyAction() throws InferenceException {
- Preconditions.checkState(!actionApplied);
- action.apply();
+
+ try {
+ action.apply();
+ } catch (InferenceException e) {
+ actionApplied = false;
+ return;
+ }
+ // Mark all mutations as performed, so context node could move to next.
actionApplied = true;
}
}
@SuppressWarnings({ "rawtypes", "unchecked" })
- private <K, C extends StmtContext.Mutable<?, ?, ?> , N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>> AbstractPrerequisite<C> mutatesCtxImpl(
+ private <K, C extends StmtContext.Mutable<?, ?, ?> , N extends StatementNamespace<K, ?, ? >> AbstractPrerequisite<C> mutatesCtxImpl(
final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key, final ModelProcessingPhase phase) {
try {
PhaseModificationInNamespace<C> mod = new PhaseModificationInNamespace<C>(phase);
- addReq(mod);
addMutation(mod);
contextImpl(context).onNamespaceItemAddedAction((Class) namespace,key,mod);
return mod;
}
}
- private static StatementContextBase<?,?,?> contextImpl(final Object value) {
- Preconditions.checkArgument(value instanceof StatementContextBase,"Supplied context was not provided by this reactor.");
- return StatementContextBase.class.cast(value);
- }
-
- boolean tryApply() {
- Preconditions.checkState(action != null, "Action was not defined yet.");
-
- if (removeSatisfied()) {
- applyAction();
- return true;
- }
- return false;
+ private static StatementContextBase<?,?,?> contextImpl(final StmtContext<?,?,?> context) {
+ Preconditions.checkArgument(context instanceof StatementContextBase,"Supplied context was not provided by this reactor.");
+ return StatementContextBase.class.cast(context);
}
@Override
@Override
- public <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>> AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(
+ public <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>> AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(
final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) {
return mutatesCtxImpl(context, namespace, key, EFFECTIVE_MODEL);
}
@Override
public void apply(final InferenceAction action) throws InferenceException {
this.action = Preconditions.checkNotNull(action);
+ tryToResolve();
}
private abstract class AbstractPrerequisite<T> implements Prerequisite<T> {
protected boolean resolvePrereq(final T value) throws InferenceException {
this.value = value;
this.done = true;
+ tryToResolve();
return isApplied();
}
@Override
public void namespaceItemAdded(final StatementContextBase<?, ?, ?> context, final Class<?> namespace, final Object key,
final Object value) throws SourceException {
- StatementContextBase<?, ?, ?> targetCtx = contextImpl(value);
- targetCtx.addMutation(modPhase,this);
- resolvePrereq((C) targetCtx);
+ context.addMutation(modPhase,this);
+ resolvePrereq((C) context);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
-import java.util.ArrayList;
+import com.google.common.base.Optional;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import java.util.Collection;
import java.util.Iterator;
-import java.util.List;
import java.util.Map;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleIdentifierImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
-abstract class NamespaceBehaviourWithListeners<K, V, N extends IdentifierNamespace<K, V>>
- extends NamespaceBehaviour<K, V, N> {
+final class NamespaceBehaviourWithListeners<K,V, N extends IdentifierNamespace<K, V>> extends NamespaceBehaviour<K, V, N> {
- abstract static class ValueAddedListener<K> {
+ abstract static class ValueAddedListener {
private final NamespaceStorageNode ctxNode;
- private K key;
- public ValueAddedListener(final NamespaceStorageNode contextNode, K key) {
+ public ValueAddedListener(final NamespaceStorageNode contextNode) {
this.ctxNode = contextNode;
- this.key = key;
- }
-
- public NamespaceStorageNode getCtxNode() {
- return ctxNode;
- }
-
- public K getKey() {
- return key;
}
abstract void onValueAdded(Object key, Object value);
}
private final NamespaceBehaviour<K, V, N> delegate;
- private final List<VirtualNamespaceContext<?, V, ?>> derivedNamespaces = new ArrayList<>();
-
+ private final Multimap<K, ValueAddedListener> listeners = HashMultimap.create();
protected NamespaceBehaviourWithListeners(final NamespaceBehaviour<K, V, N> delegate) {
super(delegate.getIdentifier());
this.delegate = delegate;
}
- protected abstract void addListener(K key, ValueAddedListener<K> listener);
-
- protected abstract Iterator<ValueAddedListener<K>> getMutableListeners(K key);
-
- protected abstract boolean isRequestedValue(ValueAddedListener<K> listener, NamespaceStorageNode storage, V value);
-
@Override
public void addTo(final NamespaceStorageNode storage, final K key, final V value) {
delegate.addTo(storage, key, value);
- Iterator<ValueAddedListener<K>> keyListeners = getMutableListeners(key);
- List<ValueAddedListener<K>> toNotify = new ArrayList<>();
+ Iterator<ValueAddedListener> keyListeners = listeners.get(key).iterator();
while (keyListeners.hasNext()) {
- ValueAddedListener<K> listener = keyListeners.next();
- if (isRequestedValue(listener, storage, value)) {
+ ValueAddedListener listener = keyListeners.next();
+ if (listener.ctxNode == storage || hasIdentiticalValue(listener.ctxNode,key,value)) {
keyListeners.remove();
- toNotify.add(listener);
+ listener.onValueAdded(key, value);
}
}
- for(ValueAddedListener<K> listener : toNotify) {
- listener.onValueAdded(key, value);
- }
- for (VirtualNamespaceContext<?, V, ?> derived : derivedNamespaces) {
- derived.addTo(storage, null, value);
+
+ if (key instanceof ModuleIdentifier && !listeners.isEmpty()) {
+ Collection<ValueAddedListener> defaultImportListeners = getDefaultImportListeners((ModuleIdentifier) key);
+ Iterator<ValueAddedListener> defaultImportsIterator = defaultImportListeners.iterator();
+ while (defaultImportsIterator.hasNext()) {
+ ValueAddedListener listener = defaultImportsIterator.next();
+ if(listener.ctxNode == storage || hasIdentiticalValue(listener.ctxNode,key,value)) {
+ defaultImportsIterator.remove();
+ listener.onValueAdded(key, value);
+ }
+ }
}
}
- final void addValueListener(final ValueAddedListener<K> listener) {
- addListener(listener.key, listener);
+ private Collection<ValueAddedListener> getDefaultImportListeners(final ModuleIdentifier key) {
+ ModuleIdentifier defaultImportKey = new ModuleIdentifierImpl(key.getName(),
+ Optional.fromNullable(key.getNamespace()), Optional.of(SimpleDateFormatUtil.DEFAULT_DATE_IMP));
+ return listeners.get((K)defaultImportKey);
+ }
+
+ private boolean hasIdentiticalValue(final NamespaceStorageNode ctxNode, final K key, final V value) {
+ return getFrom(ctxNode, key) == value;
}
- final void addDerivedNamespace(VirtualNamespaceContext<?, V, ?> namespace) {
- derivedNamespaces.add(namespace);
+ void addValueListener(final K key, final ValueAddedListener listener) {
+ listeners.put(key, listener);
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.Registry;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
return sourceContext;
}
- @Override
- public StorageNodeType getStorageNodeType() {
- return StorageNodeType.ROOT_STATEMENT_LOCAL;
- }
/**
* @return this as its own root
*/
+++ /dev/null
-/*
- * 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.parser.stmt.reactor;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
-
-final class SimpleNamespaceContext<K, V, N extends IdentifierNamespace<K, V>>
- extends NamespaceBehaviourWithListeners<K, V, N> {
-
- // FIXME: Change this to Multimap, once issue with modules
- // is resolved.
- private final List<NamespaceBehaviourWithListeners.ValueAddedListener<K>> listeners = new ArrayList<>();
- public SimpleNamespaceContext(NamespaceBehaviour<K, V, N> delegate) {
- super(delegate);
- }
-
- protected boolean isRequestedValue(NamespaceBehaviourWithListeners.ValueAddedListener<K> listener, NamespaceStorageNode storage, V value) {
- NamespaceStorageNode listenerCtx = listener.getCtxNode();
- return value == getFrom(listenerCtx, listener.getKey());
- }
-
- @Override
- protected void addListener(K key, NamespaceBehaviourWithListeners.ValueAddedListener<K> listener) {
- listeners.add(listener);
- }
-
- @Override
- protected Iterator<NamespaceBehaviourWithListeners.ValueAddedListener<K>> getMutableListeners(K key) {
- return listeners.iterator();
- }
-}
\ No newline at end of file
PhaseCompletionProgress tryToCompletePhase(final ModelProcessingPhase phase) throws SourceException {
Collection<ModifierImpl> currentPhaseModifiers = modifiers.get(phase);
- boolean hasProgressed = tryToProgress(currentPhaseModifiers);
+ boolean hasProgressed = hasProgress(currentPhaseModifiers);
boolean phaseCompleted = root.tryToCompletePhase(phase);
- hasProgressed = (tryToProgress(currentPhaseModifiers) | hasProgressed);
+ hasProgressed = (hasProgress(currentPhaseModifiers) | hasProgressed);
if (phaseCompleted && (currentPhaseModifiers.isEmpty())) {
finishedPhase = phase;
}
- private static boolean tryToProgress(final Collection<ModifierImpl> currentPhaseModifiers) {
+ private static boolean hasProgress(final Collection<ModifierImpl> currentPhaseModifiers) {
Iterator<ModifierImpl> modifier = currentPhaseModifiers.iterator();
boolean hasProgressed = false;
while (modifier.hasNext()) {
- if (modifier.next().tryApply()) {
+ if (modifier.next().isApplied()) {
modifier.remove();
hasProgressed = true;
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
+import java.util.LinkedList;
+
+import java.util.List;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.collect.HashMultimap;
import java.util.EventListener;
import java.util.Iterator;
import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
import java.util.Map;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Identifiable;
NamespaceBehaviour<K, V, N> behaviour = getBehaviourRegistry().getNamespaceBehaviour(type);
if (behaviour instanceof NamespaceBehaviourWithListeners) {
NamespaceBehaviourWithListeners<K, V, N> casted = (NamespaceBehaviourWithListeners<K, V, N>) behaviour;
- casted.addValueListener(new ValueAddedListener<K>(this, key) {
+ casted.addValueListener(key, new ValueAddedListener(this) {
@Override
void onValueAdded(Object key, Object value) {
try {
} else {
this.argument = original.argument;
}
+
+ copyDeclaredStmts(original, newQNameModule, typeOfCopy);
+
+ copyEffectiveStmts(original, newQNameModule, typeOfCopy);
}
private void copyDeclaredStmts(SubstatementContext<A, D, E> original,
}
definition().onStatementAdded(copy);
-
- copy.copyDeclaredStmts(this, newQNameModule, typeOfCopy);
- copy.copyEffectiveStmts(this, newQNameModule, typeOfCopy);
return copy;
}
+++ /dev/null
-/*
- * 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.parser.stmt.reactor;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
-
-final class VirtualNamespaceContext<K, V, N extends IdentifierNamespace<K, V>>
- extends NamespaceBehaviourWithListeners<K, V, N> {
-
- private final List<NamespaceBehaviourWithListeners.ValueAddedListener<K>> listeners = new ArrayList<>(20);
-
- public VirtualNamespaceContext(NamespaceBehaviour<K, V, N> delegate) {
- super(delegate);
- }
-
- protected boolean isRequestedValue(NamespaceBehaviourWithListeners.ValueAddedListener<K> listener, NamespaceStorageNode storage, V value) {
- return value == getFrom(listener.getCtxNode(), listener.getKey());
- }
-
- @Override
- protected void addListener(K key, NamespaceBehaviourWithListeners.ValueAddedListener<K> listener) {
- listeners.add(listener);
- }
-
- @Override
- protected Iterator<NamespaceBehaviourWithListeners.ValueAddedListener<K>> getMutableListeners(K key) {
- return listeners.iterator();
- }
-}
\ No newline at end of file
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AugmentEffectiveStatementImpl;
}
final ModelActionBuilder augmentAction = augmentNode
- .newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
+ .newInferenceAction(ModelProcessingPhase.FULL_DECLARATION);
final ModelActionBuilder.Prerequisite<StmtContext<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>>> sourceCtxPrereq = augmentAction
- .requiresCtx(augmentNode, ModelProcessingPhase.EFFECTIVE_MODEL);
- final Prerequisite<Mutable<?, ?, EffectiveStatement<?, ?>>> target = augmentAction.mutatesEffectiveCtx(getSearchRoot(augmentNode), SchemaNodeIdentifierBuildNamespace.class, augmentNode.getStatementArgument());
+ .requiresCtx(augmentNode,
+ ModelProcessingPhase.FULL_DECLARATION);
+
augmentAction.apply(new ModelActionBuilder.InferenceAction() {
@Override
public void apply() throws InferenceException {
- final StatementContextBase<?, ?, ?> augmentTargetCtx = (StatementContextBase<?, ?, ?>) target.get();
+ final StatementContextBase<?, ?, ?> augmentTargetCtx = AugmentUtils
+ .getAugmentTargetCtx(augmentNode);
+
+ if (augmentTargetCtx == null) {
+ throw new InferenceException(
+ "Augment target not found: "
+ + augmentNode.getStatementArgument(),
+ augmentNode.getStatementSourceReference());
+ }
if (!AugmentUtils.isSupportedAugmentTarget(augmentTargetCtx) || StmtContextUtils.isInExtensionBody(augmentTargetCtx)) {
augmentNode.setIsSupportedToBuildEffective(false);
return;
}
+
final StatementContextBase<?, ?, ?> augmentSourceCtx = (StatementContextBase<?, ?, ?>) augmentNode;
+
try {
AugmentUtils.copyFromSourceToTarget(augmentSourceCtx,
augmentTargetCtx);
}
});
}
-
- private Mutable<?, ?, ?> getSearchRoot(Mutable<?, ?, ?> augmentContext) {
- Mutable<?, ?, ?> parent = augmentContext.getParentContext();
- // Augment is in uses - we need to augment instantiated nodes in parent.
- if(Rfc6020Mapping.USES.equals(parent.getPublicDefinition())) {
- return parent.getParentContext();
- }
- return parent;
- }
}
@Nonnull
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import java.util.ArrayList;
import java.util.Collection;
+import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.regex.Pattern;
+import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.NamespaceToModule;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
-// FIXME: Move this to the AugmentStatementDefinition#ApplyAction
public final class AugmentUtils {
+ private static final Logger LOG = LoggerFactory.getLogger(AugmentUtils.class);
private static final Pattern PATH_REL_PATTERN1 = Pattern.compile("\\.\\.?\\s*/(.+)");
private static final Pattern PATH_REL_PATTERN2 = Pattern.compile("//.*");
private AugmentUtils() {
+ throw new UnsupportedOperationException();
}
public static Iterable<QName> parseAugmentPath(final StmtContext<?, ?, ?> ctx, final String path) {
Preconditions.checkArgument(!PATH_REL_PATTERN1.matcher(path).matches()
&& !PATH_REL_PATTERN2.matcher(path).matches(),
- "An argument for augment can be only absolute path; or descendant if used in uses");
+ "An argument for augment can be only absolute path; or descendant if used in uses");
+
return Utils.parseXPath(ctx, path);
}
public static void copyFromSourceToTarget(final StatementContextBase<?, ?, ?> sourceCtx,
final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
+
copyDeclaredStmts(sourceCtx, targetCtx);
copyEffectiveStmts(sourceCtx, targetCtx);
}
- // FIXME: Declared statements should not be copied.
- private static void copyDeclaredStmts(final StatementContextBase<?, ?, ?> sourceCtx,
+ public static void copyDeclaredStmts(final StatementContextBase<?, ?, ?> sourceCtx,
final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
final List<StatementContextBase<?, ?, ?>> subStatements = new Builder<StatementContextBase<?, ?, ?>>()
}
}
- private static void copyEffectiveStmts(final StatementContextBase<?, ?, ?> sourceCtx,
+ public static void copyEffectiveStmts(final StatementContextBase<?, ?, ?> sourceCtx,
final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
final List<StatementContextBase<?, ?, ?>> subStatements = new Builder<StatementContextBase<?, ?, ?>>()
}
private static void validateNodeCanBeCopiedByAugment(final StatementContextBase<?, ?, ?> sourceCtx,
- final List<StatementContextBase<?, ?, ?>> targetSubStatements, final boolean sourceAndTargetInSameModule) {
+ final Iterable<StatementContextBase<?, ?, ?>> targetSubStatements,
+ final boolean sourceAndTargetInSameModule) {
- if (sourceCtx.getPublicDefinition().getDeclaredRepresentationClass().equals(WhenStatement.class)) {
+ if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) {
return;
}
if (!sourceAndTargetInSameModule) {
- final List<StatementContextBase<?, ?, ?>> sourceSubStatements = new Builder<StatementContextBase<?, ?, ?>>()
- .addAll(sourceCtx.declaredSubstatements()).addAll(sourceCtx.effectiveSubstatements()).build();
-
- for (final StatementContextBase<?, ?, ?> sourceSubStatement : sourceSubStatements) {
- if (sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass()
- .equals(MandatoryStatement.class)) {
- throw new IllegalArgumentException(
- String.format(
- "An augment cannot add node '%s' because it is mandatory and in module different from target",
- sourceCtx.rawStatementArgument()));
- }
+ for (final StatementContextBase<?, ?, ?> sourceSubStatement :
+ Iterables.concat(sourceCtx.declaredSubstatements(), sourceCtx.effectiveSubstatements())) {
+ Preconditions.checkArgument(!MandatoryStatement.class.equals(
+ sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass()),
+ "An augment cannot add node '%s' because it is mandatory and in module different from target",
+ sourceCtx.rawStatementArgument());
}
}
for (final StatementContextBase<?, ?, ?> subStatement : targetSubStatements) {
- final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx
- .getPublicDefinition().getDeclaredRepresentationClass());
- final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom(subStatement
- .getPublicDefinition().getDeclaredRepresentationClass());
- boolean qNamesEqual = sourceIsDataNode && targetIsDataNode
- && Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument());
-
- if (qNamesEqual) {
- throw new IllegalStateException(String.format(
- "An augment cannot add node named '%s' because this name is already used in target",
- sourceCtx.rawStatementArgument()));
+ final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(
+ sourceCtx.getPublicDefinition().getDeclaredRepresentationClass());
+ final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom(
+ subStatement.getPublicDefinition().getDeclaredRepresentationClass());
+ Preconditions.checkState(!sourceIsDataNode || !targetIsDataNode
+ || !Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument()),
+ "An augment cannot add node named '%s' because this name is already used in target",
+ sourceCtx.rawStatementArgument());
+ }
+ }
+
+ public static QNameModule getNewQNameModule(final StatementContextBase<?, ?, ?> targetCtx,
+ final StatementContextBase<?, ?, ?> sourceCtx) {
+ Object targetStmtArgument = targetCtx.getStatementArgument();
+
+ final StatementContextBase<?, ?, ?> root = sourceCtx.getRoot();
+ final QNameModule sourceQNameModule = root.getFromNamespace(ModuleCtxToModuleQName.class, root);
+
+ if (targetStmtArgument instanceof QName) {
+ QName targetQName = (QName) targetStmtArgument;
+ QNameModule targetQNameModule = targetQName.getModule();
+
+ if (targetQNameModule.equals(sourceQNameModule)) {
+ return null;
+ } else {
+ return targetQNameModule;
}
+ } else {
+ return null;
}
}
return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition());
}
- static boolean isSupportedAugmentTarget(final StatementContextBase<?, ?, ?> substatementCtx) {
+ public static StatementContextBase<?, ?, ?> getAugmentTargetCtx(
+ final Mutable<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode) {
+
+ final SchemaNodeIdentifier augmentTargetNode = augmentNode.getStatementArgument();
+ Preconditions.checkArgument(augmentTargetNode != null,
+ "Augment argument null, something bad happened in some of previous parsing phases");
+
+ List<StatementContextBase<?, ?, ?>> rootStatementCtxList = new ArrayList<>();
+ if (augmentTargetNode.isAbsolute()) {
+
+ QNameModule module = augmentTargetNode.getPathFromRoot().iterator().next().getModule();
+
+ StatementContextBase<?, ?, ?> rootStatementCtx =
+ (StatementContextBase<?, ?, ?>) augmentNode.getFromNamespace(NamespaceToModule.class, module);
+ rootStatementCtxList.add(rootStatementCtx);
+
+ final Map<?, ?> subModules = rootStatementCtx.getAllFromNamespace(IncludedModuleContext.class);
+ if (subModules != null) {
+ rootStatementCtxList.addAll((Collection<? extends StatementContextBase<?, ?, ?>>) subModules.values());
+ }
+
+ } else {
+ StatementContextBase<?, ?, ?> parent = (StatementContextBase<?, ?, ?>) augmentNode.getParentContext();
+ if (StmtContextUtils.producesDeclared(parent, UsesStatement.class)) {
+ rootStatementCtxList.add(parent.getParentContext());
+ } else {
+ // error
+ }
+ }
+
+ StatementContextBase<?, ?, ?> augmentTargetCtx = null;
+ for (final StatementContextBase<?, ?, ?> rootStatementCtx : rootStatementCtxList) {
+ augmentTargetCtx = findCtxOfNodeInRoot(rootStatementCtx, augmentTargetNode);
+ if (augmentTargetCtx != null) {
+ break;
+ }
+ }
+
+ return augmentTargetCtx;
+ }
+
+ @Nullable
+ public static StatementContextBase<?, ?, ?> findCtxOfNodeInSubstatements(final StatementContextBase<?, ?, ?> rootStmtCtx,
+ final Iterable<QName> path) {
+
+ StatementContextBase<?, ?, ?> parent = rootStmtCtx;
+
+ Iterator<QName> pathIter = path.iterator();
+ while (pathIter.hasNext()) {
+ QName nextPathQName = pathIter.next();
+ StatementContextBase<?, ?, ?> foundSubstatement = getSubstatementByQName(parent, nextPathQName);
+
+ if (foundSubstatement == null) {
+ return null;
+ }
+ if (!pathIter.hasNext()) {
+ return foundSubstatement;
+ }
+
+ parent = foundSubstatement;
+ }
+
+ return null;
+ }
+
+ public static StatementContextBase<?, ?, ?> getSubstatementByQName(final StatementContextBase<?, ?, ?> parent,
+ final QName nextPathQName) {
+
+ Collection<StatementContextBase<?, ?, ?>> declaredSubstatement = parent.declaredSubstatements();
+ Collection<StatementContextBase<?, ?, ?>> effectiveSubstatement = parent.effectiveSubstatements();
+
+ for (StatementContextBase<?, ?, ?> substatement : Iterables.concat(declaredSubstatement, effectiveSubstatement)) {
+ Object substatementArgument = substatement.getStatementArgument();
+ QName substatementQName;
+ if (substatementArgument instanceof QName) {
+ substatementQName = (QName) substatementArgument;
+
+ if (nextPathQName.getLocalName().equals(
+ substatementQName.getLocalName())) {
+ if (isSupportedAugmentTarget(substatement)) {
+ return substatement;
+ } else if (Utils.isUnknownNode(substatement)) {
+ LOG.warn("Module '{}': augment into unknown node '{}'.",
+ substatement.getRoot().getStatementArgument(), substatementArgument);
+ return substatement;
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public static boolean isSupportedAugmentTarget(final StatementContextBase<?, ?, ?> substatementCtx) {
/*
* :TODO Substatement must be allowed augment target type e.g. Container, etc... and must be not for example
return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty()
|| allowedAugmentTargets.contains(substatementCtx.getPublicDefinition());
}
+
+ @Nullable
+ public static StatementContextBase<?, ?, ?> findCtxOfNodeInRoot(final StatementContextBase<?, ?, ?> rootStmtCtx,
+ final SchemaNodeIdentifier node) {
+ return findCtxOfNodeInSubstatements(rootStmtCtx, node.getPathFromRoot());
+ }
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
/**
* Statement local namespace, which holds direct schema node descendants.
* @param <D>
* @param <E>
*/
-public class ChildSchemaNodes<D extends DeclaredStatement<QName>,E extends EffectiveStatement<QName, D>>
- extends NamespaceBehaviour<QName, StmtContext<?, D, E>, ChildSchemaNodes<D, E>>
- implements StatementNamespace<QName, D, E>{
+public interface ChildSchemaNodes<D extends DeclaredStatement<QName>,E extends EffectiveStatement<QName, D>> extends StatementNamespace<QName, D, E>{
- protected ChildSchemaNodes() {
- super((Class<ChildSchemaNodes<D,E>>) (Class) ChildSchemaNodes.class);
- }
-
- @Override
- public StmtContext<?, D, E> get(QName key) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public StmtContext<?, D, E> getFrom(NamespaceStorageNode storage, QName key) {
- return globalOrStatementSpecific(storage).getFromLocalStorage(getIdentifier(), key);
- }
-
- @Override
- public Map<QName, StmtContext<?, D, E>> getAllFrom(NamespaceStorageNode storage) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public void addTo(NamespaceBehaviour.NamespaceStorageNode storage, QName key, StmtContext<?, D, E> value) {
- globalOrStatementSpecific(storage).addToLocalStorage(ChildSchemaNodes.class, key, value);
- }
-
- private NamespaceStorageNode globalOrStatementSpecific(NamespaceBehaviour.NamespaceStorageNode storage) {
- NamespaceStorageNode current = storage;
- while(current.getStorageNodeType() != StorageNodeType.STATEMENT_LOCAL && current.getStorageNodeType() != StorageNodeType.GLOBAL) {
- current = current.getParentNamespaceStorage();
- }
- return current;
- }
}
+++ /dev/null
-/*
- * 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.parser.stmt.rfc6020;
-
-import java.util.Iterator;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedNamespaceBehaviour;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-
-class SchemaNodeIdentifierBuildNamespace extends
- DerivedNamespaceBehaviour<SchemaNodeIdentifier, StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>>, SchemaNodeIdentifierBuildNamespace, ChildSchemaNodes<?, ?>>
- implements IdentifierNamespace<SchemaNodeIdentifier, StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>>> {
-
- @SuppressWarnings({"unchecked", "rawtypes"})
- protected SchemaNodeIdentifierBuildNamespace() {
- super(SchemaNodeIdentifierBuildNamespace.class, (Class) ChildSchemaNodes.class);
- }
-
- @Override
- public StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>> get(
- SchemaNodeIdentifier key) {
- throw new UnsupportedOperationException("Direct access to namespace is not supported");
- }
-
- @Override
- public StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>> getFrom(NamespaceStorageNode storage, SchemaNodeIdentifier key) {
-
- final NamespaceStorageNode lookupStartStorage;
- if(key.isAbsolute() || storage.getStorageNodeType() == StorageNodeType.ROOT_STATEMENT_LOCAL) {
- lookupStartStorage = NamespaceBehaviour.findClosestTowardsRoot(storage, StorageNodeType.GLOBAL);
- } else {
- lookupStartStorage = storage;
- }
- Iterator<QName> iterator = key.getPathFromRoot().iterator();
- if(!iterator.hasNext()) {
- if(lookupStartStorage instanceof StmtContext<?, ?, ?>) {
- return (StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>>) lookupStartStorage;
- } else {
- return null;
- }
- }
- StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>> current = (StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>>) lookupStartStorage.getFromLocalStorage(ChildSchemaNodes.class, iterator.next());
- while(current != null && iterator.hasNext()) {
- current = (StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>>) current.getFromNamespace(ChildSchemaNodes.class, iterator.next());
- }
- return current;
- }
-
-}
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
return;
}
- ModelActionBuilder usesAction = usesNode.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
+ ModelActionBuilder usesAction = usesNode.newInferenceAction(FULL_DECLARATION);
final QName groupingName = usesNode.getStatementArgument();
final Prerequisite<StmtContext<?, ?, ?>> sourceGroupingPre = usesAction.requiresCtx(usesNode,
- GroupingNamespace.class, groupingName, ModelProcessingPhase.EFFECTIVE_MODEL);
- final Prerequisite<? extends StmtContext.Mutable<?, ?, ?>> targetNodePre = usesAction.mutatesEffectiveCtx(
- usesNode.getParentContext());
+ GroupingNamespace.class, groupingName, FULL_DECLARATION);
+ final Prerequisite<? extends StmtContext.Mutable<?, ?, ?>> targetNodePre = usesAction.mutatesCtx(
+ usesNode.getParentContext(), FULL_DECLARATION);
usesAction.apply(new InferenceAction() {
}
@Nullable
- public static StatementContextBase<?, ?, ?> findNode(final StmtContext<?, ?, ?> rootStmtCtx,
+ public static StatementContextBase<?, ?, ?> findNode(final StatementContextBase<?, ?, ?> rootStmtCtx,
final SchemaNodeIdentifier node) {
- return (StatementContextBase<?, ?, ?>) rootStmtCtx.getFromNamespace(SchemaNodeIdentifierBuildNamespace.class, node);
+ StatementContextBase<?, ?, ?> current = rootStmtCtx;
+ Iterator<QName> arguments = node.getPathFromRoot().iterator();
+ while(current != null && arguments.hasNext()) {
+ current = (StatementContextBase<?, ?, ?>) current.getFromNamespace(ChildSchemaNodes.class, arguments.next());
+ }
+ return current;
}
public static SchemaPath getSchemaPath(final StmtContext<?, ?, ?> ctx) {
.addSupport(new YinElementStatementImpl.Definition())
.addSupport(new ArgumentStatementImpl.Definition())
.addSupport(new ExtensionStatementImpl.Definition())
- .addSupport(new ChildSchemaNodes())
- .addSupport(new SchemaNodeIdentifierBuildNamespace())
+ .addSupport(global(ChildSchemaNodes.class))
.addSupport(global(ExtensionNamespace.class))
.addSupport(new TypedefStatementImpl.Definition())
.addSupport(treeScoped(TypeNamespace.class))
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.meta.ModelStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
MULTIPLE_AUGMENT_SUBMODULE);
EffectiveSchemaContext result = null;
- result = reactor.buildEffective();
+ try {
+ result = reactor.buildEffective();
+ } catch (Exception e) {
+ log(e, "");
+ }
assertNotNull(result);
}
addSources(reactor, MULTIPLE_AUGMENT);
EffectiveSchemaContext result = null;
- result = reactor.buildEffective();
+ try {
+ result = reactor.buildEffective();
+ } catch (Exception e) {
+ log(e, "");
+ }
assertNotNull(result);
}
- @Test(expected=SomeModifiersUnresolvedException.class)
+ @Test
public void multipleAugmentIncorrectPathTest() throws SourceException,
ReactorException {
CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
addSources(reactor, MULTIPLE_AUGMENT_INCORRECT);
EffectiveSchemaContext result = null;
- result = reactor.buildEffective();
+ try {
+ result = reactor.buildEffective();
+ } catch (Exception e) {
+ log(e, "");
+ }
+
assertNull(result);
}
- @Test(expected=SomeModifiersUnresolvedException.class)
+ @Test
public void multipleAugmentIncorrectPathAndGrpTest()
throws SourceException, ReactorException {
CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
.newBuild();
addSources(reactor, MULTIPLE_AUGMENT_INCORRECT2);
+
EffectiveSchemaContext result = null;
- result = reactor.buildEffective();
+ try {
+ result = reactor.buildEffective();
+ } catch (Exception e) {
+ log(e, "");
+ }
+
assertNull(result);
}
+ private void log(final Throwable e, final String indent) {
+ System.out.println(indent + e.getMessage());
+ Throwable[] suppressed = e.getSuppressed();
+ for (Throwable throwable : suppressed) {
+ log(throwable, indent + " ");
+ }
+ }
@Test
public void readAndParseYangFileTest() throws SourceException,
status obsolete;
}
- augment "/br:interfaces/br:ifEntry/bz:augment-holder" {
+ augment "/br:interfaces/br:ifEntry/br:augment-holder" {
when "if:ifType='ds0'";
leaf ds0ChannelNumber {
type string;
status obsolete;
}
- augment "/br:interfaces/br:ifEntry/bz:augment-holder" {
+ augment "/br:interfaces/br:ifEntry/br:augment-holder" {
when "if:ifType='ds0'";
leaf subleaf {
type string;
namespace "multiple-augment-imported";
prefix imp;
+ augment /root-container/container-from-grp1/sub-container-from-grp1/container-in-uses-augment/sub-container-from-augment2/sub-container-from-augment3 {
+ container sub-container-from-augment4 {
+ }
+ }
container root-container {
uses grp1 {
}
}
+ augment /root-container/added-container-1 {
+ container added-container-2 {
+ }
+ }
+
grouping grp2 {
container container-from-grp2 {
container sub-container-from-grp2 {
container sub-container-from-augment2 {
}
}
-
+
grouping grp-from-import {
container container-from-grp-from-import {
-
+
}
}
}
prefix root;
import multiple-augment-imported { prefix imp; revision-date 1970-01-01; }
-
+
include multiple-augment-submodule { revision-date 1970-01-01; }
augment /imp:root-container/imp:container-from-grp1/imp:sub-container-from-grp1/imp:container-in-uses-augment/imp:sub-container-from-augment2 {
}
}
- augment /imp:root-container/imp:container-from-grp1/imp:sub-container-from-grp1/imp:container-from-grp2/imp:sub-container-from-grp2/sub-container-from-augment5 {
+ augment /imp:root-container/imp:container-from-grp1/imp:sub-container-from-grp1/imp:container-from-grp2/imp:sub-container-from-grp2/imp:sub-container-from-augment5 {
container sub-container-from-augment7 {
}
}
container added-container-1 {
}
}
-
+
container container-with-multiple-uses {
uses imp:grp-from-import{
augment container-from-grp-from-import {
Code Review / yangtools.git / commitdiff