/**
* Inherited from immediate parent
*/
- private final Iterable<Builder> inheritedOne;
+ private final Collection<Builder> inheritedOne;
private final YangInstanceIdentifier nodeId;
private final Collection<Node> nodes;
private final Map<DataChangeListenerRegistration<?>, Builder> baseBuilders = new HashMap<>();
private ResolveDataChangeState(final YangInstanceIdentifier nodeId,
- final Iterable<Builder> inheritedSub, final Iterable<Builder> inheritedOne,
+ final Iterable<Builder> inheritedSub, final Collection<Builder> inheritedOne,
final Collection<Node> nodes) {
this.nodeId = Preconditions.checkNotNull(nodeId);
this.nodes = Preconditions.checkNotNull(nodes);
* @return State handle
*/
public ResolveDataChangeState child(final PathArgument childId) {
- return new ResolveDataChangeState(nodeId.node(childId),
- Iterables.concat(inheritedSub, subBuilders.values()),
+ /*
+ * We instantiate a concatenation only when needed, otherwise
+ * we reuse the collection. This speeds up Iterables.isEmpty()
+ * in needsProcessing().
+ */
+ final Iterable<Builder> sb;
+ if (subBuilders.isEmpty()) {
+ sb = inheritedSub;
+ } else {
+ sb = Iterables.concat(inheritedSub, subBuilders.values());
+ }
+
+ return new ResolveDataChangeState(nodeId.node(childId), sb,
oneBuilders.values(), getListenerChildrenWildcarded(nodes, childId));
}
if (!nodes.isEmpty()) {
return true;
}
- // Have SUBTREE listeners
- if (!Iterables.isEmpty(inheritedSub)) {
+ // Have ONE listeners
+ if (!inheritedOne.isEmpty()) {
return true;
}
- // Have ONE listeners
- if (!Iterables.isEmpty(inheritedOne)) {
+ // Have SUBTREE listeners
+ if (!Iterables.isEmpty(inheritedSub)) {
return true;
}