revisionDate); stmt.addContext(ModuleNamespace.class, moduleIdentifier, stmt); stmt.addContext(ModuleNamespaceForBelongsTo.class, moduleIdentifier.getName(), stmt); stmt.addContext(NamespaceToModule.class, qNameModule, stmt);
@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 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); } }
@Override public void onStatementDefinitionDeclared( final Mutable<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> stmt) { super.onStatementDefinitionDeclared(stmt); QName stmtName = stmt.coerceStatementArgument(); if (OpenConfigStatements.OPENCONFIG_VERSION.getStatementName().isEqualWithoutRevision(stmtName)) { stmtName = stmtName.withoutRevision(); } stmt.addContext(ExtensionNamespace.class, stmtName, stmt); final StmtContext<QName, ?, ?> argument = StmtContextUtils.findFirstDeclaredSubstatement(stmt, ArgumentStatement.class); final StmtContext<Boolean, ?, ?> yinElement = StmtContextUtils.findFirstDeclaredSubstatement(stmt, YinElementStatement.class); stmt.addToNs(StatementDefinitionNamespace.class, stmt.getStatementArgument(), new ModelDefinedStatementSupport(new ModelDefinedStatementDefinition(stmt.getStatementArgument(), argument != null ? argument.getStatementArgument() : null, yinElement != null ? yinElement.getStatementArgument() : false))); }
@Override public void onFullDefinitionDeclared(final Mutable<QName, TypedefStatement, EffectiveStatement<QName, TypedefStatement>> stmt) { super.onFullDefinitionDeclared(stmt); if (stmt != null) { final Mutable<?, ?, ?> parent = stmt.getParentContext(); if (parent != null) { // Shadowing check: make sure we do not trample on pre-existing definitions. This catches sibling // declarations and parent declarations which have already been declared. checkConflict(parent, stmt); parent.addContext(TypeNamespace.class, stmt.coerceStatementArgument(), stmt); } } }
@Override public final void onFullDefinitionDeclared(final Mutable<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> stmt) { super.onFullDefinitionDeclared(stmt); if (stmt != null) { final Mutable<?, ?, ?> parent = stmt.getParentContext(); if (parent != null) { // Shadowing check: make sure we do not trample on pre-existing definitions. This catches sibling // declarations and parent declarations which have already been declared. checkConflict(parent, stmt); parent.addContext(GroupingNamespace.class, stmt.coerceStatementArgument(), stmt); } } }