Merge "BUG-865: removed unnecessary test file."
[yangtools.git] / yang / yang-parser-impl / src / main / java / org / opendaylight / yangtools / yang / parser / impl / SchemaContextImpl.java
1 /*
2  * Copyright (c) 2013 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 package org.opendaylight.yangtools.yang.parser.impl;
9
10 import com.google.common.base.Optional;
11 import org.opendaylight.yangtools.yang.common.QName;
12 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
13 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
14 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
15 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
16 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
17 import org.opendaylight.yangtools.yang.model.api.Module;
18 import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
19 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
20 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
21 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
22 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
23 import org.opendaylight.yangtools.yang.model.api.Status;
24 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
25 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
26 import org.opendaylight.yangtools.yang.model.api.UsesNode;
27 import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
28
29 import java.net.URI;
30 import java.util.ArrayList;
31 import java.util.Collections;
32 import java.util.Date;
33 import java.util.HashSet;
34 import java.util.LinkedHashSet;
35 import java.util.List;
36 import java.util.Map;
37 import java.util.Set;
38 import java.util.TreeMap;
39
40 final class SchemaContextImpl implements SchemaContext {
41     private final Set<Module> modules;
42     private final Map<ModuleIdentifier, String> identifiersToSources;
43
44     SchemaContextImpl(final Set<Module> modules, Map<ModuleIdentifier, String> identifiersToSources) {
45         this.modules = modules;
46         this.identifiersToSources = identifiersToSources;
47     }
48
49     @Override
50     public Set<DataSchemaNode> getDataDefinitions() {
51         final Set<DataSchemaNode> dataDefs = new HashSet<DataSchemaNode>();
52         for (Module m : modules) {
53             dataDefs.addAll(m.getChildNodes());
54         }
55         return dataDefs;
56     }
57
58     @Override
59     public Set<Module> getModules() {
60         List<Module> sorted = ModuleDependencySort.sort(modules.toArray(new Module[modules.size()]));
61         return new LinkedHashSet<Module>(sorted);
62     }
63
64     @Override
65     public Set<NotificationDefinition> getNotifications() {
66         final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();
67         for (Module m : modules) {
68             notifications.addAll(m.getNotifications());
69         }
70         return notifications;
71     }
72
73     @Override
74     public Set<RpcDefinition> getOperations() {
75         final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();
76         for (Module m : modules) {
77             rpcs.addAll(m.getRpcs());
78         }
79         return rpcs;
80     }
81
82     @Override
83     public Set<ExtensionDefinition> getExtensions() {
84         final Set<ExtensionDefinition> extensions = new HashSet<ExtensionDefinition>();
85         for (Module m : modules) {
86             extensions.addAll(m.getExtensionSchemaNodes());
87         }
88         return extensions;
89     }
90
91     @Override
92     public Module findModuleByName(final String name, final Date revision) {
93         if (name != null) {
94             for (final Module module : modules) {
95                 if (revision == null) {
96                     if (module.getName().equals(name)) {
97                         return module;
98                     }
99                 } else if (module.getName().equals(name) && module.getRevision().equals(revision)) {
100                     return module;
101                 }
102             }
103         }
104         return null;
105     }
106
107     @Override
108     public Set<Module> findModuleByNamespace(final URI namespace) {
109         final Set<Module> ret = new HashSet<Module>();
110         if (namespace != null) {
111             for (final Module module : modules) {
112                 if (module.getNamespace().equals(namespace)) {
113                     ret.add(module);
114                 }
115             }
116         }
117         return ret;
118     }
119
120     @Override
121     public Module findModuleByNamespaceAndRevision(URI namespace, Date revision) {
122         if (namespace != null) {
123             Set<Module> modules = findModuleByNamespace(namespace);
124
125             if (revision == null) {
126                 TreeMap<Date, Module> map = new TreeMap<Date, Module>();
127                 for (Module module : modules) {
128                     map.put(module.getRevision(), module);
129                 }
130                 if (map.isEmpty()) {
131                     return null;
132                 }
133                 return map.lastEntry().getValue();
134             } else {
135                 for (Module module : modules) {
136                     if (module.getRevision().equals(revision)) {
137                         return(module);
138                     }
139                 }
140             }
141         }
142         return null;
143     }
144
145     @Override
146     public boolean isAugmenting() {
147         return false;
148     }
149
150     @Override
151     public boolean isAddedByUses() {
152         return false;
153     }
154
155     @Override
156     public boolean isConfiguration() {
157         return false;
158     }
159
160     @Override
161     public ConstraintDefinition getConstraints() {
162         return null;
163     }
164
165     @Override
166     public QName getQName() {
167         return SchemaContext.NAME;
168     }
169
170     @Override
171     public SchemaPath getPath() {
172         return null;
173     }
174
175     @Override
176     public String getDescription() {
177         return null;
178     }
179
180     @Override
181     public String getReference() {
182         return null;
183     }
184
185     @Override
186     public Status getStatus() {
187         return Status.CURRENT;
188     }
189
190     @Override
191     public List<UnknownSchemaNode> getUnknownSchemaNodes() {
192         final List<UnknownSchemaNode> result = new ArrayList<>();
193         for (Module module : modules) {
194             result.addAll(module.getUnknownSchemaNodes());
195         }
196         return Collections.unmodifiableList(result);
197     }
198
199     @Override
200     public Set<TypeDefinition<?>> getTypeDefinitions() {
201         final Set<TypeDefinition<?>> result = new LinkedHashSet<>();
202         for (Module module : modules) {
203             result.addAll(module.getTypeDefinitions());
204         }
205         return Collections.unmodifiableSet(result);
206     }
207
208     @Override
209     public Set<DataSchemaNode> getChildNodes() {
210         final Set<DataSchemaNode> result = new LinkedHashSet<>();
211         for (Module module : modules) {
212             result.addAll(module.getChildNodes());
213         }
214         return Collections.unmodifiableSet(result);
215     }
216
217     @Override
218     public Set<GroupingDefinition> getGroupings() {
219         final Set<GroupingDefinition> result = new LinkedHashSet<>();
220         for (Module module : modules) {
221             result.addAll(module.getGroupings());
222         }
223         return Collections.unmodifiableSet(result);
224     }
225
226     @Override
227     public DataSchemaNode getDataChildByName(QName name) {
228         DataSchemaNode result = null;
229         for (Module module : modules) {
230             result = module.getDataChildByName(name);
231             if (result != null) {
232                 break;
233             }
234         }
235         return result;
236     }
237
238     @Override
239     public DataSchemaNode getDataChildByName(String name) {
240         DataSchemaNode result = null;
241         for (Module module : modules) {
242             result = module.getDataChildByName(name);
243             if (result != null) {
244                 break;
245             }
246         }
247         return result;
248     }
249
250     @Override
251     public Set<UsesNode> getUses() {
252         return Collections.emptySet();
253     }
254
255     @Override
256     public boolean isPresenceContainer() {
257         return false;
258     }
259
260     @Override
261     public Set<AugmentationSchema> getAvailableAugmentations() {
262         return Collections.emptySet();
263     }
264
265     //FIXME: should work for submodules too
266     @Override
267     public Set<ModuleIdentifier> getAllModuleIdentifiers() {
268         return identifiersToSources.keySet();
269     }
270
271     @Override
272     public Optional<String> getModuleSource(ModuleIdentifier moduleIdentifier) {
273         String maybeSource = identifiersToSources.get(moduleIdentifier);
274         return Optional.fromNullable(maybeSource);
275     }
276 }