private static boolean isSupportedRefineTarget(final StmtContext<?, ?, ?> refineSubstatementCtx, final StmtContext<?, ?, ?> refineTargetNodeCtx) { final Collection<?> supportedRefineTargets = YangValidationBundles.SUPPORTED_REFINE_TARGETS .get(refineSubstatementCtx.getPublicDefinition()); return supportedRefineTargets == null || supportedRefineTargets.isEmpty() || supportedRefineTargets.contains(refineTargetNodeCtx.getPublicDefinition()); }
private static boolean isSupportedDeviationTarget(final StmtContext<?, ?, ?> deviateSubstatementCtx, final StmtContext<?, ?, ?> deviateTargetCtx, final YangVersion yangVersion) { Set<StatementDefinition> supportedDeviationTargets = YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(deviateTargetCtx.getRootVersion(), deviateSubstatementCtx.getPublicDefinition()); if (supportedDeviationTargets == null) { supportedDeviationTargets = YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(YangVersion.VERSION_1, deviateSubstatementCtx.getPublicDefinition()); } // if supportedDeviationTargets is null, it means that the deviate substatement is an unknown statement return supportedDeviationTargets == null || supportedDeviationTargets.contains( deviateTargetCtx.getPublicDefinition()); } }
public static boolean needToCopyByUses(final StmtContext<?, ?, ?> stmtContext) { final StatementDefinition def = stmtContext.getPublicDefinition(); if (REUSED_DEF_SET.contains(def)) { LOG.trace("Will reuse {} statement {}", def, stmtContext); return false; } if (NOCOPY_FROM_GROUPING_SET.contains(def)) { return !YangStmtMapping.GROUPING.equals(stmtContext.coerceParentContext().getPublicDefinition()); } LOG.trace("Will copy {} statement {}", def, stmtContext); return true; }
private static boolean needToCopyByUses(final StmtContext<?, ?, ?> stmtContext) { final StatementDefinition def = stmtContext.getPublicDefinition(); if (REUSED_DEF_SET.contains(def)) { LOG.debug("Will reuse {} statement {}", def, stmtContext); return false; } if (NOCOPY_FROM_GROUPING_SET.contains(def)) { return !YangStmtMapping.GROUPING.equals(stmtContext.coerceParentContext().getPublicDefinition()); } LOG.debug("Will copy {} statement {}", def, stmtContext); return true; }
/** * Checks whether statement context is a non-presence container or not. * * @param stmtCtx * statement context * @return true if it is a non-presence container */ public static boolean isNonPresenceContainer(final StmtContext<?, ?, ?> stmtCtx) { return stmtCtx.getPublicDefinition() == YangStmtMapping.CONTAINER && !containsPresenceSubStmt(stmtCtx); }
/** * Checks whether statement context is a presence container or not. * * @param stmtCtx * statement context * @return true if it is a presence container */ public static boolean isPresenceContainer(final StmtContext<?, ?, ?> stmtCtx) { return stmtCtx.getPublicDefinition() == YangStmtMapping.CONTAINER && containsPresenceSubStmt(stmtCtx); }
public static boolean producesDeclared(final StmtContext<?, ?, ?> ctx, final Class<? extends DeclaredStatement<?>> type) { return type.isAssignableFrom(ctx.getPublicDefinition().getDeclaredRepresentationClass()); }
/** * Checks whether supplied statement context is conditional augment * statement. * * @param ctx * statement context to be checked * * @return true if supplied statement context is conditional augment * statement, otherwise false */ private static boolean isConditionalAugmentStmt(final StmtContext<?, ?, ?> ctx) { return ctx.getPublicDefinition() == YangStmtMapping.AUGMENT && StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null; }
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); }
private static StmtContext<?, ?, ?> getSearchRoot(final StmtContext<?, ?, ?> augmentContext) { // Augment is in uses - we need to augment instantiated nodes in parent. final StmtContext<?, ?, ?> parent = augmentContext.coerceParentContext(); if (YangStmtMapping.USES == parent.getPublicDefinition()) { return parent.getParentContext(); } return parent; }
public static @NonNull Boolean parseBoolean(final StmtContext<?, ?, ?> ctx, final String input) { if ("true".equals(input)) { return Boolean.TRUE; } else if ("false".equals(input)) { return Boolean.FALSE; } else { throw new SourceException(ctx.getStatementSourceReference(), "Invalid '%s' statement %s '%s', it can be either 'true' or 'false'", ctx.getPublicDefinition().getStatementName(), ctx.getPublicDefinition().getArgumentName(), input); } }
private String localNamespaceURI() { if (localNamespaceURI == null) { localNamespaceURI = verifyNotNull(ctx.getPublicDefinition().getStatementName().getNamespace().toString(), "Local namespace URI not found in %s", ctx); } return localNamespaceURI; }
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)); }
Effective(final StmtContext<Void, DefaultDenyWriteStatement, ?> ctx) { super(ctx); path = ctx.coerceParentContext().getSchemaPath().get().createChild( ctx.getPublicDefinition().getStatementName()); }
Effective(final StmtContext<Void, DefaultDenyAllStatement, ?> ctx) { super(ctx); path = ctx.coerceParentContext().getSchemaPath().get().createChild( ctx.getPublicDefinition().getStatementName()); }
Effective(final StmtContext<Void, DefaultDenyAllStatement, ?> ctx) { super(ctx); path = ctx.coerceParentContext().getSchemaPath().get().createChild( ctx.getPublicDefinition().getStatementName()); }
Effective(final StmtContext<Void, OpenConfigHashedValueStatement, ?> ctx) { super(ctx); path = ctx.coerceParentContext().getSchemaPath().get().createChild( ctx.getPublicDefinition().getStatementName()); }
protected UndeclaredEffectiveStatementBase(final StmtContext<A, D, ?> ctx) { super(ctx); this.statementDefinition = ctx.getPublicDefinition(); this.argument = ctx.getStatementArgument(); this.statementSource = ctx.getStatementSource(); final D declareInstance = ctx.buildDeclared(); Verify.verify(declareInstance == null, "Statement %s resulted in declared statement %s", declareInstance); }
private static void disallowIfFeatureAndWhenOnListKeys(final StmtContext<?, ?, ?> leafStmtCtx) { leafStmtCtx.allSubstatements().forEach(leafSubstmtCtx -> { final StatementDefinition statementDef = leafSubstmtCtx.getPublicDefinition(); SourceException.throwIf(YangStmtMapping.IF_FEATURE.equals(statementDef) || YangStmtMapping.WHEN.equals(statementDef), leafStmtCtx.getStatementSourceReference(), "%s statement is not allowed in %s leaf statement which is specified as a list key.", statementDef.getStatementName(), leafStmtCtx.getStatementArgument()); }); }
private static void validateDeviationTarget(final StmtContext<?, ?, ?> deviateSubStmtCtx, final StmtContext<?, ?, ?> targetCtx) { InferenceException.throwIf(!isSupportedDeviationTarget(deviateSubStmtCtx, targetCtx, targetCtx.getRootVersion()), deviateSubStmtCtx.getStatementSourceReference(), "%s is not a valid deviation target for substatement %s.", targetCtx.getStatementArgument(), deviateSubStmtCtx.getPublicDefinition().getStatementName()); }