boolean tryApply() { checkState(action != null, "Action was not defined yet."); if (removeSatisfied()) { applyAction(); return true; } return false; }
@Override public <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>> AbstractPrerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) { return requiresCtxImpl(contextImpl(context), namespace, key, EFFECTIVE_MODEL); }
@SuppressWarnings("checkstyle:hiddenField") final boolean resolvePrereq(final T value) { this.value = value; this.done = true; return isApplied(); }
private <C extends StmtContext<?, ?, ?>> @NonNull AbstractPrerequisite<C> requiresCtxImpl(final C context, final ModelProcessingPhase phase) { checkNotRegistered(); PhaseFinished<C> phaseFin = new PhaseFinished<>(); addReq(phaseFin); contextImpl(context).addPhaseCompletedListener(phase, phaseFin); return phaseFin; }
@SuppressWarnings({ "rawtypes", "unchecked" }) private <K, C extends Mutable<?, ?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>> AbstractPrerequisite<C> mutatesCtxImpl(final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key, final ModelProcessingPhase phase) { checkNotRegistered(); final PhaseModificationInNamespace<C> mod = new PhaseModificationInNamespace<>(EFFECTIVE_MODEL); addReq(mod); addMutation(mod); contextImpl(context).onNamespaceItemAddedAction((Class) namespace, key, mod); return mod; }
@Override public <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>> AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtxPath(final StmtContext<?, ?, ?> context, final Class<N> namespace, final Iterable<K> keys) { checkNotRegistered(); final PhaseModificationInNamespacePath<Mutable<?, ?, E>, K, N> ret = new PhaseModificationInNamespacePath<>( EFFECTIVE_MODEL, keys); addReq(ret); addMutation(ret); ret.hookOnto(context, namespace); return ret; }
@Override public <C extends Mutable<?, ?, ?>, T extends C> Prerequisite<C> mutatesCtx(final T context, final ModelProcessingPhase phase) { return addMutation(new PhaseMutation<>(contextImpl(context), phase)); }
@Override public <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>> AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) { return mutatesCtxImpl(context, namespace, key, EFFECTIVE_MODEL); }
void failModifier() { removeSatisfied(); action.prerequisiteFailed(unsatisfied); action = null; }
@NonNull ModelActionBuilder newInferenceAction(final @NonNull ModelProcessingPhase phase) { final ModifierImpl action = new ModifierImpl(); modifiers.put(phase, action); return action; }
Optional<SourceException> failModifiers(final ModelProcessingPhase identifier) { final List<SourceException> exceptions = new ArrayList<>(); for (final ModifierImpl mod : modifiers.get(identifier)) { try { mod.failModifier(); } catch (final SourceException e) { exceptions.add(e); } } if (exceptions.isEmpty()) { return Optional.empty(); } final String message = String.format("Yang model processing phase %s failed", identifier); final InferenceException e = new InferenceException(message, root.getStatementSourceReference(), exceptions.get(0)); exceptions.listIterator(1).forEachRemaining(e::addSuppressed); return Optional.of(e); }
private <K, C extends StmtContext<?, ?, ?>, N extends StatementNamespace<K, ?, ?>> @NonNull AbstractPrerequisite<C> requiresCtxImpl(final StmtContext<?, ?, ?> context, final Class<N> namespace, final NamespaceKeyCriterion<K> criterion, final ModelProcessingPhase phase) { checkNotRegistered(); AddedToNamespace<C> addedToNs = new AddedToNamespace<>(phase); addReq(addedToNs); contextImpl(context).onNamespaceItemAddedAction(namespace, phase, criterion, addedToNs); return addedToNs; }
@Override public <N extends IdentifierNamespace<?, ?>> Prerequisite<Mutable<?, ?, ?>> mutatesNs( final Mutable<?, ?, ?> context, final Class<N> namespace) { return addMutation(new NamespaceMutation<>(contextImpl(context), namespace)); }
private <K, C extends StmtContext<?, ?, ?>, N extends StatementNamespace<K, ?, ?>> @NonNull AbstractPrerequisite<C> requiresCtxImpl(final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key, final ModelProcessingPhase phase) { checkNotRegistered(); AddedToNamespace<C> addedToNs = new AddedToNamespace<>(phase); addReq(addedToNs); contextImpl(context).onNamespaceItemAddedAction(namespace, key, addedToNs); return addedToNs; }
@Override public boolean isFinished() { return isApplied(); } }
@Override public boolean isFinished() { return isApplied(); } }
@Override public boolean isFinished() { return isApplied(); }