+++ /dev/null
-/**
- * Copyright (c) 2015 Cisco Systems, Inc. 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.controller.md.sal.dom.spi;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
-import java.lang.ref.Reference;
-import java.lang.ref.WeakReference;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * This is a single node within the registration tree. Note that the data returned from
- * and instance of this class is guaranteed to have any relevance or consistency
- * only as long as the {@link RegistrationTreeSnapshot} instance through which it is reached
- * remains unclosed.
- *
- * @param <T> registration type
- * @author Robert Varga
- *
- * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.RegistrationTreeNode} instead.
- */
-@Deprecated
-public final class RegistrationTreeNode<T> implements Identifiable<PathArgument> {
- private static final Logger LOG = LoggerFactory.getLogger(RegistrationTreeNode.class);
-
- private final Map<PathArgument, RegistrationTreeNode<T>> children = new HashMap<>();
- private final Collection<T> registrations = new ArrayList<>(2);
- private final Collection<T> publicRegistrations = Collections.unmodifiableCollection(registrations);
- private final Reference<RegistrationTreeNode<T>> parent;
- private final PathArgument identifier;
-
- RegistrationTreeNode(final RegistrationTreeNode<T> parent, final PathArgument identifier) {
- this.parent = new WeakReference<>(parent);
- this.identifier = identifier;
- }
-
- @Override
- public PathArgument getIdentifier() {
- return identifier;
- }
-
- /**
- * Return the child matching a {@link PathArgument} specification.
- *
- * @param arg Child identifier
- * @return Child matching exactly, or null.
- */
- public RegistrationTreeNode<T> getExactChild(@Nonnull final PathArgument arg) {
- return children.get(Preconditions.checkNotNull(arg));
- }
-
- /**
- * Return a collection children which match a {@link PathArgument} specification inexactly.
- * This explicitly excludes the child returned by {@link #getExactChild(PathArgument)}.
- *
- * @param arg Child identifier
- * @return Collection of children, guaranteed to be non-null.
- */
- public @Nonnull Collection<RegistrationTreeNode<T>> getInexactChildren(@Nonnull final PathArgument arg) {
- Preconditions.checkNotNull(arg);
- if (arg instanceof NodeWithValue || arg instanceof NodeIdentifierWithPredicates) {
- /*
- * TODO: This just all-or-nothing wildcards, which we have historically supported. Given
- * that the argument is supposed to have all the elements filled out, we could support
- * partial wildcards by iterating over the registrations and matching the maps for
- * partial matches.
- */
- final RegistrationTreeNode<T> child = children.get(new NodeIdentifier(arg.getNodeType()));
- if (child == null) {
- return Collections.emptyList();
- } else {
- return Collections.singletonList(child);
- }
- } else {
- return Collections.emptyList();
- }
- }
-
- public Collection<T> getRegistrations() {
- return publicRegistrations;
- }
-
- RegistrationTreeNode<T> ensureChild(@Nonnull final PathArgument child) {
- RegistrationTreeNode<T> potential = children.get(Preconditions.checkNotNull(child));
- if (potential == null) {
- potential = new RegistrationTreeNode<>(this, child);
- children.put(child, potential);
- }
- return potential;
- }
-
- void addRegistration(@Nonnull final T registration) {
- registrations.add(Preconditions.checkNotNull(registration));
- LOG.debug("Registration {} added", registration);
- }
-
- void removeRegistration(@Nonnull final T registration) {
- registrations.remove(Preconditions.checkNotNull(registration));
- LOG.debug("Registration {} removed", registration);
-
- // We have been called with the write-lock held, so we can perform some cleanup.
- removeThisIfUnused();
- }
-
- private void removeThisIfUnused() {
- final RegistrationTreeNode<T> p = parent.get();
- if (p != null && registrations.isEmpty() && children.isEmpty()) {
- p.removeChild(identifier);
- }
- }
-
- private void removeChild(final PathArgument arg) {
- children.remove(arg);
- removeThisIfUnused();
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this)
- .add("identifier", identifier)
- .add("registrations", registrations.size())
- .add("children", children.size()).toString();
- }
-}
Code Review / controller.git / blobdiff