@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { if (failed.contains(imported)) { throw new InferenceException(stmt.getStatementSourceReference(), "Unable to find module compatible with requested import [%s(%s)].", moduleName, getRequestedImportVersionString(stmt)); } } });
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { InferenceException.throwIf(failed.contains(typePrereq), stmt.getStatementSourceReference(), "Type [%s] was not found.", typeQName); } });
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { if (failed.contains(imported)) { throw new InferenceException(stmt.getStatementSourceReference(), "Imported module [%s] was not found.", moduleName); } } });
LOG.error("Deviation cannot replace substatement {} in target leaf-list {} because a leaf-list can " + "have multiple default statements. At line: {}", stmtToBeReplaced.getStatementName(), targetCtx.getStatementArgument(), stmtCtxToBeReplaced.getStatementSourceReference()); return; throw new InferenceException(stmtCtxToBeReplaced.getStatementSourceReference(), "Deviation cannot replace " + "substatement %s in target node %s because it does not exist in target node.", stmtToBeReplaced.getStatementName(), targetCtx.getStatementArgument());
private static void performRefine(final Mutable<?, ?, ?> subStmtCtx, final StmtContext<?, ?, ?> usesParentCtx) { final Object refineArgument = subStmtCtx.getStatementArgument(); InferenceException.throwIf(!(refineArgument instanceof SchemaNodeIdentifier), subStmtCtx.getStatementSourceReference(), "Invalid refine argument %s. It must be instance of SchemaNodeIdentifier.", refineArgument); final Optional<StmtContext<?, ?, ?>> optRefineTargetCtx = ChildSchemaNodeNamespace.findNode( usesParentCtx, (SchemaNodeIdentifier) refineArgument); InferenceException.throwIf(!optRefineTargetCtx.isPresent(), subStmtCtx.getStatementSourceReference(), "Refine target node %s not found.", refineArgument); final StmtContext<?, ?, ?> refineTargetNodeCtx = optRefineTargetCtx.get(); if (StmtContextUtils.isUnknownStatement(refineTargetNodeCtx)) { LOG.trace("Refine node '{}' in uses '{}' has target node unknown statement '{}'. " + "Refine has been skipped. At line: {}", subStmtCtx.getStatementArgument(), subStmtCtx.coerceParentContext().getStatementArgument(), refineTargetNodeCtx.getStatementArgument(), subStmtCtx.getStatementSourceReference()); subStmtCtx.addAsEffectOfStatement(refineTargetNodeCtx); return; } Verify.verify(refineTargetNodeCtx instanceof StatementContextBase); addOrReplaceNodes(subStmtCtx, (StatementContextBase<?, ?, ?>) refineTargetNodeCtx); subStmtCtx.addAsEffectOfStatement(refineTargetNodeCtx); }
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { /* * Do not fail, if it is an uses-augment to an unknown node. */ if (YangStmtMapping.USES == augmentNode.coerceParentContext().getPublicDefinition()) { final SchemaNodeIdentifier augmentArg = augmentNode.coerceStatementArgument(); final Optional<StmtContext<?, ?, ?>> targetNode = ChildSchemaNodeNamespace.findNode( getSearchRoot(augmentNode), augmentArg); if (targetNode.isPresent() && StmtContextUtils.isUnknownStatement(targetNode.get())) { augmentNode.setIsSupportedToBuildEffective(false); LOG.warn("Uses-augment to unknown node {}. Augmentation has not been performed. At line: {}", augmentArg, augmentNode.getStatementSourceReference()); return; } } throw new InferenceException(augmentNode.getStatementSourceReference(), "Augment target '%s' not found", augmentNode.getStatementArgument()); } });
@Override public final void onLinkageDeclared( final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) { final SourceIdentifier submoduleIdentifier = RevisionSourceIdentifier.create(stmt.coerceStatementArgument(), StmtContextUtils.getLatestRevision(stmt.declaredSubstatements())); final StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> possibleDuplicateSubmodule = stmt.getFromNamespace(SubmoduleNamespace.class, submoduleIdentifier); if (possibleDuplicateSubmodule != null && possibleDuplicateSubmodule != stmt) { throw new SourceException(stmt.getStatementSourceReference(), "Submodule name collision: %s. At %s", stmt.getStatementArgument(), possibleDuplicateSubmodule.getStatementSourceReference()); } stmt.addContext(SubmoduleNamespace.class, submoduleIdentifier, stmt); final String belongsToModuleName = firstAttributeOf(stmt.declaredSubstatements(), BelongsToStatement.class); final StmtContext<?, ?, ?> prefixSubStmtCtx = findFirstDeclaredSubstatement(stmt, 0, BelongsToStatement.class, PrefixStatement.class); SourceException.throwIfNull(prefixSubStmtCtx, stmt.getStatementSourceReference(), "Prefix of belongsTo statement is missing in submodule [%s]", stmt.getStatementArgument()); final String prefix = (String) prefixSubStmtCtx.getStatementArgument(); stmt.addToNs(BelongsToPrefixToModuleName.class, prefix, belongsToModuleName); } }
private static void addStatement(final Mutable<?, ?, ?> stmtCtxToBeAdded, final StatementContextBase<?, ?, ?> targetCtx) { if (!StmtContextUtils.isUnknownStatement(stmtCtxToBeAdded)) { final StatementDefinition stmtToBeAdded = stmtCtxToBeAdded.getPublicDefinition(); if (SINGLETON_STATEMENTS.contains(stmtToBeAdded) || YangStmtMapping.DEFAULT.equals(stmtToBeAdded) && YangStmtMapping.LEAF.equals(targetCtx.getPublicDefinition())) { for (final StmtContext<?, ?, ?> targetCtxSubstatement : targetCtx.allSubstatements()) { InferenceException.throwIf(stmtToBeAdded.equals(targetCtxSubstatement.getPublicDefinition()), stmtCtxToBeAdded.getStatementSourceReference(), "Deviation cannot add substatement %s to target node %s because it is already defined " + "in target and can appear only once.", stmtToBeAdded.getStatementName(), targetCtx.getStatementArgument()); } } } copyStatement(stmtCtxToBeAdded, targetCtx); }
@Override public final void onPreLinkageDeclared(final Mutable<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> stmt) { final String moduleName = stmt.getStatementArgument(); final URI moduleNs = firstAttributeOf(stmt.declaredSubstatements(), NamespaceStatement.class); SourceException.throwIfNull(moduleNs, stmt.getStatementSourceReference(), "Namespace of the module [%s] is missing", stmt.getStatementArgument()); stmt.addToNs(ModuleNameToNamespace.class, moduleName, moduleNs); final String modulePrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class); SourceException.throwIfNull(modulePrefix, stmt.getStatementSourceReference(), "Prefix of the module [%s] is missing", stmt.getStatementArgument()); stmt.addToNs(ImpPrefixToNamespace.class, modulePrefix, moduleNs); stmt.addContext(PreLinkageModuleNamespace.class, moduleName, stmt); final Optional<Revision> revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()); final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate.orElse(null)).intern(); stmt.addToNs(ModuleCtxToModuleQName.class, stmt, qNameModule); stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.getStatementArgument(), revisionDate)); }
@Override public final void onFullDefinitionDeclared(final Mutable<String, IdentityRefSpecification, EffectiveStatement<String, IdentityRefSpecification>> stmt) { super.onFullDefinitionDeclared(stmt); final Collection<StmtContext<QName, BaseStatement, ?>> baseStatements = StmtContextUtils.findAllDeclaredSubstatements(stmt, BaseStatement.class); for (StmtContext<QName, BaseStatement, ?> baseStmt : baseStatements) { final QName baseIdentity = baseStmt.coerceStatementArgument(); final StmtContext<?, ?, ?> stmtCtx = stmt.getFromNamespace(IdentityNamespace.class, baseIdentity); InferenceException.throwIfNull(stmtCtx, stmt.getStatementSourceReference(), "Referenced base identity '%s' doesn't exist in given scope (module, imported modules, submodules)", baseIdentity.getLocalName()); } } }
private static void addOrReplaceNode(final Mutable<?, ?, ?> refineSubstatementCtx, final StatementContextBase<?, ?, ?> refineTargetNodeCtx) { final StatementDefinition refineSubstatementDef = refineSubstatementCtx.getPublicDefinition(); SourceException.throwIf(!isSupportedRefineTarget(refineSubstatementCtx, refineTargetNodeCtx), refineSubstatementCtx.getStatementSourceReference(), "Error in module '%s' in the refine of uses '%s': can not perform refine of '%s' for the target '%s'.", refineSubstatementCtx.getRoot().getStatementArgument(), refineSubstatementCtx.coerceParentContext().getStatementArgument(), refineSubstatementCtx.getPublicDefinition(), refineTargetNodeCtx.getPublicDefinition()); if (isAllowedToAddByRefine(refineSubstatementDef)) { refineTargetNodeCtx.addEffectiveSubstatement(refineSubstatementCtx); } else { refineTargetNodeCtx.removeStatementFromEffectiveSubstatements(refineSubstatementDef); refineTargetNodeCtx.addEffectiveSubstatement(refineSubstatementCtx); } }
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { InferenceException.throwIf(failed.contains(sourceGroupingPre), usesNode.getStatementSourceReference(), "Grouping '%s' was not resolved.", groupingName); throw new InferenceException("Unknown error occurred.", usesNode.getStatementSourceReference()); } });
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { throw new InferenceException(baseStmtCtx.getStatementSourceReference(), "Unable to resolve identity %s and base identity %s", baseParentCtx.getStatementArgument(), baseStmtCtx.getStatementArgument()); } });
@Override public void onFullDefinitionDeclared(final StmtContext.Mutable<SchemaNodeIdentifier, DeviationStatement, EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> ctx) { final QNameModule currentModule = ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot()); final QNameModule targetModule = ctx.coerceStatementArgument().getLastComponent().getModule(); if (currentModule.equals(targetModule)) { throw new InferenceException(ctx.getStatementSourceReference(), "Deviation must not target the same module as the one it is defined in: %s", currentModule); } }
@Override public void onStatementAdded(final Mutable<String, AnnotationStatement, AnnotationEffectiveStatement> stmt) { final StatementDefinition parentDef = stmt.coerceParentContext().getPublicDefinition(); SourceException.throwIf(YangStmtMapping.MODULE != parentDef && YangStmtMapping.SUBMODULE != parentDef, stmt.getStatementSourceReference(), "Annotations may only be defined at root of either a module or a submodule"); }
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { InferenceException.throwIf(failed.contains(imported), stmt.getStatementSourceReference(), "Imported module [%s] was not found.", moduleName); } });
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { InferenceException.throwIf(failed.contains(requiresCtxPrerequisite), stmt.getStatementSourceReference(), "Included submodule '%s' was not found: ", stmt.getStatementArgument()); } });
@Override public void apply(final InferenceContext ctx) { final StmtContext<?, ?, ?> importedModuleContext = imported.resolve(ctx); Verify.verify(moduleName.equals(importedModuleContext.getStatementArgument())); final URI importedModuleNamespace = importedModuleContext.getFromNamespace(ModuleNameToNamespace.class, moduleName); Verify.verifyNotNull(importedModuleNamespace); final String impPrefix = SourceException.throwIfNull( firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class), stmt.getStatementSourceReference(), "Missing prefix statement"); stmt.addToNs(ImpPrefixToNamespace.class, impPrefix, importedModuleNamespace); }
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { throw new InferenceException(deviateStmtCtx.coerceParentContext().getStatementSourceReference(), "Deviation target '%s' not found.", deviationTarget); } });
@Override public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) { if (failed.contains(belongsToPrereq)) { throw new InferenceException(belongsToCtx.getStatementSourceReference(), "Module '%s' from belongs-to was not found", belongsToCtx.getStatementArgument()); } } });