From d4b2b759ed8d6e528d54936deca955345bbb53cf Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Mon, 6 Dec 2021 08:17:42 +0100 Subject: [PATCH] Use a linear TypedefNamespace We do not access TypedefNamespace in our code and it usually is empty, implement it as a linear search map. JIRA: YANGTOOLS-1375 Change-Id: I231dfc297bca6e85a2e998d3a2fe1b2bc83e7ad4 Signed-off-by: Robert Varga --- .../AbstractDeclaredEffectiveStatement.java | 9 +- .../spi/meta/AbstractEffectiveStatement.java | 7 +- .../spi/meta/LinearTypedefNamespace.java | 93 +++++++++++++++++++ 3 files changed, 100 insertions(+), 9 deletions(-) create mode 100644 model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/LinearTypedefNamespace.java diff --git a/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java b/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java index fa5d1db38b..8847b96b7c 100644 --- a/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java +++ b/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java @@ -29,7 +29,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStat import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypedefNamespace; /** @@ -272,17 +271,15 @@ public abstract class AbstractDeclaredEffectiveStatement> extends WithDataTree { public abstract static class WithTypedefNamespace, E extends DataTreeAwareEffectiveStatement> extends DefaultWithDataTree { - private final @NonNull ImmutableMap typedefNamespace; - protected WithTypedefNamespace(final D declared, final ImmutableList> substatements) { super(declared, substatements); - this.typedefNamespace = createTypedefNamespace(substatements); + // Consistency check only + createTypedefNamespace(substatements); } protected WithTypedefNamespace(final WithTypedefNamespace original) { super(original); - this.typedefNamespace = original.typedefNamespace; } @Override @@ -290,7 +287,7 @@ public abstract class AbstractDeclaredEffectiveStatement> Optional> getNamespaceContents( final Class namespace) { if (TypedefNamespace.class.equals(namespace)) { - return Optional.of((Map) typedefNamespace); + return Optional.of((Map) new LinearTypedefNamespace(effectiveSubstatements())); } return super.getNamespaceContents(namespace); } diff --git a/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractEffectiveStatement.java b/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractEffectiveStatement.java index 71a27a383a..27ed8eaecf 100644 --- a/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractEffectiveStatement.java +++ b/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractEffectiveStatement.java @@ -12,6 +12,7 @@ import static java.util.Objects.requireNonNull; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import java.util.Collection; +import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.Optional; @@ -118,14 +119,14 @@ abstract class AbstractEffectiveStatement> return sameAsSchema ? (ImmutableMap) schemaTreeNamespace : ImmutableMap.copyOf(dataChildren); } - protected static @NonNull ImmutableMap createTypedefNamespace( + protected static @NonNull HashMap createTypedefNamespace( final Collection> substatements) { - final Map typedefs = new LinkedHashMap<>(); + final HashMap typedefs = new HashMap<>(); substatements.stream().filter(TypedefEffectiveStatement.class::isInstance) .forEach(child -> putChild(typedefs, (TypedefEffectiveStatement) child, "typedef")); - return ImmutableMap.copyOf(typedefs); + return typedefs; } private static boolean indexDataTree(final Map> map, diff --git a/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/LinearTypedefNamespace.java b/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/LinearTypedefNamespace.java new file mode 100644 index 0000000000..3c12bb6a33 --- /dev/null +++ b/model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/LinearTypedefNamespace.java @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.model.spi.meta; + +import static java.util.Objects.requireNonNull; + +import com.google.common.collect.Collections2; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import java.util.AbstractMap; +import java.util.Collection; +import java.util.Map; +import java.util.Set; +import org.opendaylight.yangtools.concepts.Immutable; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypedefNamespace; + +/** + * A filter-based implementation of a Map to serve with {@link TypedefNamespace}. + */ +final class LinearTypedefNamespace extends AbstractMap implements Immutable { + private final Collection values; + + @SuppressWarnings("unchecked") + LinearTypedefNamespace(final ImmutableList> substatements) { + values = (Collection) + Collections2.filter(substatements, TypedefEffectiveStatement.class::isInstance); + } + + @Override + public int size() { + return values.size(); + } + + @Override + public boolean isEmpty() { + return values.isEmpty(); + } + + @Override + public boolean containsKey(final Object key) { + return get(key) != null; + } + + @Override + public boolean containsValue(final Object value) { + return values.contains(requireNonNull(value)); + } + + @Override + public TypedefEffectiveStatement get(final Object key) { + final var nonnull = requireNonNull(key); + return values().stream().filter(stmt -> nonnull.equals(stmt.argument())).findFirst().orElse(null); + } + + @Override + public TypedefEffectiveStatement remove(final Object key) { + throw new UnsupportedOperationException(); + } + + @Override + @SuppressWarnings("checkstyle:parameterName") + public void putAll(final Map m) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public Set keySet() { + return values.stream().map(TypedefEffectiveStatement::argument).collect(ImmutableSet.toImmutableSet()); + } + + @Override + public Collection values() { + return values; + } + + @Override + public Set> entrySet() { + return values.stream().map(stmt -> Map.entry(stmt.argument(), stmt)).collect(ImmutableSet.toImmutableSet()); + } +} -- 2.36.6