*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
-
-import java.util.Map.Entry;
-import java.util.Collection;
-import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
import javax.annotation.Nonnull;
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.model.api.meta.IdentifierNamespace;
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.StatementSupportBundle;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
+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.SourceSpecificContext.PhaseCompletionProgress;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
class BuildGlobalContext extends NamespaceStorageSupport implements NamespaceBehaviour.Registry {
private ModelProcessingPhase currentPhase = ModelProcessingPhase.INIT;
private ModelProcessingPhase finishedPhase = ModelProcessingPhase.INIT;
- public BuildGlobalContext(Map<ModelProcessingPhase, StatementSupportBundle> supports) {
+ public BuildGlobalContext(final Map<ModelProcessingPhase, StatementSupportBundle> supports) {
super();
this.supports = Preconditions.checkNotNull(supports, "BuildGlobalContext#supports cannot be null");
}
- public BuildGlobalContext(Map<ModelProcessingPhase, StatementSupportBundle> supports, Map<ValidationBundleType,Collection<?>> supportedValidation) {
+ public BuildGlobalContext(final Map<ModelProcessingPhase, StatementSupportBundle> supports, final Map<ValidationBundleType,Collection<?>> supportedValidation) {
super();
this.supports = Preconditions.checkNotNull(supports, "BuildGlobalContext#supports cannot be null");
}
}
- public StatementSupportBundle getSupportsForPhase(ModelProcessingPhase currentPhase) {
+ public StatementSupportBundle getSupportsForPhase(final ModelProcessingPhase currentPhase) {
return supports.get(currentPhase);
}
- public void addSource(@Nonnull StatementStreamSource source) {
+ public void addSource(@Nonnull final StatementStreamSource source) {
sources.add(new SourceSpecificContext(this,source));
}
}
@Override
- public <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> getNamespaceBehaviour(Class<N> type) {
+ public <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviourWithListeners<K, V, N> getNamespaceBehaviour(final Class<N> type) {
NamespaceBehaviourWithListeners<?, ?, ?> potential = supportedNamespaces.get(type);
if (potential == null) {
NamespaceBehaviour<K, V, N> potentialRaw = supports.get(currentPhase).getNamespaceBehaviour(type);
throw new NamespaceNotAvailableException("Namespace " + type + " is not available in phase " + currentPhase);
}
- public StatementDefinitionContext<?, ?, ?> getStatementDefinition(QName name) {
+ public StatementDefinitionContext<?, ?, ?> getStatementDefinition(final QName name) {
StatementDefinitionContext<?, ?, ?> potential = definitions.get(name);
if(potential == null) {
StatementSupport<?, ?, ?> potentialRaw = supports.get(currentPhase).getStatementDefinition(name);
return new EffectiveSchemaContext(rootStatements,rootEffectiveStatements);
}
- private void startPhase(ModelProcessingPhase phase) {
+ private void startPhase(final ModelProcessingPhase phase) {
Preconditions.checkState(Objects.equals(finishedPhase, phase.getPreviousPhase()));
for(SourceSpecificContext source : sources) {
source.startPhase(phase);
}
}
- private SomeModifiersUnresolvedException addSourceExceptions(SomeModifiersUnresolvedException buildFailure,
- List<SourceSpecificContext> sourcesToProgress) {
+ private SomeModifiersUnresolvedException addSourceExceptions(final SomeModifiersUnresolvedException buildFailure,
+ final List<SourceSpecificContext> sourcesToProgress) {
for(SourceSpecificContext failedSource : sourcesToProgress) {
SourceException sourceEx = failedSource.failModifiers(currentPhase);
buildFailure.addSuppressed(sourceEx);
}
}
- private void endPhase(ModelProcessingPhase phase) {
+ private void endPhase(final ModelProcessingPhase phase) {
Preconditions.checkState(currentPhase == phase);
finishedPhase = currentPhase;
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
+import java.util.HashMap;
+import java.util.Map;
import java.util.Map.Entry;
-
import java.util.Set;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
-import java.util.HashMap;
-import java.util.Map;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceNotAvailableException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
abstract class NamespaceStorageSupport implements NamespaceStorageNode {
public abstract NamespaceBehaviour.Registry getBehaviourRegistry();
- protected void checkLocalNamespaceAllowed(Class<? extends IdentifierNamespace<?, ?>> type) {
+ protected void checkLocalNamespaceAllowed(final Class<? extends IdentifierNamespace<?, ?>> type) {
// NOOP
}
- protected <K, V, N extends IdentifierNamespace<K, V>> void onNamespaceElementAdded(Class<N> type, K key, V value) {
+ protected <K, V, N extends IdentifierNamespace<K, V>> void onNamespaceElementAdded(final Class<N> type, final K key, final V value) {
// NOOP
}
//<K,V,N extends IdentifierNamespace<K, V>> V
//public final <K, VT, V extends VT ,N extends IdentifierNamespace<K, V>> VT getFromNamespace(Class<N> type, K key)
- public final <K,V, KT extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(Class<N> type, KT key)
+ public final <K,V, KT extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(final Class<N> type, final KT key)
throws NamespaceNotAvailableException {
return getBehaviourRegistry().getNamespaceBehaviour(type).getFrom(this,key);
}
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromNamespace(Class<N> type){
+ public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromNamespace(final Class<N> type){
return getBehaviourRegistry().getNamespaceBehaviour(type).getAllFrom(this);
}
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromCurrentStmtCtxNamespace(Class<N> type){
+ public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromCurrentStmtCtxNamespace(final Class<N> type){
return (Map<K, V>) namespaces.get(type);
}
- public final <K,V, KT extends K, VT extends V,N extends IdentifierNamespace<K, V>> void addToNs(Class<N> type, KT key, VT value)
+ public final <K,V, KT extends K, VT extends V,N extends IdentifierNamespace<K, V>> void addToNs(final Class<N> type, final KT key, final VT value)
throws NamespaceNotAvailableException {
getBehaviourRegistry().getNamespaceBehaviour(type).addTo(this,key,value);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
- public final <K, N extends StatementNamespace<K, ?,?>> void addContextToNamespace(Class<N> type, K key, StmtContext<?, ?, ?> value)
+ public final <K, N extends StatementNamespace<K, ?,?>> void addContextToNamespace(final Class<N> type, final K key, final StmtContext<?, ?, ?> value)
throws NamespaceNotAvailableException {
getBehaviourRegistry().getNamespaceBehaviour((Class)type).addTo(this, key, value);
}
@SuppressWarnings("unchecked")
@Override
- public <K, V, N extends IdentifierNamespace<K, V>> V getFromLocalStorage(Class<N> type, K key) {
+ public <K, V, N extends IdentifierNamespace<K, V>> V getFromLocalStorage(final Class<N> type, final K key) {
Map<K, V> localNamespace = (Map<K,V>) namespaces.get(type);
V potential = null;
return potential;
}
- private <K, V, N extends IdentifierNamespace<K, V>> V getRegardlessOfRevision(ModuleIdentifier key,
- Map<ModuleIdentifier, V> localNamespace) {
+ private static <K, V, N extends IdentifierNamespace<K, V>> V getRegardlessOfRevision(final ModuleIdentifier key,
+ final Map<ModuleIdentifier, V> localNamespace) {
- if(localNamespace == null) {
+ if (localNamespace == null) {
return null;
}
Set<Entry<ModuleIdentifier, V>> entrySet = localNamespace.entrySet();
for (Entry<ModuleIdentifier, V> entry : entrySet) {
ModuleIdentifier moduleIdentifierInMap = entry.getKey();
- if(moduleIdentifierInMap.getName().equals(key.getName())) {
+ if (moduleIdentifierInMap.getName().equals(key.getName())) {
return entry.getValue();
}
}
}
@Override
- public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromLocalStorage(Class<N> type) {
+ public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromLocalStorage(final Class<N> type) {
@SuppressWarnings("unchecked")
Map<K, V> localNamespace = (Map<K, V>) namespaces.get(type);
return localNamespace;
}
@Override
- public <K, V, N extends IdentifierNamespace<K, V>> void addToLocalStorage(Class<N> type, K key, V value) {
+ public <K, V, N extends IdentifierNamespace<K, V>> void addToLocalStorage(final Class<N> type, final K key, final V value) {
@SuppressWarnings("unchecked")
Map<K, V> localNamespace = (Map<K,V>) namespaces.get(type);
if(localNamespace == null) {
*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import com.google.common.base.Preconditions;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Multimap;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
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.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.ImportedNamespaceContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule;
import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModuleMap;
import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinition;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.BitsSpecificationImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Decimal64SpecificationImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.EnumSpecificationImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.IdentityRefSpecificationImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.InstanceIdentifierSpecificationImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.LeafrefSpecificationImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.UnionSpecificationImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.UnknownStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Objects;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl;
public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBehaviour.Registry, Mutable {
private ModelProcessingPhase inProgressPhase;
private ModelProcessingPhase finishedPhase = ModelProcessingPhase.INIT;
- private QNameToStatementDefinitionMap qNameToStmtDefMap = new QNameToStatementDefinitionMap();
- private PrefixToModuleMap prefixToModuleMap = new PrefixToModuleMap();
+ private final QNameToStatementDefinitionMap qNameToStmtDefMap = new QNameToStatementDefinitionMap();
+ private final PrefixToModuleMap prefixToModuleMap = new PrefixToModuleMap();
- SourceSpecificContext(BuildGlobalContext currentContext, StatementStreamSource source) {
+ SourceSpecificContext(final BuildGlobalContext currentContext, final StatementStreamSource source) {
this.source = source;
this.currentContext = currentContext;
}
return inProgressPhase;
}
- StatementDefinitionContext<?, ?, ?> getDefinition(QName name) {
+ StatementDefinitionContext<?, ?, ?> getDefinition(final QName name) {
return currentContext.getStatementDefinition(name);
}
- ContextBuilder<?, ?, ?> createDeclaredChild(StatementContextBase<?, ?, ?> current, QName name, StatementSourceReference ref) {
+ ContextBuilder<?, ?, ?> createDeclaredChild(final StatementContextBase<?, ?, ?> current, final QName name, final StatementSourceReference ref) {
StatementDefinitionContext<?, ?, ?> def = getDefinition(name);
if (def == null) {
final StatementContextBase<?,?,?> extension = (StatementContextBase<?, ?, ?>) currentContext
.getAllFromNamespace(ExtensionNamespace.class).get(key);
if (extension != null) {
- final QName qName = QName.create(((QName) ((SubstatementContext) extension).getStatementArgument())
- .getModule().getNamespace(), ((QName) ((SubstatementContext) extension).
+ final QName qName = QName.create(((QName) ((SubstatementContext<?, ?, ?>) extension).getStatementArgument())
+ .getModule().getNamespace(), ((QName) ((SubstatementContext<?, ?, ?>) extension).
getStatementArgument()).getModule().getRevision(), extension.getIdentifier().getArgument());
def = new StatementDefinitionContext<>(new UnknownStatementImpl.Definition
}
@SuppressWarnings({"rawtypes", "unchecked"})
- private ContextBuilder<?, ?, ?> createDeclaredRoot(StatementDefinitionContext<?, ?, ?> def, StatementSourceReference ref) {
+ private ContextBuilder<?, ?, ?> createDeclaredRoot(final StatementDefinitionContext<?, ?, ?> def, final StatementSourceReference ref) {
return new ContextBuilder(def, ref) {
@Override
}
}
- private StatementDefinitionContext<?, ?, ?> resolveTypeBodyStmts(String typeArgument) {
+ private static StatementDefinitionContext<?, ?, ?> resolveTypeBodyStmts(final String typeArgument) {
switch (typeArgument) {
case TypeUtils.DECIMAL64:
return new StatementDefinitionContext<>(new Decimal64SpecificationImpl.Definition());
private AugmentUtils() {
}
- public static Iterable<QName> parseAugmentPath(StmtContext<?, ?, ?> ctx, String path) {
+ public static Iterable<QName> parseAugmentPath(final StmtContext<?, ?, ?> ctx, final String path) {
if (path.matches(REGEX_PATH_REL1) || path.matches(REGEX_PATH_REL2)) {
throw new IllegalArgumentException(
return Utils.parseXPath(ctx, path);
}
- public static void copyFromSourceToTarget(StatementContextBase<?, ?, ?> sourceCtx,
- StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
+ public static void copyFromSourceToTarget(final StatementContextBase<?, ?, ?> sourceCtx,
+ final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
copyDeclaredStmts(sourceCtx, targetCtx);
copyEffectiveStmts(sourceCtx, targetCtx);
}
- public static void copyDeclaredStmts(StatementContextBase<?, ?, ?> sourceCtx,
- StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
+ public static void copyDeclaredStmts(final StatementContextBase<?, ?, ?> sourceCtx,
+ final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
Collection<? extends StatementContextBase<?, ?, ?>> declaredSubStatements = sourceCtx.declaredSubstatements();
- final List<StatementContextBase> subStatements = new Builder<StatementContextBase>()
+ final List<StatementContextBase<?, ?, ?>> subStatements = new Builder<StatementContextBase<?, ?, ?>>()
.addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals(
Utils.getRootModuleQName(targetCtx));
}
}
- public static void copyEffectiveStmts(StatementContextBase<?, ?, ?> sourceCtx,
- StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
+ public static void copyEffectiveStmts(final StatementContextBase<?, ?, ?> sourceCtx,
+ final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
Collection<? extends StatementContextBase<?, ?, ?>> effectiveSubstatements = sourceCtx.effectiveSubstatements();
- final List<StatementContextBase> subStatements = new Builder<StatementContextBase>()
+ final List<StatementContextBase<?, ?, ?>> subStatements = new Builder<StatementContextBase<?, ?, ?>>()
.addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals(
Utils.getRootModuleQName(targetCtx));
}
private static void validateNodeCanBeCopiedByAugment(final StatementContextBase<?, ?, ?> sourceCtx,
- final List<StatementContextBase> targetSubStatements, boolean sourceAndTargetInSameModule) {
+ final List<StatementContextBase<?, ?, ?>> targetSubStatements, final boolean sourceAndTargetInSameModule) {
if (sourceCtx.getPublicDefinition().getDeclaredRepresentationClass().equals(WhenStatement.class)) {
return;
}
if (!sourceAndTargetInSameModule) {
- final List<StatementContextBase> sourceSubStatements = new Builder<StatementContextBase>()
+ final List<StatementContextBase<?, ?, ?>> sourceSubStatements = new Builder<StatementContextBase<?, ?, ?>>()
.addAll(sourceCtx.declaredSubstatements()).addAll(sourceCtx.effectiveSubstatements()).build();
- for (final StatementContextBase sourceSubStatement : sourceSubStatements) {
+ for (final StatementContextBase<?, ?, ?> sourceSubStatement : sourceSubStatements) {
if (sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass()
.equals(MandatoryStatement.class)) {
throw new IllegalArgumentException(
}
}
- for (final StatementContextBase subStatement : targetSubStatements) {
+ for (final StatementContextBase<?, ?, ?> subStatement : targetSubStatements) {
final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx
.getPublicDefinition().getDeclaredRepresentationClass());
}
}
- public static QNameModule getNewQNameModule(StatementContextBase<?, ?, ?> targetCtx,
- StatementContextBase<?, ?, ?> sourceCtx) {
+ public static QNameModule getNewQNameModule(final StatementContextBase<?, ?, ?> targetCtx,
+ final StatementContextBase<?, ?, ?> sourceCtx) {
Object targetStmtArgument = targetCtx.getStatementArgument();
final StatementContextBase<?, ?, ?> root = sourceCtx.getRoot();
}
}
- public static boolean needToCopyByAugment(StmtContext<?, ?, ?> stmtContext) {
+ public static boolean needToCopyByAugment(final StmtContext<?, ?, ?> stmtContext) {
Set<StatementDefinition> noCopyDefSet = new HashSet<>();
noCopyDefSet.add(Rfc6020Mapping.USES);
return !noCopyDefSet.contains(def);
}
- public static boolean isReusedByAugment(StmtContext<?, ?, ?> stmtContext) {
+ public static boolean isReusedByAugment(final StmtContext<?, ?, ?> stmtContext) {
Set<StatementDefinition> reusedDefSet = new HashSet<>();
reusedDefSet.add(Rfc6020Mapping.TYPEDEF);
StatementContextBase<?, ?, ?> augmentTargetCtx = null;
for (final StatementContextBase<?, ?, ?> rootStatementCtx : rootStatementCtxList) {
augmentTargetCtx = findCtxOfNodeInRoot(rootStatementCtx, augmentTargetNode);
- if (augmentTargetCtx != null)
+ if (augmentTargetCtx != null) {
break;
+ }
}
return augmentTargetCtx;
}
@Nullable
- public static StatementContextBase<?, ?, ?> findCtxOfNodeInSubstatements(StatementContextBase<?, ?, ?> rootStmtCtx,
+ public static StatementContextBase<?, ?, ?> findCtxOfNodeInSubstatements(final StatementContextBase<?, ?, ?> rootStmtCtx,
final Iterable<QName> path) {
StatementContextBase<?, ?, ?> parent = rootStmtCtx;
return null;
}
- public static StatementContextBase<?, ?, ?> getSubstatementByQName(StatementContextBase<?, ?, ?> parent,
- QName nextPathQName) {
+ public static StatementContextBase<?, ?, ?> getSubstatementByQName(final StatementContextBase<?, ?, ?> parent,
+ final QName nextPathQName) {
Collection<StatementContextBase<?, ?, ?>> declaredSubstatement = parent.declaredSubstatements();
Collection<StatementContextBase<?, ?, ?>> effectiveSubstatement = parent.effectiveSubstatements();
return null;
}
- public static boolean isSupportedAugmentTarget(StatementContextBase<?, ?, ?> substatementCtx) {
+ 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
}
@Nullable
- public static StatementContextBase<?, ?, ?> findCtxOfNodeInRoot(StatementContextBase<?, ?, ?> rootStmtCtx,
+ public static StatementContextBase<?, ?, ?> findCtxOfNodeInRoot(final StatementContextBase<?, ?, ?> rootStmtCtx,
final SchemaNodeIdentifier node) {
return findCtxOfNodeInSubstatements(rootStmtCtx, node.getPathFromRoot());
}
implements BelongsToStatement {
protected BelongsToStatementImpl(
- StmtContext<String, BelongsToStatement, ?> context) {
+ final StmtContext<String, BelongsToStatement, ?> context) {
super(context);
}
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return value;
}
@Override
public BelongsToStatement createDeclared(
- StmtContext<String, BelongsToStatement, ?> ctx) {
+ final StmtContext<String, BelongsToStatement, ?> ctx) {
return new BelongsToStatementImpl(ctx);
}
@Override
public EffectiveStatement<String, BelongsToStatement> createEffective(
- StmtContext<String, BelongsToStatement, EffectiveStatement<String, BelongsToStatement>> ctx) {
+ final StmtContext<String, BelongsToStatement, EffectiveStatement<String, BelongsToStatement>> ctx) {
return new BelongsEffectiveToStatementImpl(ctx);
}
}
@Override
- public void prerequisiteFailed(Collection<? extends ModelActionBuilder.Prerequisite<?>> failed) throws InferenceException {
+ public void prerequisiteFailed(final Collection<? extends ModelActionBuilder.Prerequisite<?>> failed) throws InferenceException {
if (failed.contains(belongsToPrereq)) {
throw new InferenceException("Module from belongs-to was not found: " + belongsToCtx.getStatementArgument(), belongsToCtx
.getStatementSourceReference());
});
}
- private ModuleIdentifier getModuleIdentifier(StmtContext.Mutable<String, BelongsToStatement, EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
+ private static ModuleIdentifier getModuleIdentifier(final StmtContext.Mutable<String, BelongsToStatement, EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
String moduleName = belongsToCtx.getStatementArgument();
return new ModuleIdentifierImpl(moduleName, Optional.<URI> absent(), Optional.of(SimpleDateFormatUtil.DEFAULT_BELONGS_TO_DATE));
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.antlrv4.code.gen.YangStatementParser;
-import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
-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.IdentityEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
import org.opendaylight.yangtools.yang.common.QName;
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.IdentityStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
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.rfc6020.effective.IdentityEffectiveStatementImpl;
public class IdentityStatementImpl extends AbstractDeclaredStatement<QName>
implements IdentityStatement {
protected IdentityStatementImpl(
- StmtContext<QName, IdentityStatement, ?> context) {
+ final StmtContext<QName, IdentityStatement, ?> context) {
super(context);
}
}
@Override
- public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return Utils.qNameFromArgument(ctx, value);
}
@Override
public IdentityStatement createDeclared(
- StmtContext<QName, IdentityStatement, ?> ctx) {
+ final StmtContext<QName, IdentityStatement, ?> ctx) {
return new IdentityStatementImpl(ctx);
}
@Override
public EffectiveStatement<QName, IdentityStatement> createEffective(
- StmtContext<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> ctx) {
+ final StmtContext<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> ctx) {
return new IdentityEffectiveStatementImpl(ctx);
}
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
-
-import java.util.Set;
-
-import java.util.Map.Entry;
-import java.util.Map;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import com.google.common.base.Optional;
import java.net.URI;
import java.util.Collection;
import java.util.Date;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
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.ImportStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleIdentifierImpl;
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return value;
}
@Override
public ImportStatement createDeclared(
- StmtContext<String, ImportStatement, ?> ctx) {
+ final StmtContext<String, ImportStatement, ?> ctx) {
return new ImportStatementImpl(ctx);
}
@Override
public EffectiveStatement<String, ImportStatement> createEffective(
- StmtContext<String, ImportStatement, EffectiveStatement<String, ImportStatement>> ctx) {
+ final StmtContext<String, ImportStatement, EffectiveStatement<String, ImportStatement>> ctx) {
return new ImportEffectiveStatementImpl(ctx);
}
}
private Entry<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> findRecentModule(
- ModuleIdentifier impIdentifier,
- Map<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> allModules) {
+ final ModuleIdentifier impIdentifier,
+ final Map<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> allModules) {
ModuleIdentifier recentModuleIdentifier = impIdentifier;
Entry<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> recentModuleEntry = null;
@Override
public void prerequisiteFailed(
- Collection<? extends Prerequisite<?>> failed)
+ final Collection<? extends Prerequisite<?>> failed)
throws InferenceException {
if (failed.contains(imported)) {
throw new InferenceException(String.format(
});
}
- private ModuleIdentifier getImportedModuleIdentifier(
- Mutable<String, ImportStatement, ?> stmt) throws SourceException {
+ private static ModuleIdentifier getImportedModuleIdentifier(
+ final Mutable<String, ImportStatement, ?> stmt) throws SourceException {
String moduleName = stmt.getStatementArgument();
Date revision = firstAttributeOf(stmt.declaredSubstatements(),
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.PatternConstraintEffectiveImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.PatternEffectiveStatementImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class PatternStatementImpl extends AbstractDeclaredStatement<PatternConstraint> implements PatternStatement {
+ private static final Logger LOG = LoggerFactory.getLogger(PatternStatementImpl.class);
+ private static final Optional<String> OPTIONAL_EMPTY = Optional.of("");
protected PatternStatementImpl(StmtContext<PatternConstraint, PatternStatement, ?> context) {
super(context);
@Override
public PatternConstraint parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
-
- final StringBuilder wrapPatternBuilder = new StringBuilder(value.length() + 2);
- wrapPatternBuilder.append('^');
- wrapPatternBuilder.append(value);
- wrapPatternBuilder.append('$');
- final String pattern = wrapPatternBuilder.toString();
+ final String pattern = "^" + value + '$';
try {
Pattern.compile(pattern);
- return new PatternConstraintEffectiveImpl(pattern, Optional.of(""), Optional.of(""));
+ return new PatternConstraintEffectiveImpl(pattern, OPTIONAL_EMPTY, OPTIONAL_EMPTY);
} catch (PatternSyntaxException e) {
+ LOG.debug("Pattern {} failed to compile", pattern, e);
return null;
}
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BinaryEffectiveStatementImpl;
-
import java.util.Collection;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ExtendedTypeEffectiveStatementImpl;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ExtendedTypeEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BinaryEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BooleanEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EmptyEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Int16EffectiveStatementImpl;
public class TypeStatementImpl extends AbstractDeclaredStatement<String>
implements TypeStatement {
- protected TypeStatementImpl(StmtContext<String, TypeStatement, ?> context) {
+ protected TypeStatementImpl(final StmtContext<String, TypeStatement, ?> context) {
super(context);
}
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value)
throws SourceException {
return value;
}
@Override
public TypeStatement createDeclared(
- StmtContext<String, TypeStatement, ?> ctx) {
+ final StmtContext<String, TypeStatement, ?> ctx) {
return new TypeStatementImpl(ctx);
}
@Override
public EffectiveStatement<String, TypeStatement> createEffective(
- StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx) {
+ final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx) {
// :FIXME improve the test of isExtended - e.g. unknown statements,
// etc..
Collection<StatementContextBase<?, ?, ?>> declaredSubstatements = ctx
.declaredSubstatements();
- boolean isExtended = declaredSubstatements.isEmpty() ? false
- : true;
- if (isExtended)
+ boolean isExtended = !declaredSubstatements.isEmpty();
+ if (isExtended) {
return new ExtendedTypeEffectiveStatementImpl(ctx, true);
+ }
switch (ctx.getStatementArgument()) {
case TypeUtils.INT8:
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import java.util.SortedSet;
-import java.util.TreeSet;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.LinkedList;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
import java.util.List;
import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
+import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
public class ChoiceEffectiveStatementImpl extends
AbstractEffectiveDocumentedNode<QName, ChoiceStatement> implements
ImmutableList<UnknownSchemaNode> unknownNodes;
public ChoiceEffectiveStatementImpl(
- StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
+ final StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
super(ctx);
this.qname = ctx.getStatementArgument();
}
private void initCopyType(
- StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
+ final StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
List<TypeOfCopy> copyTypesFromOriginal = ctx.getCopyHistory();
this.cases = ImmutableSet.copyOf(casesInit);
}
- private void resetAugmenting(DataSchemaNode dataSchemaNode) {
+ private static void resetAugmenting(final DataSchemaNode dataSchemaNode) {
if (dataSchemaNode instanceof LeafEffectiveStatementImpl) {
LeafEffectiveStatementImpl leaf = (LeafEffectiveStatementImpl) dataSchemaNode;
leaf.augmenting = false;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
-
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Map;
import java.util.NoSuchElementException;
-
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
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.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
private final A argument;
- public EffectiveStatementBase(StmtContext<A, D, ?> ctx) {
+ public EffectiveStatementBase(
final StmtContext<A, D, ?> ctx) {
this.stmtCtx = ctx;
this.statementDefinition = ctx.getPublicDefinition();
if(declaredSubstatement.getPublicDefinition() == Rfc6020Mapping.USES) {
substatementsInit.add(declaredSubstatement);
substatementsInit.addAll(declaredSubstatement.getEffectOfStatement());
- ((StatementContextBase)ctx).removeStatementsFromEffectiveSubstatements(declaredSubstatement
+ ((StatementContextBase<?, ?, ?>)ctx).removeStatementsFromEffectiveSubstatements(declaredSubstatement
.getEffectOfStatement());
} else {
substatementsInit.add(declaredSubstatement);
@Override
public <K, V, N extends IdentifierNamespace<K, V>> V get(
- Class<N> namespace, K identifier) {
+ final Class<N> namespace, final K identifier) {
return stmtCtx.getFromNamespace(namespace, identifier);
}
@Override
public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(
- Class<N> namespace) {
- return (Map<K, V>) stmtCtx.getAllFromNamespace(namespace);
+ final Class<N> namespace) {
+ return stmtCtx.getAllFromNamespace(namespace);
}
@Override
}
protected final <S extends EffectiveStatement<?, ?>> S firstEffective(
- Class<S> type) {
+ final Class<S> type) {
S result = null;
try {
result = type.cast(Iterables.find(substatements,
return result;
}
- protected final <S extends SchemaNode> S firstSchemaNode(Class<S> type) {
+ protected final <S extends SchemaNode> S firstSchemaNode(final Class<S> type) {
S result = null;
try {
result = type.cast(Iterables.find(substatements,
@SuppressWarnings("unchecked")
protected final <T> Collection<T> allSubstatementsOfType(
- Class<T> type) {
+ final Class<T> type) {
Collection<T> result = null;
try {
return result;
}
- protected final <T> T firstSubstatementOfType(Class<T> type) {
+ protected final <T> T firstSubstatementOfType(final Class<T> type) {
T result = null;
try {
result = type.cast(Iterables.find(substatements,
return result;
}
- protected final <R> R firstSubstatementOfType(Class<?> type,
- Class<R> returnType) {
+ protected final <R> R firstSubstatementOfType(final Class<?> type,
+ final Class<R> returnType) {
R result = null;
try {
result = returnType.cast(Iterables.find(
private final boolean isExtended;
public ExtendedTypeEffectiveStatementImpl(
- StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx, boolean isExtended) {
+ final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx, final boolean isExtended) {
super(ctx);
this.isExtended = isExtended;
validateTypeConstraints(ctx);
}
- private QName initQName(final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
+ private static QName initQName(final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final boolean isExtended) {
QName qName;
return qName;
}
- private TypeDefinition<?> parseBaseTypeFromCtx(
+ private static TypeDefinition<?> parseBaseTypeFromCtx(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx) {
TypeDefinition<?> baseType;
typeConstraints.validateConstraints();
}
- private TypeConstraints addConstraintsFromBaseType(final TypeConstraints typeConstraints,
+ private static TypeConstraints addConstraintsFromBaseType(final TypeConstraints typeConstraints,
final TypeDefinition<?> baseType) {
final String baseTypeName = baseType.getQName().getLocalName();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
-
-import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
-import org.opendaylight.yangtools.yang.model.util.ModuleImportImpl;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-import java.util.LinkedHashSet;
-import java.util.LinkedHashMap;
import com.google.common.collect.ImmutableMap;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
-import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
-import java.util.Map;
-import org.opendaylight.yangtools.yang.parser.spi.source.DeclarationInTextSource;
-import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToIdentifier;
+import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
+import org.opendaylight.yangtools.yang.model.util.ExtendedType;
+import org.opendaylight.yangtools.yang.model.util.ModuleImportImpl;
+import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
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.DeclarationInTextSource;
+import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
public class ModuleEffectiveStatementImpl extends
AbstractEffectiveDocumentedNode<String, ModuleStatement> implements
private final QNameModule qNameModule;
private final String name;
- private String sourcePath;
+ private final String sourcePath;
private String prefix;
private String yangVersion;
private String organization;
private ImmutableList<ExtensionDefinition> extensionNodes;
private ImmutableSet<IdentitySchemaNode> identities;
private ImmutableList<UnknownSchemaNode> unknownNodes;
- private String source;
+ private final String source;
private ImmutableList<EffectiveStatement<?, ?>> substatementsOfSubmodules;
private ImmutableMap<QName, DataSchemaNode> childNodes;
private ImmutableSet<DataSchemaNode> publicChildNodes;
public ModuleEffectiveStatementImpl(
- StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
+ final StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
super(ctx);
name = argument();
}
private void initSubmodules(
- StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
+ final StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
Map<String, ModuleIdentifier> includedSubmodulesMap = ctx
.getAllFromCurrentStmtCtxNamespace(IncludedSubmoduleNameToIdentifier.class);
}
private void initSubstatementCollections(
- StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
+ final StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
List<EffectiveStatement<?, ?>> effectiveSubstatements = new LinkedList<>();
effectiveSubstatements.addAll(effectiveSubstatements());
this.uses = ImmutableSet.copyOf(mutableUses);
}
- private Set<ModuleImport> resolveModuleImports(
- Set<ModuleImport> importsInit,
- StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
+ private static Set<ModuleImport> resolveModuleImports(
+ final Set<ModuleImport> importsInit,
+ final StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
Set<ModuleImport> resolvedModuleImports = new LinkedHashSet<>();
for (ModuleImport moduleImport : importsInit) {
if (moduleImport.getRevision().equals(
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
-
-import org.opendaylight.yangtools.yang.model.util.ModuleImportImpl;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-import java.util.LinkedHashSet;
-import java.util.LinkedHashMap;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
-import java.util.Map;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.source.DeclarationInTextSource;
-import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToIdentifier;
+import com.google.common.collect.ImmutableSet;
import java.net.URI;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
+import org.opendaylight.yangtools.yang.model.util.ExtendedType;
+import org.opendaylight.yangtools.yang.model.util.ModuleImportImpl;
+import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.source.DeclarationInTextSource;
+import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToModuleQName;
-import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
public class SubmoduleEffectiveStatementImpl
extends
private final QNameModule qNameModule;
private final String name;
- private String sourcePath;
+ private final String sourcePath;
private String prefix;
private String yangVersion;
private String organization;
private ImmutableSet<DataSchemaNode> publicChildNodes;
public SubmoduleEffectiveStatementImpl(
- StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
+ final StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
super(ctx);
name = argument();
}
private void initSubmodules(
- StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
+ final StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
Map<String, ModuleIdentifier> includedSubmodulesMap = ctx
.getAllFromCurrentStmtCtxNamespace(IncludedSubmoduleNameToIdentifier.class);
this.substatementsOfSubmodules = ImmutableList.copyOf(substatementsOfSubmodulesInit);
}
- private void initSubstatementCollections(StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
+ private void initSubstatementCollections(final StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
List<EffectiveStatement<?, ?>> effectiveSubstatements = new LinkedList<>();
effectiveSubstatements.addAll(effectiveSubstatements());
this.uses = ImmutableSet.copyOf(mutableUses);
}
- private Set<ModuleImport> resolveModuleImports(
- Set<ModuleImport> importsInit,
- StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
+ private static Set<ModuleImport> resolveModuleImports(
+ final Set<ModuleImport> importsInit,
+ final StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
Set<ModuleImport> resolvedModuleImports = new LinkedHashSet<>();
for (ModuleImport moduleImport : importsInit) {
if (moduleImport.getRevision().equals(
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
-
import com.google.common.base.Optional;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
public class BinaryEffectiveStatementImpl extends
EffectiveStatementBase<String, TypeStatement> implements
private static final String REFERENCE = "https://tools.ietf.org/html/rfc6020#section-9.8";
private static final String UNITS = "";
- private final static QName QNAME = QName.create(
- YangConstants.RFC6020_YANG_MODULE, "binary");
-
- private final static SchemaPath PATH = SchemaPath.create(true, QNAME);
+ private static final QName QNAME = QName.create(YangConstants.RFC6020_YANG_MODULE, "binary");
+ private static final SchemaPath PATH = SchemaPath.create(true, QNAME);
+ private static final Optional<String> OPTIONAL_EMPTY = Optional.of("");
private final List<Byte> defaultValue = Collections.emptyList();
private final List<LengthConstraint> lengthConstraints;
super(ctx);
final LengthConstraint lengthConstraint = new LengthConstraintEffectiveImpl(
- 0, Long.MAX_VALUE, Optional.of(""), Optional.of(""));
+ 0, Long.MAX_VALUE, OPTIONAL_EMPTY, OPTIONAL_EMPTY);
lengthConstraints = Collections.singletonList(lengthConstraint);
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType.Builder;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
-import org.opendaylight.yangtools.yang.model.util.Decimal64;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import java.math.BigDecimal;
-import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
+import org.opendaylight.yangtools.yang.model.util.Decimal64;
+import org.opendaylight.yangtools.yang.model.util.ExtendedType;
+import org.opendaylight.yangtools.yang.model.util.ExtendedType.Builder;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FractionDigitsEffectiveStatementImpl;
public class Decimal64SpecificationEffectiveStatementImpl extends
"-922337203685477580.8");
private static final BigDecimal MAX_VALUE = new BigDecimal(
"922337203685477580.7");
+ private static final List<RangeConstraint> DEFAULT_RANGE_STATEMENTS;
+ static {
+ final String rangeDescription = "Integer values between " + MIN_VALUE
+ + " and " + MAX_VALUE + ", inclusively.";
+ final String rangeReference = RangeConstraintEffectiveImpl.DEFAULT_REFERENCE;
+
+ DEFAULT_RANGE_STATEMENTS = ImmutableList.<RangeConstraint>of(
+ new RangeConstraintEffectiveImpl(MIN_VALUE, MAX_VALUE, Optional.of(rangeDescription),
+ Optional.of(rangeReference)));
+ }
private List<RangeConstraint> rangeConstraints;
private Integer fractionDigits;
private final boolean isExtended;
public Decimal64SpecificationEffectiveStatementImpl(
- StmtContext<String, TypeStatement.Decimal64Specification, EffectiveStatement<String, TypeStatement.Decimal64Specification>> ctx) {
+ final StmtContext<String, TypeStatement.Decimal64Specification, EffectiveStatement<String, TypeStatement.Decimal64Specification>> ctx) {
super(ctx);
for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
path = parentPath.createChild(extendedTypeQName);
} else {
isExtended = false;
- rangeConstraints = defaultRangeStatements();
+ rangeConstraints = DEFAULT_RANGE_STATEMENTS;
path = Utils.getSchemaPath(ctx.getParentContext()).createChild(QNAME);
}
}
- private boolean validateRanges(List<RangeConstraint> initRanges) {
+ private static boolean validateRanges(final List<RangeConstraint> initRanges) {
for (RangeConstraint rangeConstraint : initRanges) {
String maxValueString = rangeConstraint.getMax().toString();
: Collections.<RangeConstraint> emptyList();
}
- private List<RangeConstraint> defaultRangeStatements() {
-
- final List<RangeConstraint> rangeStmts = new ArrayList<>();
- final String rangeDescription = "Integer values between " + MIN_VALUE
- + " and " + MAX_VALUE + ", inclusively.";
- final String rangeReference = RangeConstraintEffectiveImpl.DEFAULT_REFERENCE;
-
- rangeStmts.add(new RangeConstraintEffectiveImpl(MIN_VALUE, MAX_VALUE,
- Optional.of(rangeDescription), Optional.of(rangeReference)));
-
- return ImmutableList.copyOf(rangeStmts);
- }
-
public boolean isExtended() {
return isExtended;
}
+ "Legal characters are tab, carriage return, line feed, and the legal "
+ "characters of Unicode and ISO/IEC 10646";
private static final String REFERENCE = "https://tools.ietf.org/html/rfc6020#section-9.4";
+ private static final String UNITS = "";
+ private static final Optional<String> OPTIONAL_EMPTY = Optional.of("");
+
private final List<LengthConstraint> lengthConstraints;
private final List<PatternConstraint> patternConstraints;
- private static final String UNITS = "";
public StringEffectiveStatementImpl(
- StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx) {
+ final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx) {
super(ctx);
- final LengthConstraint defLength = new LengthConstraintEffectiveImpl(0, Integer.MAX_VALUE, Optional.of(""),
- Optional.of(""));
+ final LengthConstraint defLength = new LengthConstraintEffectiveImpl(0, Integer.MAX_VALUE, OPTIONAL_EMPTY,
+ OPTIONAL_EMPTY);
lengthConstraints = Collections.singletonList(defLength);
patternConstraints = Collections.emptyList();
*/
package org.opendaylight.yangtools.yang.parser.impl;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
import java.io.File;
-import java.math.BigInteger;
-import java.net.URI;
import java.util.Arrays;
-import java.util.List;
-import java.util.Set;
-import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
-import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
-import org.opendaylight.yangtools.yang.model.util.BitsType;
-import org.opendaylight.yangtools.yang.model.util.EnumerationType;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
-import org.opendaylight.yangtools.yang.model.util.InstanceIdentifierType;
-import org.opendaylight.yangtools.yang.model.util.UnionType;
public class Bug2291Test {
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import java.util.Set;
-import java.net.URISyntaxException;
import java.io.FileNotFoundException;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Collection;
+import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
assertNotNull(result);
}
- private void addSources(BuildAction reactor,
- YangStatementSourceImpl... sources) {
+ private static void addSources(final BuildAction reactor, final YangStatementSourceImpl... sources) {
for (YangStatementSourceImpl source : sources) {
reactor.addSource(source);
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
-
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Collection;
+import java.util.Set;
+import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-
import org.opendaylight.yangtools.yang.common.QNameModule;
-import java.net.URISyntaxException;
-import java.net.URI;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
-import java.util.Collection;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import java.util.Set;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.stmt.test.StmtTestUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangStatementSourceImpl;
-import org.junit.Test;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
+import org.opendaylight.yangtools.yang.stmt.test.StmtTestUtils;
public class EffectiveModulesAndSubmodulesTest {
}
- private void getDataChildByNameSubTest(EffectiveSchemaContext result,
- Module root) {
+ private static void getDataChildByNameSubTest(final EffectiveSchemaContext result,
+ final Module root) {
DataSchemaNode containerInRoot = result.getDataChildByName(QName
.create(root.getQNameModule(), "container-in-root-module"));
assertNotNull(containerInRoot);
assertEquals("desc", containerInRoot.getDescription());
}
- private void findModulesSubTest(EffectiveSchemaContext result, Module root,
- Module imported) throws URISyntaxException {
+ private static void findModulesSubTest(final EffectiveSchemaContext result, final Module root,
+ final Module imported) throws URISyntaxException {
Module foundRoot = result.findModuleByName("root-module",
SimpleDateFormatUtil.DEFAULT_DATE_REV);
Set<Module> foundRoots = result.findModuleByNamespace(new URI(
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-
+import java.net.URISyntaxException;
+import java.util.Set;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import java.util.Set;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import java.net.URISyntaxException;
+import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangStatementSourceImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
import org.opendaylight.yangtools.yang.stmt.test.StmtTestUtils;
-import org.junit.Test;
public class EffectiveUsesRefineAndConstraintsTest {
}
- private void checkOriginalContainer(EffectiveSchemaContext result,
- SchemaPath path) {
+ private static void checkOriginalContainer(final EffectiveSchemaContext result,
+ final SchemaPath path) {
SchemaNode containerInContainerNode = SchemaContextUtil
.findDataSchemaNode(result, path);
assertNotNull(containerInContainerNode);
assertEquals(0, containerConstraints.getMustConstraints().size());
}
- private void checkOriginalChoice(EffectiveSchemaContext result,
- SchemaPath path) {
+ private static void checkOriginalChoice(final EffectiveSchemaContext result,
+ final SchemaPath path) {
SchemaNode choiceInContainerNode = SchemaContextUtil
.findDataSchemaNode(result, path);
assertNotNull(choiceInContainerNode);
assertTrue(choiceConstraints.getMustConstraints().isEmpty());
}
- private void checkOriginalList(EffectiveSchemaContext result,
- SchemaPath path) {
+ private static void checkOriginalList(final EffectiveSchemaContext result,
+ final SchemaPath path) {
SchemaNode listInContainerNode = SchemaContextUtil.findDataSchemaNode(
result, path);
assertNotNull(listInContainerNode);
assertEquals(1, listConstraints.getMustConstraints().size());
}
- private void checkRefinedContainer(EffectiveSchemaContext result,
- SchemaPath path) {
+ private static void checkRefinedContainer(final EffectiveSchemaContext result,
+ final SchemaPath path) {
SchemaNode containerInContainerNode = SchemaContextUtil
.findDataSchemaNode(result, path);
assertNotNull(containerInContainerNode);
assertEquals(1, containerConstraints.getMustConstraints().size());
}
- private void checkRefinedChoice(EffectiveSchemaContext result,
- SchemaPath path) {
+ private static void checkRefinedChoice(final EffectiveSchemaContext result,
+ final SchemaPath path) {
SchemaNode choiceInContainerNode = SchemaContextUtil
.findDataSchemaNode(result, path);
assertNotNull(choiceInContainerNode);
assertTrue(choiceConstraints.getMustConstraints().isEmpty());
}
- private void checkRefinedList(EffectiveSchemaContext result, SchemaPath path) {
+ private static void checkRefinedList(final EffectiveSchemaContext result, final SchemaPath path) {
SchemaNode listInContainerNode = SchemaContextUtil.findDataSchemaNode(
result, path);
assertNotNull(listInContainerNode);
}
}
- private void addSources(CrossSourceStatementReactor.BuildAction reactor, YangStatementSourceImpl... sources) {
+ private static void addSources(final CrossSourceStatementReactor.BuildAction reactor, final YangStatementSourceImpl... sources) {
for (YangStatementSourceImpl source : sources) {
reactor.addSource(source);
}
*/
package org.opendaylight.yangtools.yang.stmt.retest;
+import static org.mockito.Mockito.doReturn;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.text.ParseException;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Map;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
//import org.opendaylight.yangtools.yang.parser.impl.SchemaContextImpl;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.text.ParseException;
-import java.util.Collections;
-import java.util.Date;
-import java.util.Map;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.doReturn;
-
public class SchemaContextTest {
@Mock
private Module oldModule;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-
import java.io.File;
import java.math.BigInteger;
import java.net.URI;
}
}
- private void addSources(CrossSourceStatementReactor.BuildAction reactor, YangStatementSourceImpl... sources) {
+ private static void addSources(final CrossSourceStatementReactor.BuildAction reactor, final YangStatementSourceImpl... sources) {
for (YangStatementSourceImpl source : sources) {
reactor.addSource(source);
}
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
-
import org.antlr.v4.runtime.tree.ParseTree;
import org.junit.Before;
import org.junit.Test;
}
}
- private Submodule_stmtContext mockSubmoduleParent(final ParseTree child,
+ private static Submodule_stmtContext mockSubmoduleParent(final ParseTree child,
final String moduleName) {
Submodule_stmtContext ctx = YangModelValidationTest.mockStatement(
Submodule_stmtContext.class, moduleName);
package org.opendaylight.yangtools.yang.stmt.retest;
import static org.hamcrest.CoreMatchers.containsString;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Date;
-
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
}
}
- private Import_stmtContext mockImport(final String name, final String prefixName) {
+ private static Import_stmtContext mockImport(final String name, final String prefixName) {
Import_stmtContext impor = mockStatement(Import_stmtContext.class, name);
Prefix_stmtContext prefix = mockStatement(Prefix_stmtContext.class, prefixName);
return new SimpleDateFormat("yyyy-MM-dd").format(new Date());
}
- private Include_stmtContext mockInclude(final String name) {
+ private static Include_stmtContext mockInclude(final String name) {
Include_stmtContext incl = mockStatement(Include_stmtContext.class, name);
Revision_date_stmtContext revDate = mockStatement(Revision_date_stmtContext.class, getFormattedDate());
// assertSetEquals(newModules, ctx.getModules());
// }
- private void checkOrder(final Collection<Module> modules) {
+ private static void checkOrder(final Collection<Module> modules) {
Iterator<Module> it = modules.iterator();
Module m = it.next();
assertEquals("m2", m.getName());
assertEquals("m1", m.getName());
}
- private void assertSetEquals(final Set<Module> s1, final Set<Module> s2) {
+ private static void assertSetEquals(final Set<Module> s1, final Set<Module> s2) {
assertEquals(s1, s2);
Iterator<Module> it = s1.iterator();
for (Module m : s2) {
}
}
- private void addSources(CrossSourceStatementReactor.BuildAction reactor, YangStatementSourceImpl... sources) {
+ private static void addSources(final CrossSourceStatementReactor.BuildAction reactor, final YangStatementSourceImpl... sources) {
for (YangStatementSourceImpl source : sources) {
reactor.addSource(source);
}
*/
package org.opendaylight.yangtools.yang.stmt.test;
-import static org.junit.Assert.*;
-
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import java.io.FileNotFoundException;
import java.net.URI;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import java.net.URISyntaxException;
+import java.text.ParseException;
import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import java.util.Set;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import java.util.Set;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import java.text.ParseException;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import java.io.FileNotFoundException;
-import java.net.URISyntaxException;
+import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.junit.Test;
public class ControllerStmtParserTest {
configModuleTest(context);
}
- private void salDomBrokerImplModuleTest(SchemaContext context)
+ private static void salDomBrokerImplModuleTest(final SchemaContext context)
throws ParseException {
Module module = context.findModuleByName(
"opendaylight-sal-dom-broker-impl", SimpleDateFormatUtil
assertTrue(checked);
}
- private void configModuleTest(SchemaContext context) throws ParseException,
+ private static void configModuleTest(final SchemaContext context) throws ParseException,
URISyntaxException {
Module configModule = context.findModuleByName("config",
SimpleDateFormatUtil.getRevisionFormat().parse("2013-04-05"));
.getPath().getLastComponent());
}
- private int getChildNodeSizeWithoutUses(final DataNodeContainer csn) {
+ private static int getChildNodeSizeWithoutUses(final DataNodeContainer csn) {
int result = 0;
for (DataSchemaNode dsn : csn.getChildNodes()) {
if (dsn.isAddedByUses() == false) {
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-
import org.junit.Test;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangStatementSourceImpl;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
public class ImportResolutionBasicTest {
assertNotNull(buildEffective);
}
- private void addSources(final BuildAction reactor, final YangStatementSourceImpl... sources) {
+ private static void addSources(final BuildAction reactor, final YangStatementSourceImpl... sources) {
for (YangStatementSourceImpl source : sources) {
reactor.addSource(source);
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-
import java.util.logging.Logger;
import org.junit.Test;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
}
- private void addSources(final BuildAction reactor, final YangStatementSourceImpl... sources) {
+ private static void addSources(final BuildAction reactor, final YangStatementSourceImpl... sources) {
for (YangStatementSourceImpl source : sources) {
reactor.addSource(source);
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-
-import java.io.IOException;
-
-import java.io.FileReader;
import java.io.BufferedReader;
import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.URISyntaxException;
import java.util.Set;
+import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import java.net.URISyntaxException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.junit.Test;
public class ModuleSourceTest {
assertEquals(readFile(moduleSourcePath), source);
}
- private String readFile(String fileName) throws IOException {
+ private static String readFile(final String fileName) throws IOException {
BufferedReader br = new BufferedReader(new FileReader(fileName));
try {
StringBuilder sb = new StringBuilder();
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import java.text.ParseException;
-import java.util.Date;
-import org.opendaylight.yangtools.yang.common.QName;
-import java.net.URI;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import java.io.FileNotFoundException;
+import java.net.URI;
import java.net.URISyntaxException;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import java.text.ParseException;
+import java.util.Date;
import java.util.Set;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.ModuleImport;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
}
}
- private void checkContentFullTest(SchemaContext context) throws ParseException,
+ private static void checkContentFullTest(final SchemaContext context) throws ParseException,
URISyntaxException {
String yangTypesNSStr = "urn:ietf:params:xml:ns:yang:ietf-yang-types";
}
- private void checkInterfacesModuleFullTest(SchemaContext context, Date rev20100924,
+ private static void checkInterfacesModuleFullTest(final SchemaContext context, final Date rev20100924,
final QName dateTimeTypeDef_20100924) throws URISyntaxException,
ParseException {
Date rev20121115 = SimpleDateFormatUtil.getRevisionFormat().parse(
assertEquals(rev20100924, interfacesImport.getRevision());
}
- private void checkNetconfMonitoringModuleFullTest(SchemaContext context,
- Date rev20130715, final QName dateTimeTypeDef_20130715)
+ private static void checkNetconfMonitoringModuleFullTest(final SchemaContext context,
+ final Date rev20130715, final QName dateTimeTypeDef_20130715)
throws ParseException, URISyntaxException {
Date rev20101004 = SimpleDateFormatUtil.getRevisionFormat().parse(
"2010-10-04");
}
}
- private void checkContentSimpleTest(SchemaContext context)
+ private static void checkContentSimpleTest(final SchemaContext context)
throws ParseException, URISyntaxException {
String yangTypesNSStr = "urn:ietf:params:xml:ns:yang:ietf-yang-types";
}
- private void checkInterfacesModuleSimpleTest(SchemaContext context,
- Date rev20100924, final QName dateTimeTypeDef_20100924)
+ private static void checkInterfacesModuleSimpleTest(final SchemaContext context,
+ final Date rev20100924, final QName dateTimeTypeDef_20100924)
throws URISyntaxException, ParseException {
String interfacesNSStr = "urn:ietf:params:xml:ns:yang:ietf-interfaces";
URI interfacesNS = new URI(interfacesNSStr);
assertEquals(rev20100924, interfacesImport.getRevision());
}
- private void checkNetconfMonitoringModuleSimpleTest(SchemaContext context,
- Date rev20130715, final QName dateTimeTypeDef_20130715)
+ private static void checkNetconfMonitoringModuleSimpleTest(final SchemaContext context,
+ final Date rev20130715, final QName dateTimeTypeDef_20130715)
throws ParseException, URISyntaxException {
String monitoringNSStr = "urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring";
URI monitoringNS = new URI(monitoringNSStr);
assertEquals(rev20130715, monitoringImport.getRevision());
}
- private boolean findTypeDef(Module module, QName typedef) {
+ private static boolean findTypeDef(final Module module, final QName typedef) {
Set<TypeDefinition<?>> typeDefinitions = module.getTypeDefinitions();
for (TypeDefinition<?> typeDefinition : typeDefinitions) {
if (typeDefinition.getQName().equals(typedef)) {
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-
import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.util.BooleanType;
+import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.util.Int16;
import org.opendaylight.yangtools.yang.model.util.Int32;
import org.opendaylight.yangtools.yang.model.util.Int64;
assertEquals(BooleanType.class, lfBoolNode.getType().getClass());
}
- private void addSources(CrossSourceStatementReactor.BuildAction reactor, StatementStreamSource... sources) {
+ private static void addSources(final CrossSourceStatementReactor.BuildAction reactor, final StatementStreamSource... sources) {
for (StatementStreamSource source : sources) {
reactor.addSource(source);
}
*/
package org.opendaylight.yangtools.yang.stmt.test;
+import static org.junit.Assert.assertNotNull;
import org.junit.Test;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangStatementSourceImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
-import static org.junit.Assert.assertNotNull;
-
public class YangTypesStmtTest {
private static final YangStatementSourceImpl TYPEFILE1 = new YangStatementSourceImpl
assertNotNull(result);
}
- private void addSources(CrossSourceStatementReactor.BuildAction reactor, StatementStreamSource... sources) {
+ private static void addSources(final CrossSourceStatementReactor.BuildAction reactor, final StatementStreamSource... sources) {
for (StatementStreamSource source : sources) {
reactor.addSource(source);
}
Code Review / yangtools.git / commitdiff