2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.md.sal.dom.spi;
10 import com.google.common.base.MoreObjects;
11 import com.google.common.base.Preconditions;
12 import java.lang.ref.Reference;
13 import java.lang.ref.WeakReference;
14 import java.util.ArrayList;
15 import java.util.Collection;
16 import java.util.Collections;
17 import java.util.HashMap;
19 import javax.annotation.Nonnull;
20 import org.opendaylight.yangtools.concepts.Identifiable;
21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
25 import org.slf4j.Logger;
26 import org.slf4j.LoggerFactory;
29 * This is a single node within the registration tree. Note that the data returned from
30 * and instance of this class is guaranteed to have any relevance or consistency
31 * only as long as the {@link RegistrationTreeSnapshot} instance through which it is reached
34 * @param <T> registration type
35 * @author Robert Varga
37 * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.RegistrationTreeNode} instead.
40 public final class RegistrationTreeNode<T> implements Identifiable<PathArgument> {
41 private static final Logger LOG = LoggerFactory.getLogger(RegistrationTreeNode.class);
43 private final Map<PathArgument, RegistrationTreeNode<T>> children = new HashMap<>();
44 private final Collection<T> registrations = new ArrayList<>(2);
45 private final Collection<T> publicRegistrations = Collections.unmodifiableCollection(registrations);
46 private final Reference<RegistrationTreeNode<T>> parent;
47 private final PathArgument identifier;
49 RegistrationTreeNode(final RegistrationTreeNode<T> parent, final PathArgument identifier) {
50 this.parent = new WeakReference<>(parent);
51 this.identifier = identifier;
55 public PathArgument getIdentifier() {
60 * Return the child matching a {@link PathArgument} specification.
62 * @param arg Child identifier
63 * @return Child matching exactly, or null.
65 public RegistrationTreeNode<T> getExactChild(@Nonnull final PathArgument arg) {
66 return children.get(Preconditions.checkNotNull(arg));
70 * Return a collection children which match a {@link PathArgument} specification inexactly.
71 * This explicitly excludes the child returned by {@link #getExactChild(PathArgument)}.
73 * @param arg Child identifier
74 * @return Collection of children, guaranteed to be non-null.
76 public @Nonnull Collection<RegistrationTreeNode<T>> getInexactChildren(@Nonnull final PathArgument arg) {
77 Preconditions.checkNotNull(arg);
78 if (arg instanceof NodeWithValue || arg instanceof NodeIdentifierWithPredicates) {
80 * TODO: This just all-or-nothing wildcards, which we have historically supported. Given
81 * that the argument is supposed to have all the elements filled out, we could support
82 * partial wildcards by iterating over the registrations and matching the maps for
85 final RegistrationTreeNode<T> child = children.get(new NodeIdentifier(arg.getNodeType()));
87 return Collections.emptyList();
89 return Collections.singletonList(child);
92 return Collections.emptyList();
96 public Collection<T> getRegistrations() {
97 return publicRegistrations;
100 RegistrationTreeNode<T> ensureChild(@Nonnull final PathArgument child) {
101 RegistrationTreeNode<T> potential = children.get(Preconditions.checkNotNull(child));
102 if (potential == null) {
103 potential = new RegistrationTreeNode<>(this, child);
104 children.put(child, potential);
109 void addRegistration(@Nonnull final T registration) {
110 registrations.add(Preconditions.checkNotNull(registration));
111 LOG.debug("Registration {} added", registration);
114 void removeRegistration(@Nonnull final T registration) {
115 registrations.remove(Preconditions.checkNotNull(registration));
116 LOG.debug("Registration {} removed", registration);
118 // We have been called with the write-lock held, so we can perform some cleanup.
119 removeThisIfUnused();
122 private void removeThisIfUnused() {
123 final RegistrationTreeNode<T> p = parent.get();
124 if (p != null && registrations.isEmpty() && children.isEmpty()) {
125 p.removeChild(identifier);
129 private void removeChild(final PathArgument arg) {
130 children.remove(arg);
131 removeThisIfUnused();
135 public String toString() {
136 return MoreObjects.toStringHelper(this)
137 .add("identifier", identifier)
138 .add("registrations", registrations.size())
139 .add("children", children.size()).toString();