@Override
public void onFullDefinitionDeclared(
final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>>
usesNode)
throws SourceException {
if (StmtContextUtils.isInExtensionBody(usesNode)) {
return;
}
ModelActionBuilder usesAction = usesNode.newInferenceAction(FULL_DECLARATION);
final QName groupingName = usesNode.getStatementArgument();
final Prerequisite<StmtContext<?, ?, ?>> sourceGroupingPre =
usesAction.requiresCtx(usesNode, GroupingNamespace.class, groupingName, FULL_DECLARATION);
final Prerequisite<? extends StmtContext.Mutable<?, ?, ?>> targetNodePre =
usesAction.mutatesCtx(usesNode.getParentContext(), FULL_DECLARATION);
usesAction.apply(
new InferenceAction() {
@Override
public void apply() throws InferenceException {
StatementContextBase<?, ?, ?> targetNodeStmtCtx =
(StatementContextBase<?, ?, ?>) targetNodePre.get();
StatementContextBase<?, ?, ?> sourceGrpStmtCtx =
(StatementContextBase<?, ?, ?>) sourceGroupingPre.get();
try {
GroupingUtils.copyFromSourceToTarget(sourceGrpStmtCtx, targetNodeStmtCtx, usesNode);
GroupingUtils.resolveUsesNode(usesNode, targetNodeStmtCtx);
} catch (SourceException e) {
LOG.warn(e.getMessage(), e);
throw e;
}
}
@Override
public void prerequisiteFailed(Collection<? extends Prerequisite<?>> failed)
throws InferenceException {
if (failed.contains(sourceGroupingPre)) {
throw new InferenceException(
"Grouping " + groupingName + " was not resolved.",
usesNode.getStatementSourceReference());
}
throw new InferenceException(
"Unknown error occurred.", usesNode.getStatementSourceReference());
}
});
}
@Override
public void onStatementDefinitionDeclared(
final Mutable<QName, BaseStatement, EffectiveStatement<QName, BaseStatement>> baseStmtCtx) {
final Mutable<?, ?, ?> baseParentCtx = baseStmtCtx.getParentContext();
if (StmtContextUtils.producesDeclared(baseParentCtx, IdentityStatement.class)) {
final QName baseIdentityQName = baseStmtCtx.getStatementArgument();
ModelActionBuilder baseIdentityAction =
baseStmtCtx.newInferenceAction(ModelProcessingPhase.STATEMENT_DEFINITION);
final Prerequisite<StmtContext<?, ?, ?>> requiresPrereq =
baseIdentityAction.requiresCtx(
baseStmtCtx,
IdentityNamespace.class,
baseIdentityQName,
ModelProcessingPhase.STATEMENT_DEFINITION);
final Prerequisite<StmtContext.Mutable<?, ?, ?>> mutatesPrereq =
baseIdentityAction.mutatesCtx(baseParentCtx, ModelProcessingPhase.STATEMENT_DEFINITION);
baseIdentityAction.apply(
new InferenceAction() {
@Override
public void apply() throws InferenceException {
List<StmtContext<?, ?, ?>> derivedIdentities =
baseStmtCtx.getFromNamespace(
DerivedIdentitiesNamespace.class, baseStmtCtx.getStatementArgument());
if (derivedIdentities == null) {
derivedIdentities = new ArrayList<>();
baseStmtCtx.addToNs(
DerivedIdentitiesNamespace.class, baseIdentityQName, derivedIdentities);
}
derivedIdentities.add(baseParentCtx);
}
@Override
public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
throw new InferenceException(
"Unable to resolve identity "
+ baseParentCtx.getStatementArgument()
+ " and base identity "
+ baseStmtCtx.getStatementArgument(),
baseStmtCtx.getStatementSourceReference());
}
});
}
}
private void initCopyType(
StmtContext<QName, OutputStatement, EffectiveStatement<QName, OutputStatement>> ctx) {
Set<TypeOfCopy> copyTypesFromOriginal = StmtContextUtils.getCopyTypesFromOriginal(ctx);
if (copyTypesFromOriginal.contains(TypeOfCopy.ADDED_BY_AUGMENTATION)) {
augmenting = true;
}
if (copyTypesFromOriginal.contains(TypeOfCopy.ADDED_BY_USES)) {
addedByUses = true;
}
if (copyTypesFromOriginal.contains(TypeOfCopy.ADDED_BY_USES_AUGMENTATION)) {
addedByUses = augmenting = true;
}
if (ctx.getTypeOfCopy() != TypeOfCopy.ORIGINAL) {
original = (ContainerSchemaNode) ctx.getOriginalCtx().buildEffective();
}
}