*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
-import java.util.HashSet;
+import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
-import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
import java.net.URI;
import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleIdentifierImpl;
+import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
-public class EffectiveSchemaContext extends AbstractEffectiveSchemaContext {
-
- private final Map<ModuleIdentifier, String> identifiersToSources;
- private final SetMultimap<URI, Module> namespaceToModules;
- private final SetMultimap<String, Module> nameToModules;
- private final Set<Module> modules;
+public final class EffectiveSchemaContext extends AbstractEffectiveSchemaContext {
+ private final SetMultimap<URI, Module> namespaceToModules;
+ private final SetMultimap<String, Module> nameToModules;
+ private final Set<Module> modules;
- private final ImmutableList<DeclaredStatement<?>> rootDeclaredStatements;
- private final ImmutableList<EffectiveStatement<?,?>> rootEffectiveStatements;
+ private final List<DeclaredStatement<?>> rootDeclaredStatements;
+ private final List<EffectiveStatement<?, ?>> rootEffectiveStatements;
+ private final Set<ModuleIdentifier> moduleIdentifiers;
- public EffectiveSchemaContext(List<DeclaredStatement<?>> rootDeclaredStatements, List<EffectiveStatement<?,?>> rootEffectiveStatements) {
+ public EffectiveSchemaContext(final List<DeclaredStatement<?>> rootDeclaredStatements,
+ final List<EffectiveStatement<?, ?>> rootEffectiveStatements) {
this.rootDeclaredStatements = ImmutableList.copyOf(rootDeclaredStatements);
this.rootEffectiveStatements = ImmutableList.copyOf(rootEffectiveStatements);
- HashSet<Module> modules = new HashSet<Module>();
+ Set<Module> modulesInit = new HashSet<>();
for (EffectiveStatement<?, ?> rootEffectiveStatement : rootEffectiveStatements) {
- if(rootEffectiveStatement instanceof Module) {
+ if (rootEffectiveStatement instanceof ModuleEffectiveStatementImpl) {
Module module = (Module) rootEffectiveStatement;
- modules.add(module);
+ modulesInit.add(module);
}
}
- this.modules = ImmutableSet.copyOf(modules);
- final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(
- new TreeMap<URI, Collection<Module>>(), MODULE_SET_SUPPLIER);
- final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(
- new TreeMap<String, Collection<Module>>(), MODULE_SET_SUPPLIER);
+ Module[] moduleArray = new Module[modulesInit.size()];
+ List<Module> sortedModuleList = ModuleDependencySort.sort(modulesInit.toArray(moduleArray));
+ this.modules = ImmutableSet.copyOf(sortedModuleList);
+
+ final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(
+ new TreeMap<URI, Collection<Module>>(), MODULE_SET_SUPPLIER);
+ final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(
+ new TreeMap<String, Collection<Module>>(), MODULE_SET_SUPPLIER);
+ Set<ModuleIdentifier> modIdBuilder = new HashSet<>();
+ for (Module m : modulesInit) {
+ nameMap.put(m.getName(), m);
+ nsMap.put(m.getNamespace(), m);
+ modIdBuilder.add(new ModuleIdentifierImpl(m.getName(), Optional.of(m.getNamespace()), Optional.of(m.getRevision())));
+ }
+
+ namespaceToModules = ImmutableSetMultimap.copyOf(nsMap);
+ nameToModules = ImmutableSetMultimap.copyOf(nameMap);
+ moduleIdentifiers = ImmutableSet.copyOf(modIdBuilder);
+ }
- for (Module m : modules) {
- nameMap.put(m.getName(), m);
- nsMap.put(m.getNamespace(), m);
- }
+ public EffectiveSchemaContext(final Set<Module> modules) {
+
+ /*
+ * Instead of doing this on each invocation of getModules(), pre-compute
+ * it once and keep it around -- better than the set we got in.
+ */
+ this.modules = ImmutableSet.copyOf(ModuleDependencySort.sort(modules.toArray(new Module[modules.size()])));
+
+ /*
+ * The most common lookup is from Namespace->Module.
+ *
+ * RESTCONF performs lookups based on module name only, where it wants
+ * to receive the latest revision
+ *
+ * Invest some quality time in building up lookup tables for both.
+ */
+ final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(
+ new TreeMap<URI, Collection<Module>>(), MODULE_SET_SUPPLIER);
+ final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(
+ new TreeMap<String, Collection<Module>>(), MODULE_SET_SUPPLIER);
+
+ Set<ModuleIdentifier> modIdBuilder = new HashSet<>();
+ for (Module m : modules) {
+ nameMap.put(m.getName(), m);
+ nsMap.put(m.getNamespace(), m);
+ modIdBuilder.add(new ModuleIdentifierImpl(m.getName(), Optional.of(m.getNamespace()), Optional.of(m.getRevision())));
+ }
- namespaceToModules = ImmutableSetMultimap.copyOf(nsMap);
- nameToModules = ImmutableSetMultimap.copyOf(nameMap);
+ namespaceToModules = ImmutableSetMultimap.copyOf(nsMap);
+ nameToModules = ImmutableSetMultimap.copyOf(nameMap);
+ moduleIdentifiers = ImmutableSet.copyOf(modIdBuilder);
- //:TODO
- //this.identifiersToSources = ImmutableMap.copyOf(identifiersToSources);
- this.identifiersToSources = null;
+ rootDeclaredStatements = ImmutableList.of();
+ rootEffectiveStatements = ImmutableList.of();
+ }
+ public static SchemaContext resolveSchemaContext(final Set<Module> modules) {
+ return new EffectiveSchemaContext(modules);
}
- public ImmutableList<DeclaredStatement<?>> getRootDeclaredStatements() {
+ public List<DeclaredStatement<?>> getRootDeclaredStatements() {
return rootDeclaredStatements;
}
- public ImmutableList<EffectiveStatement<?,?>> getRootEffectiveStatements() {
+ public List<EffectiveStatement<?, ?>> getRootEffectiveStatements() {
return rootEffectiveStatements;
}
@Override
- protected Map<ModuleIdentifier, String> getIdentifiersToSources(){
-
- return identifiersToSources;
+ protected Map<ModuleIdentifier, String> getIdentifiersToSources() {
+ return ImmutableMap.of();
}
@Override
- public Set<Module> getModules(){
-
+ public Set<Module> getModules() {
return modules;
}
@Override
protected SetMultimap<URI, Module> getNamespaceToModules() {
-
return namespaceToModules;
}
@Override
protected SetMultimap<String, Module> getNameToModules() {
-
return nameToModules;
}
@Override
- public String toString() {
+ public Set<ModuleIdentifier> getAllModuleIdentifiers() {
+ return moduleIdentifiers;
+ }
+ @Override
+ public String toString() {
return String.format("SchemaContextImpl{modules=%s}", modules);
}
}
Code Review / yangtools.git / blobdiff