@SuppressWarnings("unchecked") public static <A, D extends DeclaredStatement<A>> StmtContext<A, ?, ?> findFirstDeclaredSubstatement( final StmtContext<?, ?, ?> stmtContext, final Class<D> declaredType) { for (final StmtContext<?, ?, ?> subStmtContext : stmtContext.declaredSubstatements()) { if (producesDeclared(subStmtContext, declaredType)) { return (StmtContext<A, ?, ?>) subStmtContext; } } return null; }
@SuppressWarnings("unchecked") public static <A, D extends DeclaredStatement<A>> Collection<StmtContext<A, D, ?>> findAllDeclaredSubstatements( final StmtContext<?, ?, ?> stmtContext, final Class<D> declaredType) { final ImmutableList.Builder<StmtContext<A, D, ?>> listBuilder = ImmutableList.builder(); for (final StmtContext<?, ?, ?> subStmtContext : stmtContext.declaredSubstatements()) { if (producesDeclared(subStmtContext, declaredType)) { listBuilder.add((StmtContext<A, D, ?>) subStmtContext); } } return listBuilder.build(); }
default Iterable<? extends StmtContext<?, ?, ?>> allSubstatements() { return Iterables.concat(declaredSubstatements(), effectiveSubstatements()); }
default Stream<? extends StmtContext<?, ?, ?>> allSubstatementsStream() { return Streams.concat(declaredSubstatements().stream(), effectiveSubstatements().stream()); }
@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; }
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; }
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; }
protected AbstractDeclaredStatement(final StmtContext<A, ?, ?> context) { rawArgument = context.rawStatementArgument(); argument = context.getStatementArgument(); source = context.getStatementSource(); definition = context.getPublicDefinition(); /* * Perform an explicit copy, because Collections2.transform() is lazily transformed and retains pointer to * original collection, which may contains references to mutable context. */ substatements = ImmutableList.copyOf(Collections2.transform(context.declaredSubstatements(), StmtContext::buildDeclared)); }
/** * Constructor. * * @param ctx context of statement. */ protected EffectiveStatementBase(final StmtContext<A, D, ?> ctx) { final Collection<? extends StmtContext<?, ?, ?>> effectiveSubstatements = ctx.effectiveSubstatements(); final Collection<StmtContext<?, ?, ?>> substatementsInit = new ArrayList<>(); final Collection<? extends StmtContext<?, ?, ?>> supportedDeclaredSubStmts = Collections2.filter( ctx.declaredSubstatements(), StmtContext::isSupportedByFeatures); for (final StmtContext<?, ?, ?> declaredSubstatement : supportedDeclaredSubStmts) { if (YangStmtMapping.USES == declaredSubstatement.getPublicDefinition()) { substatementsInit.add(declaredSubstatement); substatementsInit.addAll(declaredSubstatement.getEffectOfStatement()); ((StatementContextBase<?, ?, ?>) ctx).removeStatementsFromEffectiveSubstatements(declaredSubstatement .getEffectOfStatement()); } else { substatementsInit.add(declaredSubstatement); } } substatementsInit.addAll(effectiveSubstatements); this.substatements = ImmutableList.copyOf(initSubstatements(substatementsInit)); }
public static boolean checkFeatureSupport(final StmtContext<?, ?, ?> stmtContext, final Set<QName> supportedFeatures) { boolean isSupported = false; boolean containsIfFeature = false; for (final StmtContext<?, ?, ?> stmt : stmtContext.declaredSubstatements()) { if (YangStmtMapping.IF_FEATURE.equals(stmt.getPublicDefinition())) { containsIfFeature = true; @SuppressWarnings("unchecked") final Predicate<Set<QName>> argument = (Predicate<Set<QName>>) stmt.coerceStatementArgument(); if (argument.test(supportedFeatures)) { isSupported = true; } else { isSupported = false; break; } } } return !containsIfFeature || isSupported; }
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; }
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<?, ?, ?> importedModule = imported.resolve(ctx); linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, stmt.getFromNamespace(ModuleCtxToSourceIdentifier.class, importedModule), importedModule); final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class); final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(), NamespaceStatement.class); stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule); stmt.addToNs(URIStringToImportPrefix.class, modNs.toString(), impPrefix); }
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); }
if (ctx.declaredSubstatements().isEmpty() && ctx.effectiveSubstatements().isEmpty()) { return typeStmt;