private static Optional<SemVer> getRequestedImportVersion(final StmtContext<?, ?, ?> stmt) { return Optional.ofNullable(stmt.getFromNamespace(SemanticVersionNamespace.class, stmt)); }
private static QName internedQName(final StmtContext<?, ?, ?> ctx, final QNameModule module, final String localName) { return ctx.getFromNamespace(QNameCacheNamespace.class, QName.create(module, localName)); }
public static QNameModule getModuleQNameByPrefix(final StmtContext<?, ?, ?> ctx, final String prefix) { final StmtContext<?, ?, ?> importedModule = ctx.getRoot().getFromNamespace(ImportPrefixToModuleCtx.class, prefix); final QNameModule qnameModule = ctx.getFromNamespace(ModuleCtxToModuleQName.class, importedModule); if (qnameModule != null) { return qnameModule; } if (producesDeclared(ctx.getRoot(), SubmoduleStatement.class)) { final String moduleName = ctx.getRoot().getFromNamespace(BelongsToPrefixToModuleName.class, prefix); return ctx.getFromNamespace(ModuleNameToModuleQName.class, moduleName); } return null; }
static boolean isSupportedAugmentTarget(final StmtContext<?, ?, ?> substatementCtx) { /* * :TODO Substatement must be allowed augment target type e.g. * Container, etc... and must not be for example grouping, identity etc. * It is problem in case when more than one substatements have the same * QName, for example Grouping and Container are siblings and they have * the same QName. We must find the Container and the Grouping must be * ignored as disallowed augment target. */ final Collection<?> allowedAugmentTargets = substatementCtx.getFromNamespace( ValidationBundlesNamespace.class, ValidationBundleType.SUPPORTED_AUGMENT_TARGETS); // if no allowed target is returned we consider all targets allowed return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty() || allowedAugmentTargets.contains(substatementCtx.getPublicDefinition()); } }
@Override public String getPrefix(final String namespaceURI) { // API-mandated by NamespaceContext checkArgument(namespaceURI != null); final String prefix = uriToPrefix.get(namespaceURI); if (prefix != null) { return prefix; } if (localNamespaceURI().equals(namespaceURI)) { return ""; } return ctx.getFromNamespace(URIStringToImportPrefix.class, namespaceURI); }
private static boolean isSupportedRefineSubstatement(final StmtContext<?, ?, ?> refineSubstatementCtx) { final Collection<?> supportedRefineSubstatements = refineSubstatementCtx.getFromNamespace( ValidationBundlesNamespace.class, ValidationBundleType.SUPPORTED_REFINE_SUBSTATEMENTS); return supportedRefineSubstatements == null || supportedRefineSubstatements.isEmpty() || supportedRefineSubstatements.contains(refineSubstatementCtx.getPublicDefinition()) || StmtContextUtils.isUnknownStatement(refineSubstatementCtx); }
@Override public QName adaptArgumentValue(final StmtContext<QName, D, E> ctx, final QNameModule targetModule) { return ctx.getFromNamespace(QNameCacheNamespace.class, ctx.getStatementArgument().withModule(targetModule)); } }
IdentityEffectiveStatementImpl( final StmtContext<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> ctx) { super(ctx); this.baseIdentities = new HashSet<>(); ((StmtContext.Mutable<?, ?, ?>) ctx).addMutableStmtToSeal(this); // initDerivedIdentities final Set<IdentitySchemaNode> derivedIdentitiesInit = new HashSet<>(); final List<StmtContext<?, ?, ?>> derivedIdentitiesCtxList = ctx.getFromNamespace( DerivedIdentitiesNamespace.class, ctx.coerceStatementArgument()); if (derivedIdentitiesCtxList == null) { this.derivedIdentities = ImmutableSet.of(); return; } for (final StmtContext<?, ?, ?> derivedIdentityCtx : derivedIdentitiesCtxList) { final IdentityEffectiveStatementImpl derivedIdentity = (IdentityEffectiveStatementImpl) derivedIdentityCtx .buildEffective(); derivedIdentity.addBaseIdentity(this); derivedIdentitiesInit.add(derivedIdentity); } this.derivedIdentities = ImmutableSet.copyOf(derivedIdentitiesInit); }
public static QNameModule getRootModuleQName(final StmtContext<?, ?, ?> ctx) { if (ctx == null) { return null; } final StmtContext<?, ?, ?> rootCtx = ctx.getRoot(); final QNameModule qnameModule; if (producesDeclared(rootCtx, ModuleStatement.class)) { qnameModule = rootCtx.getFromNamespace(ModuleCtxToModuleQName.class, rootCtx); } else if (producesDeclared(rootCtx, SubmoduleStatement.class)) { final String belongsToModuleName = firstAttributeOf(rootCtx.declaredSubstatements(), BelongsToStatement.class); qnameModule = rootCtx.getFromNamespace(ModuleNameToModuleQName.class, belongsToModuleName); } else { qnameModule = null; } checkArgument(qnameModule != null, "Failed to look up root QNameModule for %s", ctx); return qnameModule; }
private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) { final QName arg = stmt.coerceStatementArgument(); final StmtContext<?, ?, ?> existing = parent.getFromNamespace(GroupingNamespace.class, arg); SourceException.throwIf(existing != null, stmt.getStatementSourceReference(), "Duplicate name for grouping %s", arg); } }
static final SchemaPath typeEffectiveSchemaPath(final StmtContext<?, ?, ?> stmtCtx) { final SchemaPath path = stmtCtx.getSchemaPath().get(); final SchemaPath parent = path.getParent(); final QName parentQName = parent.getLastComponent(); Preconditions.checkArgument(parentQName != null, "Path %s has an empty parent", path); final QName qname = stmtCtx.getFromNamespace(QNameCacheNamespace.class, QName.create(parentQName, path.getLastComponent().getLocalName())); return parent.createChild(qname); } }
private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) { final QName arg = stmt.coerceStatementArgument(); final StmtContext<?, ?, ?> existing = parent.getFromNamespace(TypeNamespace.class, arg); // RFC7950 sections 5.5 and 6.2.1: identifiers must not be shadowed SourceException.throwIf(existing != null, stmt.getStatementSourceReference(), "Duplicate name for typedef %s", arg); } }
ImportEffectiveStatementImpl(final StmtContext<String, ImportStatement, ?> ctx) { super(ctx); moduleName = ctx.coerceStatementArgument(); final Optional<String> prefixStmt = findFirstEffectiveSubstatementArgument(PrefixEffectiveStatement.class); MissingSubstatementException.throwIf(!prefixStmt.isPresent(), ctx.getStatementSourceReference(), "Prefix is mandatory substatement of import statement"); this.prefix = prefixStmt.get(); if (!ctx.isEnabledSemanticVersioning()) { final Optional<Revision> optRev = findFirstEffectiveSubstatementArgument( RevisionDateEffectiveStatement.class); this.revision = optRev.isPresent() ? optRev.get() : getImportedRevision(ctx); this.semVer = null; } else { final SemVerSourceIdentifier importedModuleIdentifier = ctx.getFromNamespace( ImportPrefixToSemVerSourceIdentifier.class, prefix); revision = importedModuleIdentifier.getRevision().orElse(null); semVer = importedModuleIdentifier.getSemanticVersion().orElse(null); } description = findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class).orElse(null); reference = findFirstEffectiveSubstatementArgument(ReferenceEffectiveStatement.class).orElse(null); }
@Override public Collection<SchemaNodeIdentifier> adaptArgumentValue( final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> ctx, final QNameModule targetModule) { final Builder<SchemaNodeIdentifier> builder = ImmutableSet.builder(); boolean replaced = false; for (final SchemaNodeIdentifier arg : ctx.coerceStatementArgument()) { final QName qname = arg.getLastComponent(); if (!targetModule.equals(qname.getModule())) { final QName newQname = ctx.getFromNamespace(QNameCacheNamespace.class, qname.withModule(targetModule)); builder.add(SchemaNodeIdentifier.SAME.createChild(newQname)); replaced = true; } else { builder.add(arg); } } // This makes sure we reuse the collection when a grouping is // instantiated in the same module return replaced ? builder.build() : ctx.getStatementArgument(); }
SubmoduleEffectiveStatementImpl( final StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) { super(ctx); final String belongsToModuleName = firstAttributeOf(ctx.declaredSubstatements(), BelongsToStatement.class); final QNameModule belongsToModuleQName = ctx.getFromNamespace(ModuleNameToModuleQName.class, belongsToModuleName); final Optional<Revision> submoduleRevision = findFirstEffectiveSubstatementArgument( RevisionEffectiveStatement.class); this.qnameModule = QNameModule.create(belongsToModuleQName.getNamespace(), submoduleRevision).intern(); }
@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); }
IdentityRefSpecificationEffectiveStatement(final StmtContext<String, IdentityRefSpecification, EffectiveStatement<String, IdentityRefSpecification>> ctx) { super(ctx); final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(ctx.getSchemaPath().get()); for (final EffectiveStatement<?, ?> stmt : effectiveSubstatements()) { if (stmt instanceof BaseEffectiveStatement) { final QName identityQName = ((BaseEffectiveStatement) stmt).argument(); final StmtContext<?, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> identityCtx = ctx.getFromNamespace(IdentityNamespace.class, identityQName); builder.addIdentity((IdentitySchemaNode) identityCtx.buildEffective()); } if (stmt instanceof UnknownSchemaNode) { builder.addUnknownSchemaNode((UnknownSchemaNode)stmt); } } typeDefinition = builder.build(); }
private static QNameModule getNewQNameModule(final StmtContext<?, ?, ?> targetCtx, final StmtContext<?, ?, ?> stmtContext) { if (targetCtx.getParentContext() == null) { return targetCtx.getFromNamespace(ModuleCtxToModuleQName.class, targetCtx); } if (targetCtx.getPublicDefinition() == YangStmtMapping.AUGMENT) { return StmtContextUtils.getRootModuleQName(targetCtx); } final Object targetStmtArgument = targetCtx.getStatementArgument(); final Object sourceStmtArgument = stmtContext.getStatementArgument(); if (targetStmtArgument instanceof QName && sourceStmtArgument instanceof QName) { return ((QName) targetStmtArgument).getModule(); } return null; } }
public static SourceIdentifier createSourceIdentifier(final StmtContext<?, ?, ?> root) { final QNameModule qNameModule = root.getFromNamespace(ModuleCtxToModuleQName.class, root); if (qNameModule != null) { // creates SourceIdentifier for a module return RevisionSourceIdentifier.create((String) root.getStatementArgument(), qNameModule.getRevision()); } // creates SourceIdentifier for a submodule final Optional<Revision> revision = getLatestRevision(root.declaredSubstatements()); return RevisionSourceIdentifier.create((String) root.getStatementArgument(), revision); }
@Override public void apply(final InferenceContext ctx) { final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx); final SemVer importedVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt); final SourceIdentifier importedModuleIdentifier = importedModule.getFromNamespace( ModuleCtxToSourceIdentifier.class, importedModule); final SemVerSourceIdentifier semVerModuleIdentifier = createSemVerModuleIdentifier( importedModuleIdentifier, importedVersion); linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier, importedModule); final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class); stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule); stmt.addToNs(ImportPrefixToSemVerSourceIdentifier.class, impPrefix, semVerModuleIdentifier); final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(), NamespaceStatement.class); stmt.addToNs(URIStringToImportPrefix.class, modNs.toString(), impPrefix); }