Enable checkstyle in yang-model-util
[yangtools.git] / yang / yang-model-util / src / main / java / org / opendaylight / yangtools / yang / model / util / FilteringSchemaContextProxy.java
1 /*
2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
3  *
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
7  */
8
9 package org.opendaylight.yangtools.yang.model.util;
10
11 import com.google.common.base.Preconditions;
12 import com.google.common.base.Strings;
13 import com.google.common.collect.Collections2;
14 import com.google.common.collect.ImmutableMap;
15 import com.google.common.collect.ImmutableSet.Builder;
16 import com.google.common.collect.ImmutableSetMultimap;
17 import com.google.common.collect.Lists;
18 import com.google.common.collect.Maps;
19 import com.google.common.collect.Multimap;
20 import com.google.common.collect.Multimaps;
21 import com.google.common.collect.SetMultimap;
22 import com.google.common.collect.TreeMultimap;
23 import java.net.URI;
24 import java.util.Collection;
25 import java.util.Collections;
26 import java.util.Date;
27 import java.util.List;
28 import java.util.Map;
29 import java.util.Set;
30 import java.util.TreeMap;
31 import java.util.function.Function;
32 import javax.annotation.concurrent.Immutable;
33 import org.opendaylight.yangtools.yang.model.api.Module;
34 import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
35 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
36 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
37
38 @Immutable
39 public final class FilteringSchemaContextProxy extends AbstractSchemaContext {
40
41     //collection to be filled with filtered modules
42     private final Set<Module> filteredModules;
43
44     //collections to be filled in with filtered data
45     private final Map<ModuleIdentifier, String> identifiersToSources;
46     private final SetMultimap<URI, Module> namespaceToModules;
47     private final SetMultimap<String, Module> nameToModules;
48
49     /**
50      * Filters SchemaContext for yang modules.
51      *
52      * @param delegate original SchemaContext
53      * @param rootModules modules (yang schemas) to be available and all their dependencies (modules importing
54      *                    rootModule and whole chain of their imports)
55      * @param additionalModuleIds (additional) modules (yang schemas) to be available and whole chain of their imports
56      */
57     public FilteringSchemaContextProxy(final SchemaContext delegate, final Collection<ModuleId> rootModules,
58             final Set<ModuleId> additionalModuleIds) {
59         Preconditions.checkNotNull(rootModules, "Base modules cannot be null.");
60         Preconditions.checkNotNull(additionalModuleIds, "Additional modules cannot be null.");
61
62         final Builder<Module> filteredModulesBuilder = new Builder<>();
63         final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(), MODULE_SET_SUPPLIER);
64         final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(new TreeMap<>(), MODULE_SET_SUPPLIER);
65
66         ImmutableMap.Builder<ModuleIdentifier, String> identifiersToSourcesBuilder = ImmutableMap.builder();
67
68         //preparing map to get all modules with one name but difference in revision
69         final TreeMultimap<String, Module> nameToModulesAll = getStringModuleTreeMultimap();
70
71         nameToModulesAll.putAll(getStringModuleMap(delegate));
72
73         //in case there is a particular dependancy to view filteredModules/yang models
74         //dependancy is checked for module name and imports
75         processForRootModules(delegate, rootModules, filteredModulesBuilder);
76
77         //adding additional modules
78         processForAdditionalModules(delegate, additionalModuleIds, filteredModulesBuilder);
79
80         filteredModulesBuilder.addAll(getImportedModules(
81                 Maps.uniqueIndex(delegate.getModules(), ModuleId.MODULE_TO_MODULE_ID::apply),
82                 filteredModulesBuilder.build(), nameToModulesAll));
83
84         /**
85          * Instead of doing this on each invocation of getModules(), pre-compute
86          * it once and keep it around -- better than the set we got in.
87          */
88         this.filteredModules = filteredModulesBuilder.build();
89
90         for (final Module module :filteredModules) {
91             nameMap.put(module.getName(), module);
92             nsMap.put(module.getNamespace(), module);
93             identifiersToSourcesBuilder.put(module, module.getSource());
94         }
95
96         namespaceToModules = ImmutableSetMultimap.copyOf(nsMap);
97         nameToModules = ImmutableSetMultimap.copyOf(nameMap);
98         identifiersToSources = identifiersToSourcesBuilder.build();
99     }
100
101     private static TreeMultimap<String, Module> getStringModuleTreeMultimap() {
102         return TreeMultimap.create(String::compareTo, REVISION_COMPARATOR);
103     }
104
105     private static void processForAdditionalModules(final SchemaContext delegate,
106             final Set<ModuleId> additionalModuleIds, final Builder<Module> filteredModulesBuilder) {
107         filteredModulesBuilder.addAll(Collections2.filter(delegate.getModules(),
108             module -> selectAdditionalModules(module, additionalModuleIds)));
109     }
110
111     private void processForRootModules(final SchemaContext delegate, final Collection<ModuleId> rootModules,
112             final Builder<Module> filteredModulesBuilder) {
113         filteredModulesBuilder.addAll(Collections2.filter(delegate.getModules(),
114             module -> checkModuleDependency(module, rootModules)));
115     }
116
117     private static Multimap<String, Module> getStringModuleMap(final SchemaContext delegate) {
118         return Multimaps.index(delegate.getModules(), Module::getName);
119     }
120
121     //dealing with imported module other than root and directly importing root
122     private static Collection<Module> getImportedModules(final Map<ModuleId, Module> allModules,
123             final Set<Module> baseModules, final TreeMultimap<String, Module> nameToModulesAll) {
124
125         List<Module> relatedModules = Lists.newLinkedList();
126
127         for (Module module : baseModules) {
128             for (ModuleImport moduleImport : module.getImports()) {
129
130                 Date revisionDate = moduleImport.getRevision() == null
131                     ? nameToModulesAll.get(moduleImport.getModuleName()).first().getRevision()
132                     : moduleImport.getRevision();
133
134                 ModuleId key = new ModuleId(moduleImport.getModuleName(),revisionDate);
135                 Module importedModule = allModules.get(key);
136
137                 Preconditions.checkArgument(importedModule != null,
138                         "Invalid schema, cannot find imported module: %s from module: %s, %s, modules:%s", key,
139                         module.getQNameModule(), module.getName());
140                 relatedModules.add(importedModule);
141
142                 //calling imports recursive
143                 relatedModules.addAll(getImportedModules(allModules, Collections.singleton(importedModule),
144                             nameToModulesAll));
145             }
146         }
147
148         return relatedModules;
149     }
150
151     @Override
152     protected Map<ModuleIdentifier, String> getIdentifiersToSources() {
153         return identifiersToSources;
154     }
155
156     @Override
157     public Set<Module> getModules() {
158         return filteredModules;
159     }
160
161     @Override
162     protected SetMultimap<URI, Module> getNamespaceToModules() {
163         return namespaceToModules;
164     }
165
166     @Override
167     protected SetMultimap<String, Module> getNameToModules() {
168         return nameToModules;
169     }
170
171     private static boolean selectAdditionalModules(final Module module, final Set<ModuleId> additionalModules) {
172         return additionalModules.contains(new ModuleId(module.getName(), module.getRevision()));
173     }
174
175     //check for any dependency regarding given string
176     private boolean checkModuleDependency(final Module module, final Collection<ModuleId> rootModules) {
177
178         for (ModuleId rootModule : rootModules) {
179
180             if (rootModule.equals(new ModuleId(module.getName(), module.getRevision()))) {
181                 return true;
182             }
183
184             //handling/checking imports regarding root modules
185             for (ModuleImport moduleImport : module.getImports()) {
186
187                 if (moduleImport.getModuleName().equals(rootModule.getName())) {
188
189                     if (moduleImport.getRevision() != null && !moduleImport.getRevision().equals(rootModule.getRev())) {
190                         return false;
191                     }
192
193                     return true;
194                 }
195             }
196
197             //submodules handling
198             for (Module moduleSub : module.getSubmodules()) {
199                 return checkModuleDependency(moduleSub, rootModules);
200             }
201         }
202
203         return false;
204     }
205
206     @Override
207     public String toString() {
208         return String.format("SchemaContextProxyImpl{filteredModules=%s}", filteredModules);
209     }
210
211     public static final class ModuleId {
212         private final String name;
213         private final Date rev;
214
215         public ModuleId(final String name, final Date rev) {
216             Preconditions.checkArgument(!Strings.isNullOrEmpty(name),
217                     "No module dependency name given. Nothing to do.");
218             this.name = name;
219             this.rev = Preconditions.checkNotNull(rev, "No revision date given. Nothing to do.");
220         }
221
222         public String getName() {
223             return name;
224         }
225
226         public Date getRev() {
227             return rev;
228         }
229
230         public static final Function<Module, ModuleId> MODULE_TO_MODULE_ID = input -> new ModuleId(input.getName(),
231             input.getRevision());
232
233         @Override
234         public boolean equals(final Object obj) {
235             if (this == obj) {
236                 return true;
237             }
238             if (!(obj instanceof ModuleId)) {
239                 return false;
240             }
241
242             ModuleId moduleId = (ModuleId) obj;
243             if (name != null ? !name.equals(moduleId.name) : moduleId.name != null) {
244                 return false;
245             }
246             if (rev != null ? !rev.equals(moduleId.rev) : moduleId.rev != null) {
247                 return false;
248             }
249
250             return true;
251         }
252
253         @Override
254         public int hashCode() {
255             int result = name != null ? name.hashCode() : 0;
256             result = 31 * result + (rev != null ? rev.hashCode() : 0);
257             return result;
258         }
259
260         @Override
261         public String toString() {
262
263             return String.format("ModuleId{name='%s', rev=%s}",name,rev);
264         }
265     }
266 }