import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
import java.util.Map;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
return child instanceof DataSchemaNode ? Optional.of((DataSchemaNode) child) : Optional.empty();
}
- protected abstract ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
+ protected abstract Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
}
/**
return super.getNamespaceContents(namespace);
}
- protected abstract ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace();
+ protected abstract Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace();
}
/**
*/
public abstract static class DefaultWithSchemaTree<A, D extends DeclaredStatement<A>,
E extends SchemaTreeAwareEffectiveStatement<A, D>> extends WithSchemaTree<A, D, E> {
- private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+ private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
private final @NonNull D declared;
protected DefaultWithSchemaTree(final D declared, final StmtContext<?, ?, ?> ctx,
}
@Override
- protected final ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
+ protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
return schemaTree;
}
}
*/
public abstract static class DefaultWithDataTree<A, D extends DeclaredStatement<A>,
E extends DataTreeAwareEffectiveStatement<A, D>> extends WithDataTree<A, D, E> {
- private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
- private final @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTree;
+ private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+ private final @NonNull Map<QName, DataTreeEffectiveStatement<?>> dataTree;
private final @NonNull D declared;
protected DefaultWithDataTree(final D declared, final StmtContext<?, ?, ?> ctx,
}
@Override
- protected final ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
+ protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
return schemaTree;
}
@Override
- protected final ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace() {
+ protected final Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace() {
return dataTree;
}
}
import com.google.common.collect.ImmutableSet;
import java.lang.invoke.VarHandle;
import java.util.Collection;
+import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
@Beta
public abstract class AbstractSchemaEffectiveDocumentedNode<A, D extends DeclaredStatement<A>>
extends AbstractEffectiveDocumentedNode<A, D> {
- private final ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace;
- private final ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace;
+ private final Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace;
+ private final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace;
protected AbstractSchemaEffectiveDocumentedNode(final StmtContext<A, D, ?> ctx) {
super(ctx);
return child instanceof DataSchemaNode ? Optional.of((DataSchemaNode) child) : Optional.empty();
}
- static @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> createSchemaTreeNamespace(
+ static @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> createSchemaTreeNamespace(
final StatementSourceReference ref, final Collection<? extends EffectiveStatement<?, ?>> substatements) {
final Map<QName, SchemaTreeEffectiveStatement<?>> schemaChildren = new LinkedHashMap<>();
substatements.stream().filter(SchemaTreeEffectiveStatement.class::isInstance)
.forEach(child -> putChild(schemaChildren, (SchemaTreeEffectiveStatement) child, ref, "schema"));
- return ImmutableMap.copyOf(schemaChildren);
+ return toImmutable(schemaChildren);
}
- static @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> createDataTreeNamespace(
+ static @NonNull Map<QName, DataTreeEffectiveStatement<?>> createDataTreeNamespace(
final StatementSourceReference ref,
- final ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace) {
+ final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace) {
final Map<QName, DataTreeEffectiveStatement<?>> dataChildren = new LinkedHashMap<>();
boolean sameAsSchema = true;
// This is a mighty hack to lower memory usage: if we consumed all schema tree children as data nodes,
// the two maps are equal and hence we can share the instance.
- return sameAsSchema ? (ImmutableMap) schemaTreeNamespace : ImmutableMap.copyOf(dataChildren);
+ return sameAsSchema ? (Map) schemaTreeNamespace : toImmutable(dataChildren);
+ }
+
+ private static <K, V> Map<K, V> toImmutable(final Map<K, V> map) {
+ switch (map.size()) {
+ case 0:
+ return ImmutableMap.of();
+ case 1:
+ // Special case: singleton ImmutableMap is actually SingletonImmutableBiMap, which allocates its inverse
+ // view and its keySet() when asked for values() -- which costs us 64 bytes (40+24).
+ // java.util.Collections can do the same job for less memory.
+ final Entry<K, V> entry = map.entrySet().iterator().next();
+ return Collections.singletonMap(entry.getKey(), entry.getValue());
+ default:
+ return ImmutableMap.copyOf(map);
+ }
}
@SuppressWarnings("unchecked")