/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2013 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
// module builders sorted by dependencies
List<ModuleBuilder> sortedBuilders = ModuleDependencySort.sort(resolved);
- Map<URI, TreeMap<Date, ModuleBuilder>> modules = resolveModulesWithImports(sortedBuilders, null);
+ Map<URI, NavigableMap<Date, ModuleBuilder>> modules = resolveModulesWithImports(sortedBuilders, null);
Collection<Module> unsorted = build(modules).values();
Set<Module> result = new LinkedHashSet<>(
ModuleDependencySort.sort(unsorted.toArray(new Module[unsorted.size()])));
}
final List<ModuleBuilder> sorted = resolveModuleBuilders(sources, context);
- final Map<URI, TreeMap<Date, ModuleBuilder>> modules = resolveModulesWithImports(sorted, context);
+ final Map<URI, NavigableMap<Date, ModuleBuilder>> modules = resolveModulesWithImports(sorted, context);
final Set<Module> unsorted = new LinkedHashSet<>(build(modules).values());
if (context != null) {
return resolveSchemaContext(result);
}
- private static Map<URI, TreeMap<Date, ModuleBuilder>> resolveModulesWithImports(final List<ModuleBuilder> sorted,
+ private static Map<URI, NavigableMap<Date, ModuleBuilder>> resolveModulesWithImports(final List<ModuleBuilder> sorted,
final SchemaContext context) {
- final Map<URI, TreeMap<Date, ModuleBuilder>> modules = orderModules(sorted);
+ final Map<URI, NavigableMap<Date, ModuleBuilder>> modules = orderModules(sorted);
for (ModuleBuilder module : sorted) {
if (module != null) {
for (ModuleImport imp : module.getImports().values()) {
if (targetModule == null) {
Module result = findModuleFromContext(context, module, prefix, 0);
targetModule = new ModuleBuilder(result);
- TreeMap<Date, ModuleBuilder> map = modules.get(targetModule.getNamespace());
+ NavigableMap<Date, ModuleBuilder> map = modules.get(targetModule.getNamespace());
if (map == null) {
map = new TreeMap<>();
map.put(targetModule.getRevision(), targetModule);
public Collection<Module> buildModules(final Collection<ModuleBuilder> builders) {
Collection<ModuleBuilder> unsorted = resolveSubmodules(builders);
List<ModuleBuilder> sorted = ModuleDependencySort.sort(unsorted);
- Map<URI, TreeMap<Date, ModuleBuilder>> modules = resolveModulesWithImports(sorted, null);
+ Map<URI, NavigableMap<Date, ModuleBuilder>> modules = resolveModulesWithImports(sorted, null);
Map<ModuleBuilder, Module> builderToModule = build(modules);
return builderToModule.values();
}
Map<ByteSource, ModuleBuilder> sourceToBuilder = resolveSources(sources, context);
// sort and check for duplicates
List<ModuleBuilder> sorted = ModuleDependencySort.sort(sourceToBuilder.values());
- Map<URI, TreeMap<Date, ModuleBuilder>> modules = resolveModulesWithImports(sorted, null);
+ Map<URI, NavigableMap<Date, ModuleBuilder>> modules = resolveModulesWithImports(sorted, null);
Map<ModuleBuilder, Module> builderToModule = build(modules);
Map<ModuleBuilder, ByteSource> builderToSource = HashBiMap.create(sourceToBuilder).inverse();
sorted = ModuleDependencySort.sort(builderToModule.keySet());
return resolveSubmodules(builders);
}
- private Map<ByteSource, ModuleBuilder> parseSourcesToBuilders(final Collection<ByteSource> sources,
+ private static Map<ByteSource, ModuleBuilder> parseSourcesToBuilders(final Collection<ByteSource> sources,
final SchemaContext context) throws IOException, YangSyntaxErrorException {
final ParseTreeWalker walker = new ParseTreeWalker();
final Map<ByteSource, ParseTree> sourceToTree = parseYangSources(sources);
// validate yang
new YangModelBasicValidator(walker).validate(sourceToTree.values());
- Map<String, TreeMap<Date, URI>> namespaceContext = BuilderUtils.createYangNamespaceContext(
+ Map<String, NavigableMap<Date, URI>> namespaceContext = BuilderUtils.createYangNamespaceContext(
sourceToTree.values(), Optional.fromNullable(context));
YangParserListenerImpl yangModelParser;
for (Map.Entry<ByteSource, ParseTree> entry : sourceToTree.entrySet()) {
private Map<ByteSource, ModuleBuilder> resolveSubmodules(final Map<ByteSource, ModuleBuilder> builders) {
Map<ByteSource, ModuleBuilder> modules = new HashMap<>();
- Map<String, TreeMap<Date, ModuleBuilder>> submodules = new HashMap<>();
+ Map<String, NavigableMap<Date, ModuleBuilder>> submodules = new HashMap<>();
for (Map.Entry<ByteSource, ModuleBuilder> entry : builders.entrySet()) {
ModuleBuilder builder = entry.getValue();
if (builder.isSubmodule()) {
String submoduleName = builder.getName();
- TreeMap<Date, ModuleBuilder> map = submodules.get(submoduleName);
+ NavigableMap<Date, ModuleBuilder> map = submodules.get(submoduleName);
if (map == null) {
map = new TreeMap<>();
map.put(builder.getRevision(), builder);
private Collection<ModuleBuilder> resolveSubmodules(final Collection<ModuleBuilder> builders) {
Collection<ModuleBuilder> modules = new HashSet<>();
- Map<String, TreeMap<Date, ModuleBuilder>> submodules = new HashMap<>();
+ Map<String, NavigableMap<Date, ModuleBuilder>> submodules = new HashMap<>();
for (ModuleBuilder builder : builders) {
if (builder.isSubmodule()) {
String submoduleName = builder.getName();
- TreeMap<Date, ModuleBuilder> map = submodules.get(submoduleName);
+ NavigableMap<Date, ModuleBuilder> map = submodules.get(submoduleName);
if (map == null) {
map = new TreeMap<>();
map.put(builder.getRevision(), builder);
* @return collection of module builders with resolved submodules
*/
private void resolveSubmodules(final ModuleBuilder module,
- final Map<String, TreeMap<Date, ModuleBuilder>> submodules) {
+ final Map<String, NavigableMap<Date, ModuleBuilder>> submodules) {
Map<String, Date> includes = module.getIncludedModules();
for (Map.Entry<String, Date> entry : includes.entrySet()) {
NavigableMap<Date, ModuleBuilder> subs = submodules.get(entry.getKey());
}
}
- if (submodule.getIncludedModules().size() > 0) {
+ if (!submodule.getIncludedModules().isEmpty()) {
resolveSubmodules(submodule, submodules);
}
addSubmoduleToModule(submodule, module);
}
}
- private void addSubmoduleToModule(final ModuleBuilder submodule, final ModuleBuilder module) {
+ private static void addSubmoduleToModule(final ModuleBuilder submodule, final ModuleBuilder module) {
module.addSubmodule(submodule);
submodule.setParent(module);
module.getDirtyNodes().addAll(submodule.getDirtyNodes());
* topologically sorted modules
* @return modules ordered by namespace and revision
*/
- private static Map<URI, TreeMap<Date, ModuleBuilder>> orderModules(final List<ModuleBuilder> modules) {
- final Map<URI, TreeMap<Date, ModuleBuilder>> result = new LinkedHashMap<>();
+ private static Map<URI, NavigableMap<Date, ModuleBuilder>> orderModules(final List<ModuleBuilder> modules) {
+ final Map<URI, NavigableMap<Date, ModuleBuilder>> result = new LinkedHashMap<>();
for (final ModuleBuilder builder : modules) {
if (builder == null) {
continue;
rev = new Date(0);
}
- TreeMap<Date, ModuleBuilder> builderByRevision = result.get(ns);
+ NavigableMap<Date, ModuleBuilder> builderByRevision = result.get(ns);
if (builderByRevision == null) {
builderByRevision = new TreeMap<>();
builderByRevision.put(rev, builder);
// if this is submodule, add parent to filtered and pick its imports
if (main.isSubmodule()) {
- TreeMap<Date, ModuleBuilder> dependencies = new TreeMap<>();
+ NavigableMap<Date, ModuleBuilder> dependencies = new TreeMap<>();
for (ModuleBuilder mb : other) {
if (mb.getName().equals(main.getBelongsTo())) {
dependencies.put(mb.getRevision(), mb);
filterImports(builder, other, filtered);
}
} else {
- if (mi.getRevision().equals(builder.getRevision())) {
- if (!filtered.contains(builder)) {
- filtered.add(builder);
- filterImports(builder, other, filtered);
- }
+ if (!filtered.contains(builder) && mi.getRevision().equals(builder.getRevision())) {
+ filtered.add(builder);
+ filterImports(builder, other, filtered);
}
}
}
}
}
- private Map<ByteSource, ParseTree> parseYangSources(final Collection<ByteSource> sources) throws IOException, YangSyntaxErrorException {
+ private static Map<ByteSource, ParseTree> parseYangSources(final Collection<ByteSource> sources) throws IOException, YangSyntaxErrorException {
final Map<ByteSource, ParseTree> trees = new HashMap<>();
for (ByteSource source : sources) {
try (InputStream stream = source.openStream()) {
* all loaded modules
* @return modules mapped on their builders
*/
- private Map<ModuleBuilder, Module> build(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ private Map<ModuleBuilder, Module> build(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
resolveDirtyNodes(modules);
resolveAugmentsTargetPath(modules);
resolveUsesTargetGrouping(modules);
// build
final Map<ModuleBuilder, Module> result = new LinkedHashMap<>();
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder moduleBuilder = childEntry.getValue();
final Module module = moduleBuilder.build();
* @param modules
* all loaded modules
*/
- private void resolveDirtyNodes(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ private static void resolveDirtyNodes(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder module = childEntry.getValue();
resolveUnknownNodes(modules, module);
* @param module
* current module
*/
- private void resolveDirtyNodes(final Map<URI, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ private static void resolveDirtyNodes(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
if (!dirtyNodes.isEmpty()) {
for (TypeAwareBuilder nodeToResolve : dirtyNodes) {
* @param modules
* all loaded modules
*/
- private void resolveAugmentsTargetPath(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ private void resolveAugmentsTargetPath(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
// collect augments from all loaded modules
final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
allAugments.addAll(inner.getValue().getAllAugments());
}
}
}
- private SchemaPath findUsesAugmentTargetNodePath(DataNodeContainerBuilder usesParent,
- AugmentationSchemaBuilder augment) {
+ private static SchemaPath findUsesAugmentTargetNodePath(final DataNodeContainerBuilder usesParent,
+ final AugmentationSchemaBuilder augment) {
QName parentQName = usesParent.getQName();
final QNameModule qnm;
if (parentQName == null) {
* @param augments
* augments to check
*/
- private void checkAugmentMandatoryNodes(final Collection<AugmentationSchemaBuilder> augments) {
+ private static void checkAugmentMandatoryNodes(final Collection<AugmentationSchemaBuilder> augments) {
for (AugmentationSchemaBuilder augment : augments) {
URI augmentTargetNs = augment.getTargetPath().getPathFromRoot().iterator().next().getNamespace();
Date augmentTargetRev = augment.getTargetPath().getPathFromRoot().iterator().next().getRevision();
* all loaded modules topologically sorted (based on dependencies
* between each other)
*/
- private void resolveAugments(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ private static void resolveAugments(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
List<ModuleBuilder> all = new ArrayList<>();
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
all.add(inner.getValue());
}
* all loaded modules
* @return true if augment process succeed
*/
- private boolean resolveUsesAugment(final AugmentationSchemaBuilder augment, final ModuleBuilder module,
- final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ private static boolean resolveUsesAugment(final AugmentationSchemaBuilder augment, final ModuleBuilder module,
+ final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
if (augment.isResolved()) {
return true;
}
* all loaded modules
* @return true if augment process succeed
*/
- private boolean resolveAugment(final AugmentationSchemaBuilder augment, final ModuleBuilder module,
- final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ private static boolean resolveAugment(final AugmentationSchemaBuilder augment, final ModuleBuilder module,
+ final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
if (augment.isResolved()) {
return true;
}
* @param modules
* all loaded modules
*/
- private void resolveIdentities(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ private static void resolveIdentities(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
ModuleBuilder module = inner.getValue();
final Set<IdentitySchemaNodeBuilder> identities = module.getAddedIdentities();
}
}
- private void resolveIdentity(final ModuleBuilder module,
+ private static void resolveIdentity(final ModuleBuilder module,
final IdentitySchemaNodeBuilder identity) {
final String baseIdentityName = identity.getBaseIdentityName();
if (baseIdentityName != null) {
* @param modules
* all loaded modules
*/
- private void resolveUsesTargetGrouping(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ private static void resolveUsesTargetGrouping(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
final List<UsesNodeBuilder> allUses = new ArrayList<>();
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
allUses.addAll(inner.getValue().getAllUsesNodes());
}
* @param modules
* all loaded modules
*/
- private void resolveUsesForGroupings(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ private static void resolveUsesForGroupings(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
final Set<GroupingBuilder> allGroupings = new HashSet<>();
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
ModuleBuilder module = inner.getValue();
allGroupings.addAll(module.getAllGroupings());
* @param modules
* all loaded modules
*/
- private void resolveUsesForNodes(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ private static void resolveUsesForNodes(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
ModuleBuilder module = inner.getValue();
List<UsesNodeBuilder> usesNodes = module.getAllUsesNodes();
* @param modules
* all loaded modules
*/
- private void resolveUses(final UsesNodeBuilder usesNode, final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
+ private static void resolveUses(final UsesNodeBuilder usesNode, final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
if (!usesNode.isResolved()) {
DataNodeContainerBuilder parent = usesNode.getParent();
ModuleBuilder module = BuilderUtils.getParentModule(parent);
}
}
- private int nodeAfterUsesIndex(final UsesNodeBuilder usesNode) {
+ private static int nodeAfterUsesIndex(final UsesNodeBuilder usesNode) {
DataNodeContainerBuilder parent = usesNode.getParent();
int usesLine = usesNode.getLine();
DataSchemaNodeBuilder nextNodeAfterUses = null;
for (DataSchemaNodeBuilder childNode : childNodes) {
- if (!(childNode.isAddedByUses()) && !(childNode.isAugmenting())) {
- if (childNode.getLine() > usesLine) {
- nextNodeAfterUses = childNode;
- break;
- }
+ if (!childNode.isAddedByUses() && !childNode.isAugmenting() && childNode.getLine() > usesLine) {
+ nextNodeAfterUses = childNode;
+ break;
}
}
* @param module
* current module
*/
- private void resolveUnknownNodes(final Map<URI, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ private static void resolveUnknownNodes(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
QName nodeType = usnb.getNodeType();
String localName = usnb.getNodeType().getLocalName();
}
}
- private ExtensionBuilder findExtBuilder(final String name, final Collection<ExtensionBuilder> extensions) {
+ private static ExtensionBuilder findExtBuilder(final String name, final Collection<ExtensionBuilder> extensions) {
for (ExtensionBuilder extension : extensions) {
if (extension.getQName().getLocalName().equals(name)) {
return extension;
return null;
}
- private ExtensionDefinition findExtDef(final String name, final Collection<ExtensionDefinition> extensions) {
+ private static ExtensionDefinition findExtDef(final String name, final Collection<ExtensionDefinition> extensions) {
for (ExtensionDefinition extension : extensions) {
if (extension.getQName().getLocalName().equals(name)) {
return extension;
* @param modules
* all loaded modules
*/
- private void checkChoiceCasesForDuplicityQNames(final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
- for (Map.Entry<URI, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ private void checkChoiceCasesForDuplicityQNames(final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
+ for (Map.Entry<URI, NavigableMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder moduleBuilder = childEntry.getValue();
final Module module = moduleBuilder.build();
}
}
- private void findDuplicityNodesIn(final ChoiceSchemaNode choiceNode, final Module module, final ModuleBuilder moduleBuilder,
- final Map<URI, TreeMap<Date, ModuleBuilder>> modules) {
- final Set<QName> duplicityTestSet = new HashSet<QName>();
+ private static void findDuplicityNodesIn(final ChoiceSchemaNode choiceNode, final Module module, final ModuleBuilder moduleBuilder,
+ final Map<URI, NavigableMap<Date, ModuleBuilder>> modules) {
+ final Set<QName> duplicityTestSet = new HashSet<>();
for (ChoiceCaseNode choiceCaseNode : choiceNode.getCases()) {
}
private List<ChoiceSchemaNode> getChoicesFrom(final Module module) {
- final List<ChoiceSchemaNode> allChoices = new ArrayList<ChoiceSchemaNode>();
+ final List<ChoiceSchemaNode> allChoices = new ArrayList<>();
for (DataSchemaNode dataSchemaNode : module.getChildNodes()) {
findChoicesIn(dataSchemaNode, allChoices);