@SuppressWarnings("unchecked") static Mutable<?, ?, EffectiveStatement<?, ?>> tryToFindUnknownStatement(final String localName, final Mutable<?, ?, EffectiveStatement<?, ?>> current) { final Collection<? extends StmtContext<?, ?, ?>> unknownSubstatements = StmtContextUtils.findAllSubstatements( current, UnknownStatement.class); for (final StmtContext<?, ?, ?> unknownSubstatement : unknownSubstatements) { if (localName.equals(unknownSubstatement.rawStatementArgument())) { return (Mutable<?, ?, EffectiveStatement<?, ?>>) unknownSubstatement; } } return null; }
EnumEffectiveStatementImpl(final StmtContext<String, EnumStatement, ?> ctx) { super(ctx); name = ctx.rawStatementArgument(); final List<UnknownSchemaNode> unknownSchemaNodesInit = new ArrayList<>(); Integer declaredValueInit = null; for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) { if (effectiveStatement instanceof ValueEffectiveStatement) { declaredValueInit = ((ValueEffectiveStatement) effectiveStatement).argument(); } if (effectiveStatement instanceof UnknownSchemaNode) { unknownSchemaNodesInit.add((UnknownSchemaNode) effectiveStatement); } } declaredValue = declaredValueInit; unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodesInit); }
/** * Return the statement argument in literal format. * * @return raw statement argument string * @throws VerifyException if this statement does not have an argument */ default @NonNull String coerceRawStatementArgument() { return verifyNotNull(rawStatementArgument(), "Statement context %s does not have an argument", this); }
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)); }
private static void checkForMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx) { if (StmtContextUtils.isNonPresenceContainer(sourceCtx)) { /* * We need to iterate over both declared and effective sub-statements, * because a mandatory node can be: * a) declared in augment body * b) added to augment body also via uses of a grouping and * such sub-statements are stored in effective sub-statements collection. */ sourceCtx.allSubstatementsStream().forEach(AbstractAugmentStatementSupport::checkForMandatoryNodes); } InferenceException.throwIf(StmtContextUtils.isMandatoryNode(sourceCtx), sourceCtx.getStatementSourceReference(), "An augment cannot add node '%s' because it is mandatory and in module different than target", sourceCtx.rawStatementArgument()); }
nodeParameter = ctx.rawStatementArgument() == null ? "" : ctx.rawStatementArgument();
private static void validateNodeCanBeCopiedByAugment(final StmtContext<?, ?, ?> sourceCtx, final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy, final boolean skipCheckOfMandatoryNodes) { if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) { return; } if (!skipCheckOfMandatoryNodes && typeOfCopy == CopyType.ADDED_BY_AUGMENTATION && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) { checkForMandatoryNodes(sourceCtx); } // Data definition statements must not collide on their namespace if (DataDefinitionStatement.class.isAssignableFrom( sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) { for (final StmtContext<?, ?, ?> subStatement : targetCtx.allSubstatements()) { if (DataDefinitionStatement.class.isAssignableFrom( subStatement.getPublicDefinition().getDeclaredRepresentationClass())) { InferenceException.throwIf( Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument()), sourceCtx.getStatementSourceReference(), "An augment cannot add node named '%s' because this name is already used in target", sourceCtx.rawStatementArgument()); } } } }
private static void deleteStatement(final StmtContext<?, ?, ?> stmtCtxToBeDeleted, final StatementContextBase<?, ?, ?> targetCtx) { final StatementDefinition stmtToBeDeleted = stmtCtxToBeDeleted.getPublicDefinition(); final String stmtArgument = stmtCtxToBeDeleted.rawStatementArgument(); for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableEffectiveSubstatements()) { if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(), targetCtxSubstatement.rawStatementArgument())) { targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeDeleted, stmtArgument); return; } } for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) { if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(), targetCtxSubstatement.rawStatementArgument())) { targetCtxSubstatement.setIsSupportedToBuildEffective(false); return; } } LOG.error("Deviation cannot delete substatement {} with argument '{}' in target node {} because it does " + "not exist in the target node. At line: {}", stmtToBeDeleted.getStatementName(), stmtArgument, targetCtx.getStatementArgument(), stmtCtxToBeDeleted.getStatementSourceReference()); }