Object analysis shows we are recording outer class multiple times,
leading to suboptimimal object layout. Make the class hierarchy static,
with outer class recorded in explicit field, reducing
size of PhaseModificationInNamespacePath from 40-80 (48 typical) bytes
to 32-64 (40 typical) bytes. Other subclasses observe a similar
reduction.
JIRA: YANGTOOLS-1486
Change-Id: Ifc3da86a564bc54f4247996e622787a8528422b7
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
(cherry picked from commit
007dd4ccf28dd4288bafbce38a00c2b8d3ec2a68)
(cherry picked from commit
a9bd1a493db611489687effeaeab9f2dc5d3af32)
final ModelProcessingPhase phase) {
checkNotRegistered();
final ModelProcessingPhase phase) {
checkNotRegistered();
- AddedToNamespace<C> addedToNs = new AddedToNamespace<>(phase);
+ final var addedToNs = new AddedToNamespace<C>(this, phase);
addReq(addedToNs);
contextImpl(context).onNamespaceItemAddedAction(namespace, key, addedToNs);
return addedToNs;
addReq(addedToNs);
contextImpl(context).onNamespaceItemAddedAction(namespace, key, addedToNs);
return addedToNs;
final NamespaceKeyCriterion<K> criterion, final ModelProcessingPhase phase) {
checkNotRegistered();
final NamespaceKeyCriterion<K> criterion, final ModelProcessingPhase phase) {
checkNotRegistered();
- AddedToNamespace<C> addedToNs = new AddedToNamespace<>(phase);
+ final var addedToNs = new AddedToNamespace<C>(this, phase);
addReq(addedToNs);
contextImpl(context).onNamespaceItemAddedAction(namespace, phase, criterion, addedToNs);
return addedToNs;
addReq(addedToNs);
contextImpl(context).onNamespaceItemAddedAction(namespace, phase, criterion, addedToNs);
return addedToNs;
final ModelProcessingPhase phase) {
checkNotRegistered();
final ModelProcessingPhase phase) {
checkNotRegistered();
- PhaseFinished<C> phaseFin = new PhaseFinished<>();
+ final var phaseFin = new PhaseFinished<C>(this);
addReq(phaseFin);
addBootstrap(() -> contextImpl(context).addPhaseCompletedListener(phase, phaseFin));
return phaseFin;
addReq(phaseFin);
addBootstrap(() -> contextImpl(context).addPhaseCompletedListener(phase, phaseFin));
return phaseFin;
final K key, final ModelProcessingPhase phase) {
checkNotRegistered();
final K key, final ModelProcessingPhase phase) {
checkNotRegistered();
- final PhaseModificationInNamespace<C> mod = new PhaseModificationInNamespace<>(EFFECTIVE_MODEL);
+ final var mod = new PhaseModificationInNamespace<C>(this, EFFECTIVE_MODEL);
addReq(mod);
addMutation(mod);
contextImpl(context).onNamespaceItemAddedAction((Class) namespace, key, mod);
addReq(mod);
addMutation(mod);
contextImpl(context).onNamespaceItemAddedAction((Class) namespace, key, mod);
@Override
public <C extends Mutable<?, ?, ?>, T extends C> Prerequisite<C> mutatesCtx(final T context,
final ModelProcessingPhase phase) {
@Override
public <C extends Mutable<?, ?, ?>, T extends C> Prerequisite<C> mutatesCtx(final T context,
final ModelProcessingPhase phase) {
- return addMutation(new PhaseMutation<>(contextImpl(context), phase));
+ return addMutation(new PhaseMutation<>(this, contextImpl(context), phase));
final Class<N> namespace, final Iterable<K> keys, final ModelProcessingPhase phase) {
checkNotRegistered();
final Class<N> namespace, final Iterable<K> keys, final ModelProcessingPhase phase) {
checkNotRegistered();
- final var ret = new PhaseRequirementInNamespacePath<StmtContext<?, ?, E>, K, N>(EFFECTIVE_MODEL, keys);
+ final var ret = new PhaseRequirementInNamespacePath<StmtContext<?, ?, E>, K, N>(this, EFFECTIVE_MODEL, keys);
addReq(ret);
addBootstrap(() -> ret.hookOnto(context, namespace));
return ret;
addReq(ret);
addBootstrap(() -> ret.hookOnto(context, namespace));
return ret;
@Deprecated
public <N extends ParserNamespace<?, ?>> Prerequisite<Mutable<?, ?, ?>> mutatesNs(final Mutable<?, ?, ?> context,
final Class<N> namespace) {
@Deprecated
public <N extends ParserNamespace<?, ?>> Prerequisite<Mutable<?, ?, ?>> mutatesNs(final Mutable<?, ?, ?> context,
final Class<N> namespace) {
- return addMutation(new NamespaceMutation<>(contextImpl(context), namespace));
+ return addMutation(new NamespaceMutation<>(this, contextImpl(context), namespace));
final Class<N> namespace, final Iterable<K> keys) {
checkNotRegistered();
final Class<N> namespace, final Iterable<K> keys) {
checkNotRegistered();
- final var ret = new PhaseModificationInNamespacePath<Mutable<?, ?, E>, K, N>(EFFECTIVE_MODEL, keys);
+ final var ret = new PhaseModificationInNamespacePath<Mutable<?, ?, E>, K, N>(this, EFFECTIVE_MODEL, keys);
addReq(ret);
addMutation(ret);
addBootstrap(() -> ret.hookOnto(context, namespace));
addReq(ret);
addMutation(ret);
addBootstrap(() -> ret.hookOnto(context, namespace));
bootstraps.add(bootstrap);
}
bootstraps.add(bootstrap);
}
- private abstract class AbstractPrerequisite<T> implements Prerequisite<T> {
+ private abstract static class AbstractPrerequisite<T> implements Prerequisite<T> {
+ final @NonNull ModifierImpl modifier;
+
private boolean done = false;
private T value;
private boolean done = false;
private T value;
+ AbstractPrerequisite(final ModifierImpl modifier) {
+ this.modifier = requireNonNull(modifier);
+ }
+
@Override
@SuppressWarnings("checkstyle:hiddenField")
public final T resolve(final InferenceContext ctx) {
checkState(done);
@Override
@SuppressWarnings("checkstyle:hiddenField")
public final T resolve(final InferenceContext ctx) {
checkState(done);
- checkArgument(ctx == ModifierImpl.this.ctx);
+ checkArgument(ctx == modifier.ctx);
return verifyNotNull(value, "Attempted to access unavailable prerequisite %s", this);
}
return verifyNotNull(value, "Attempted to access unavailable prerequisite %s", this);
}
final boolean resolvePrereq(final T value) {
this.value = value;
this.done = true;
final boolean resolvePrereq(final T value) {
this.value = value;
this.done = true;
+ return modifier.isApplied();
}
final <O> @NonNull Prerequisite<O> transform(final Function<? super T, O> transformation) {
}
final <O> @NonNull Prerequisite<O> transform(final Function<? super T, O> transformation) {
- private abstract class AbstractPathPrerequisite<C extends StmtContext<?, ?, ?>, K,
+ private abstract static class AbstractPathPrerequisite<C extends StmtContext<?, ?, ?>, K,
N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPrerequisite<C>
implements OnNamespaceItemAdded {
private final ModelProcessingPhase modPhase;
private final Iterable<K> keys;
private final Iterator<K> it;
N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPrerequisite<C>
implements OnNamespaceItemAdded {
private final ModelProcessingPhase modPhase;
private final Iterable<K> keys;
private final Iterator<K> it;
- AbstractPathPrerequisite(final ModelProcessingPhase phase, final Iterable<K> keys) {
+ AbstractPathPrerequisite(final ModifierImpl modifier, final ModelProcessingPhase phase,
+ final Iterable<K> keys) {
+ super(modifier);
this.modPhase = requireNonNull(phase);
this.keys = requireNonNull(keys);
it = keys.iterator();
this.modPhase = requireNonNull(phase);
this.keys = requireNonNull(keys);
it = keys.iterator();
if (!target.isSupportedByFeatures()) {
LOG.debug("Key {} in {} is not supported", key, keys);
resolvePrereq(null);
if (!target.isSupportedByFeatures()) {
LOG.debug("Key {} in {} is not supported", key, keys);
resolvePrereq(null);
- action.prerequisiteUnavailable(this);
+ modifier.action.prerequisiteUnavailable(this);
if (!it.hasNext()) {
// Last step: we are done
if (resolvePrereq((C) value)) {
if (!it.hasNext()) {
// Last step: we are done
if (resolvePrereq((C) value)) {
- private final class PhaseMutation<C> extends AbstractPrerequisite<C> implements ContextMutation {
+ private static final class PhaseMutation<C> extends AbstractPrerequisite<C> implements ContextMutation {
@SuppressWarnings("unchecked")
@SuppressWarnings("unchecked")
- PhaseMutation(final StatementContextBase<?, ?, ?> context, final ModelProcessingPhase phase) {
+ PhaseMutation(final ModifierImpl modifier, final StatementContextBase<?, ?, ?> context,
+ final ModelProcessingPhase phase) {
+ super(modifier);
context.addMutation(phase, this);
resolvePrereq((C) context);
}
@Override
public boolean isFinished() {
context.addMutation(phase, this);
resolvePrereq((C) context);
}
@Override
public boolean isFinished() {
+ return modifier.isApplied();
- private final class PhaseFinished<C extends StmtContext<?, ?, ?>> extends AbstractPrerequisite<C>
+ private static final class PhaseFinished<C extends StmtContext<?, ?, ?>> extends AbstractPrerequisite<C>
implements OnPhaseFinished {
implements OnPhaseFinished {
+ PhaseFinished(final ModifierImpl modifier) {
+ super(modifier);
+ }
+
@SuppressWarnings("unchecked")
@Override
public boolean phaseFinished(final StatementContextBase<?, ?, ?> context,
final ModelProcessingPhase finishedPhase) {
@SuppressWarnings("unchecked")
@Override
public boolean phaseFinished(final StatementContextBase<?, ?, ?> context,
final ModelProcessingPhase finishedPhase) {
- return resolvePrereq((C) context) || tryApply();
+ return resolvePrereq((C) context) || modifier.tryApply();
- private final class NamespaceMutation<N extends ParserNamespace<?, ?>>
+ private static final class NamespaceMutation<N extends ParserNamespace<?, ?>>
extends AbstractPrerequisite<Mutable<?, ?, ?>> {
extends AbstractPrerequisite<Mutable<?, ?, ?>> {
- NamespaceMutation(final StatementContextBase<?, ?, ?> ctx, final Class<N> namespace) {
+ NamespaceMutation(final ModifierImpl modifier, final StatementContextBase<?, ?, ?> ctx,
+ final Class<N> namespace) {
+ super(modifier);
- private final class AddedToNamespace<C extends StmtContext<?, ?, ?>> extends AbstractPrerequisite<C>
+ private static final class AddedToNamespace<C extends StmtContext<?, ?, ?>> extends AbstractPrerequisite<C>
implements OnNamespaceItemAdded, OnPhaseFinished {
private final ModelProcessingPhase phase;
implements OnNamespaceItemAdded, OnPhaseFinished {
private final ModelProcessingPhase phase;
- AddedToNamespace(final ModelProcessingPhase phase) {
+ AddedToNamespace(final ModifierImpl modifier, final ModelProcessingPhase phase) {
+ super(modifier);
this.phase = requireNonNull(phase);
}
this.phase = requireNonNull(phase);
}
@Override
public boolean phaseFinished(final StatementContextBase<?, ?, ?> context,
final ModelProcessingPhase finishedPhase) {
@Override
public boolean phaseFinished(final StatementContextBase<?, ?, ?> context,
final ModelProcessingPhase finishedPhase) {
- return resolvePrereq((C) context) || tryApply();
+ return resolvePrereq((C) context) || modifier.tryApply();
- private final class PhaseRequirementInNamespacePath<C extends StmtContext<?, ?, ?>, K,
+ private static final class PhaseRequirementInNamespacePath<C extends StmtContext<?, ?, ?>, K,
N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPathPrerequisite<C, K, N> {
N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPathPrerequisite<C, K, N> {
- PhaseRequirementInNamespacePath(final ModelProcessingPhase phase, final Iterable<K> keys) {
- super(phase, keys);
+ PhaseRequirementInNamespacePath(final ModifierImpl modifier, final ModelProcessingPhase phase,
+ final Iterable<K> keys) {
+ super(modifier, phase, keys);
- private final class PhaseModificationInNamespace<C extends Mutable<?, ?, ?>> extends AbstractPrerequisite<C>
+ private static final class PhaseModificationInNamespace<C extends Mutable<?, ?, ?>> extends AbstractPrerequisite<C>
implements OnNamespaceItemAdded, ContextMutation {
private final ModelProcessingPhase modPhase;
implements OnNamespaceItemAdded, ContextMutation {
private final ModelProcessingPhase modPhase;
- PhaseModificationInNamespace(final ModelProcessingPhase phase) {
+ PhaseModificationInNamespace(final ModifierImpl modifier, final ModelProcessingPhase phase) {
+ super(modifier);
checkArgument(phase != null, "Model processing phase must not be null");
this.modPhase = phase;
}
checkArgument(phase != null, "Model processing phase must not be null");
this.modPhase = phase;
}
@Override
public boolean isFinished() {
@Override
public boolean isFinished() {
+ return modifier.isApplied();
* target. The mechanics is driven as a sequence of prerequisites along a path: first we hook onto namespace to
* give us the first step. When it does, we hook onto the first item to provide us the second step and so on.
*/
* target. The mechanics is driven as a sequence of prerequisites along a path: first we hook onto namespace to
* give us the first step. When it does, we hook onto the first item to provide us the second step and so on.
*/
- private final class PhaseModificationInNamespacePath<C extends Mutable<?, ?, ?>, K,
+ private static final class PhaseModificationInNamespacePath<C extends Mutable<?, ?, ?>, K,
N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPathPrerequisite<C, K, N>
implements ContextMutation {
N extends ParserNamespace<K, ? extends StmtContext<?, ?, ?>>> extends AbstractPathPrerequisite<C, K, N>
implements ContextMutation {
- PhaseModificationInNamespacePath(final ModelProcessingPhase phase, final Iterable<K> keys) {
- super(phase, keys);
+ PhaseModificationInNamespacePath(final ModifierImpl modifier, final ModelProcessingPhase phase,
+ final Iterable<K> keys) {
+ super(modifier, phase, keys);
}
@Override
public boolean isFinished() {
}
@Override
public boolean isFinished() {
+ return modifier.isApplied();