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.yangtools.yang.model.util;
10 import static com.google.common.base.Preconditions.checkArgument;
11 import static java.util.Objects.requireNonNull;
13 import com.google.common.collect.ImmutableMap;
14 import com.google.common.collect.ImmutableSet;
15 import com.google.common.collect.Multimaps;
16 import com.google.common.collect.SetMultimap;
17 import java.lang.invoke.MethodHandles;
18 import java.lang.invoke.VarHandle;
20 import java.util.ArrayList;
21 import java.util.Collection;
22 import java.util.Collections;
23 import java.util.Comparator;
24 import java.util.HashMap;
25 import java.util.HashSet;
26 import java.util.LinkedHashSet;
27 import java.util.List;
29 import java.util.Optional;
31 import java.util.TreeSet;
32 import org.opendaylight.yangtools.yang.common.QName;
33 import org.opendaylight.yangtools.yang.common.QNameModule;
34 import org.opendaylight.yangtools.yang.common.Revision;
35 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
37 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
38 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.Module;
40 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
41 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
42 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
43 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
44 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
46 public abstract class AbstractSchemaContext implements SchemaContext {
48 * A {@link Module} comparator based on {@link Module#getRevision()}, placing latest revision first. Note this
49 * comparator does not take into account module name and so two modules with different names but same revisions
52 protected static final Comparator<Module> REVISION_COMPARATOR =
53 (first, second) -> Revision.compare(second.getRevision(), first.getRevision());
56 * A {@link Module} comparator based on {@link Module#getName()} and {@link Module#getRevision()}, ordering modules
57 * lexicographically by their name and then in order of descending revision. This comparator assumes that
58 * the combination of these two attributes is sufficient to be consistent with hashCode/equals.
60 protected static final Comparator<Module> NAME_REVISION_COMPARATOR = (first, second) -> {
61 final int cmp = first.getName().compareTo(second.getName());
62 return cmp != 0 ? cmp : REVISION_COMPARATOR.compare(first, second);
66 * Create a TreeSet for containing Modules with the same name, such that the set is ordered
67 * by {@link #REVISION_COMPARATOR}.
69 * @return A fresh TreeSet instance.
71 protected static final TreeSet<Module> createModuleSet() {
72 return new TreeSet<>(REVISION_COMPARATOR);
75 private static final VarHandle DERIVED_IDENTITIES;
79 DERIVED_IDENTITIES = MethodHandles.lookup().findVarHandle(AbstractSchemaContext.class, "derivedIdentities",
81 } catch (NoSuchFieldException | IllegalAccessException e) {
82 throw new ExceptionInInitializerError(e);
86 // Accessed via DERIVED_IDENTITIES
87 @SuppressWarnings("unused")
88 private volatile ImmutableMap<IdentitySchemaNode, ImmutableSet<IdentitySchemaNode>> derivedIdentities = null;
91 * Returns the namespace-to-module mapping.
93 * @return Map of modules where key is namespace
95 protected abstract SetMultimap<URI, Module> getNamespaceToModules();
98 * Returns the module name-to-module mapping.
100 * @return Map of modules where key is name of module
102 protected abstract SetMultimap<String, Module> getNameToModules();
105 * Returns the namespace+revision-to-module mapping.
107 * @return Map of modules where key is Module's QNameModule.
109 protected abstract Map<QNameModule, Module> getModuleMap();
112 public Collection<? extends DataSchemaNode> getDataDefinitions() {
113 final Set<DataSchemaNode> dataDefs = new HashSet<>();
114 for (Module m : getModules()) {
115 dataDefs.addAll(m.getChildNodes());
121 public Collection<? extends NotificationDefinition> getNotifications() {
122 final Set<NotificationDefinition> notifications = new HashSet<>();
123 for (Module m : getModules()) {
124 notifications.addAll(m.getNotifications());
126 return notifications;
130 public Collection<? extends RpcDefinition> getOperations() {
131 final Set<RpcDefinition> rpcs = new HashSet<>();
132 for (Module m : getModules()) {
133 rpcs.addAll(m.getRpcs());
139 public Collection<? extends ExtensionDefinition> getExtensions() {
140 final Set<ExtensionDefinition> extensions = new HashSet<>();
141 for (Module m : getModules()) {
142 extensions.addAll(m.getExtensionSchemaNodes());
148 public Optional<? extends Module> findModule(final String name, final Optional<Revision> revision) {
149 for (final Module module : getNameToModules().get(name)) {
150 if (revision.equals(module.getRevision())) {
151 return Optional.of(module);
155 return Optional.empty();
159 public Optional<Module> findModule(final QNameModule qnameModule) {
160 return Optional.ofNullable(getModuleMap().get(qnameModule));
164 public Collection<? extends Module> findModules(final URI namespace) {
165 return getNamespaceToModules().get(namespace);
169 public Collection<? extends Module> findModules(final String name) {
170 return getNameToModules().get(name);
174 public Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
175 final List<UnknownSchemaNode> result = new ArrayList<>();
176 for (Module module : getModules()) {
177 result.addAll(module.getUnknownSchemaNodes());
179 return Collections.unmodifiableList(result);
183 public Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
184 final Set<TypeDefinition<?>> result = new LinkedHashSet<>();
185 for (Module module : getModules()) {
186 result.addAll(module.getTypeDefinitions());
188 return Collections.unmodifiableSet(result);
192 public Collection<? extends DataSchemaNode> getChildNodes() {
193 final Set<DataSchemaNode> result = new LinkedHashSet<>();
194 for (Module module : getModules()) {
195 result.addAll(module.getChildNodes());
197 return Collections.unmodifiableSet(result);
201 public Collection<? extends GroupingDefinition> getGroupings() {
202 final Set<GroupingDefinition> result = new LinkedHashSet<>();
203 for (Module module : getModules()) {
204 result.addAll(module.getGroupings());
206 return Collections.unmodifiableSet(result);
210 public Optional<DataSchemaNode> findDataChildByName(final QName name) {
211 requireNonNull(name);
212 for (Module module : getModules()) {
213 final Optional<DataSchemaNode> result = module.findDataChildByName(name);
214 if (result.isPresent()) {
218 return Optional.empty();
222 public Collection<? extends IdentitySchemaNode> getDerivedIdentities(final IdentitySchemaNode identity) {
223 ImmutableMap<IdentitySchemaNode, ImmutableSet<IdentitySchemaNode>> local =
224 (ImmutableMap<IdentitySchemaNode, ImmutableSet<IdentitySchemaNode>>)
225 DERIVED_IDENTITIES.getAcquire(this);
227 local = loadDerivedIdentities();
229 final ImmutableSet<IdentitySchemaNode> result = local.get(requireNonNull(identity));
230 checkArgument(result != null, "Identity %s not found", identity);
234 private ImmutableMap<IdentitySchemaNode, ImmutableSet<IdentitySchemaNode>> loadDerivedIdentities() {
235 final SetMultimap<IdentitySchemaNode, IdentitySchemaNode> tmp =
236 Multimaps.newSetMultimap(new HashMap<>(), HashSet::new);
237 final List<IdentitySchemaNode> identities = new ArrayList<>();
238 for (Module module : getModules()) {
239 final Collection<? extends IdentitySchemaNode> ids = module.getIdentities();
240 for (IdentitySchemaNode identity : ids) {
241 for (IdentitySchemaNode base : identity.getBaseIdentities()) {
242 tmp.put(base, identity);
245 identities.addAll(ids);
248 final ImmutableMap.Builder<IdentitySchemaNode, ImmutableSet<IdentitySchemaNode>> builder =
249 ImmutableMap.builderWithExpectedSize(identities.size());
250 for (IdentitySchemaNode identity : identities) {
251 builder.put(identity, ImmutableSet.copyOf(tmp.get(identity)));
254 final ImmutableMap<IdentitySchemaNode, ImmutableSet<IdentitySchemaNode>> result = builder.build();
255 final Object witness = DERIVED_IDENTITIES.compareAndExchangeRelease(this, null, result);
256 return witness == null ? result : (ImmutableMap<IdentitySchemaNode, ImmutableSet<IdentitySchemaNode>>) witness;