private static boolean containsPresenceSubStmt(final StmtContext<?, ?, ?> stmtCtx) { return findFirstSubstatement(stmtCtx, PresenceStatement.class) != null; }
@Override public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) { return StmtContextUtils.parseIdentifier(ctx, value); }
@SuppressWarnings("unchecked") public static <A, D extends DeclaredStatement<A>> A firstAttributeOf(final StmtContext<?, ?, ?> ctx, final Class<D> declaredType) { return producesDeclared(ctx, declaredType) ? (A) ctx.getStatementArgument() : null; }
/** * Searches for the first substatement of the specified type in the specified statement context. * First, it tries to find the substatement in the effective substatements of the statement context. * If it was not found, then it proceeds to search in the declared substatements. If it still was not found, * the method returns null. * * @param stmtContext statement context to search in * @param declaredType substatement type to search for * @param <A> statement argument type * @param <D> declared statement type * @return statement context that was searched for or null if was not found */ public static <A, D extends DeclaredStatement<A>> StmtContext<A, ?, ?> findFirstSubstatement( final StmtContext<?, ?, ?> stmtContext, final Class<D> declaredType) { final StmtContext<A, ?, ?> effectiveSubstatement = findFirstEffectiveSubstatement(stmtContext, declaredType); return effectiveSubstatement != null ? effectiveSubstatement : findFirstDeclaredSubstatement(stmtContext, declaredType); }
public static <A, D extends DeclaredStatement<A>> Collection<StmtContext<A, D, ?>> findAllSubstatements( final StmtContext<?, ?, ?> stmtContext, final Class<D> type) { final ImmutableList.Builder<StmtContext<A, D, ?>> listBuilder = ImmutableList.builder(); listBuilder.addAll(findAllDeclaredSubstatements(stmtContext, type)); listBuilder.addAll(findAllEffectiveSubstatements(stmtContext, type)); return listBuilder.build(); }
public static <D extends DeclaredStatement<?>> StmtContext<?, ?, ?> findDeepFirstDeclaredSubstatement( final StmtContext<?, ?, ?> stmtContext, final Class<D> declaredType) { for (final StmtContext<?, ?, ?> subStmtContext : stmtContext.declaredSubstatements()) { if (producesDeclared(subStmtContext, declaredType)) { return subStmtContext; } final StmtContext<?, ?, ?> result = findDeepFirstDeclaredSubstatement(subStmtContext, declaredType); if (result != null) { return result; } } return null; }
case 1: localName = namesParts[0]; qnameModule = StmtContextUtils.getRootModuleQName(ctx); break; default: prefix = namesParts[0]; localName = namesParts[1]; qnameModule = StmtContextUtils.getModuleQNameByPrefix(ctx, prefix); if (qnameModule == null && isUnknownStatement(ctx)) { localName = value; qnameModule = StmtContextUtils.getRootModuleQName(ctx); qnameModule = StmtContextUtils.getModuleQNameByPrefix(ctx, prefix); return internedQName(ctx, InferenceException.throwIfNull(qnameModule, ctx.getStatementSourceReference(), "Cannot resolve QNameModule for '%s'", value), localName);
final SchemaPath parentPath = maybeParentPath.get(); if (StmtContextUtils.isUnknownStatement(this)) { return parentPath.createChild(getPublicDefinition().getStatementName()); if (StmtContextUtils.producesDeclared(this, UsesStatement.class)) { return maybeParentPath.orElse(null); if ((StmtContextUtils.producesDeclared(parent, ChoiceStatement.class) || Boolean.TRUE.equals(parent.getFromNamespace(AugmentToChoiceNamespace.class, parent))) && isSupportedAsShorthandCase()) { final QName qname = StmtContextUtils.qnameFromArgument(originalCtx.orElse(this), (String) argument); return parentPath.createChild(qname); && (StmtContextUtils.producesDeclared(this, AugmentStatement.class) || StmtContextUtils.producesDeclared(this, RefineStatement.class) || StmtContextUtils.producesDeclared(this, DeviationStatement.class))) {
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); }
/** * Validates the specified statement context with regards to if-feature and when statement on list keys. * The context can either be a leaf which is defined directly in the substatements of a keyed list or a uses * statement defined in a keyed list (a uses statement may add leaves into the list). * * <p> * If one of the list keys contains an if-feature or a when statement in YANG 1.1 model, an exception is thrown. * * @param ctx statement context to be validated */ public static void validateIfFeatureAndWhenOnListKeys(final StmtContext<?, ?, ?> ctx) { if (!isRelevantForIfFeatureAndWhenOnListKeysCheck(ctx)) { return; } final StmtContext<?, ?, ?> listStmtCtx = ctx.getParentContext(); final StmtContext<Collection<SchemaNodeIdentifier>, ?, ?> keyStmtCtx = StmtContextUtils.findFirstDeclaredSubstatement(listStmtCtx, KeyStatement.class); if (YangStmtMapping.LEAF.equals(ctx.getPublicDefinition())) { if (isListKey(ctx, keyStmtCtx)) { disallowIfFeatureAndWhenOnListKeys(ctx); } } else if (YangStmtMapping.USES.equals(ctx.getPublicDefinition())) { StmtContextUtils.findAllEffectiveSubstatements(listStmtCtx, LeafStatement.class).forEach(leafStmtCtx -> { if (isListKey(leafStmtCtx, keyStmtCtx)) { disallowIfFeatureAndWhenOnListKeys(leafStmtCtx); } }); } }
@SafeVarargs public static StmtContext<?, ?, ?> findFirstDeclaredSubstatement(final StmtContext<?, ?, ?> stmtContext, int startIndex, final Class<? extends DeclaredStatement<?>>... types) { if (startIndex >= types.length) { return null; } for (final StmtContext<?, ?, ?> subStmtContext : stmtContext.declaredSubstatements()) { if (producesDeclared(subStmtContext, types[startIndex])) { return startIndex + 1 == types.length ? subStmtContext : findFirstDeclaredSubstatement(subStmtContext, ++startIndex, types); } } return null; }
@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); } }
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; }
@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)); }
Effective(final StmtContext<String, AnnotationStatement, ?> ctx) { super(ctx); path = ctx.coerceParentContext().getSchemaPath().get().createChild( StmtContextUtils.parseIdentifier(ctx, argument())); final TypeEffectiveStatement<?> typeStmt = SourceException.throwIfNull( firstSubstatementOfType(TypeEffectiveStatement.class), ctx.getStatementSourceReference(), "AnnotationStatementSupport %s is missing a 'type' statement", argument()); final ConcreteTypeBuilder<?> builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(), path); final StmtContext<String, ?, ?> unitsStmt = StmtContextUtils.findFirstEffectiveSubstatement(ctx, UnitsStatement.class); if (unitsStmt != null) { builder.setUnits(unitsStmt.getStatementArgument()); } type = builder.build(); }
@Override public final void onFullDefinitionDeclared( final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) { super.onFullDefinitionDeclared(stmt); if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) { ((StatementContextBase<?, ?, ?>) stmt).appendImplicitStatement(implictInput()); } if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, OutputStatement.class) == null) { ((StatementContextBase<?, ?, ?>) stmt).appendImplicitStatement(implictOutput()); } }
public static <D extends DeclaredStatement<?>> StmtContext<?, ?, ?> findFirstDeclaredSubstatementOnSublevel( final StmtContext<?, ?, ?> stmtContext, final Class<D> declaredType, int sublevel) { for (final StmtContext<?, ?, ?> subStmtContext : stmtContext.declaredSubstatements()) { if (sublevel == 1 && producesDeclared(subStmtContext, declaredType)) { return subStmtContext; } if (sublevel > 1) { final StmtContext<?, ?, ?> result = findFirstDeclaredSubstatementOnSublevel(subStmtContext, declaredType, --sublevel); if (result != null) { return result; } } } return null; }
public static <A, D extends DeclaredStatement<A>> A firstSubstatementAttributeOf( final StmtContext<?, ?, ?> ctx, final Class<D> declaredType) { return firstAttributeOf(ctx.allSubstatements(), declaredType); }
private static boolean isRelevantForIfFeatureAndWhenOnListKeysCheck(final StmtContext<?, ?, ?> ctx) { return YangVersion.VERSION_1_1.equals(ctx.getRootVersion()) && StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.LIST) && StmtContextUtils.findFirstDeclaredSubstatement(ctx.coerceParentContext(), KeyStatement.class) != null; }
checkIdentifierString(ctx, str); return internedQName(ctx, str); SourceException.throwIf(localName.isEmpty(), ctx.getStatementSourceReference(), "String '%s' has an empty identifier", str); checkIdentifierString(ctx, localName); final QNameModule module = StmtContextUtils.getModuleQNameByPrefix(ctx, prefix); if (module != null) { return internedQName(ctx, module, localName); if (optOrigCtx.isPresent()) { ctx = optOrigCtx.get(); final QNameModule origModule = StmtContextUtils.getModuleQNameByPrefix(ctx, prefix); if (origModule != null) { return internedQName(ctx, origModule, localName);