Fixed bugs in parsing enumeration, augment, identity.
[controller.git] / opendaylight / sal / yang-prototype / code-generator / yang-model-parser-impl / src / main / java / org / opendaylight / controller / yang / model / parser / impl / YangModelParserImpl.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.controller.yang.model.parser.impl;
9
10 import java.io.File;
11 import java.io.FileInputStream;
12 import java.io.FileNotFoundException;
13 import java.io.IOException;
14 import java.io.InputStream;
15 import java.net.URI;
16 import java.util.ArrayList;
17 import java.util.Collections;
18 import java.util.Date;
19 import java.util.HashMap;
20 import java.util.HashSet;
21 import java.util.Iterator;
22 import java.util.List;
23 import java.util.Map;
24 import java.util.NoSuchElementException;
25 import java.util.Set;
26 import java.util.TreeMap;
27
28 import org.antlr.v4.runtime.ANTLRInputStream;
29 import org.antlr.v4.runtime.CommonTokenStream;
30 import org.antlr.v4.runtime.tree.ParseTree;
31 import org.antlr.v4.runtime.tree.ParseTreeWalker;
32 import org.opendaylight.controller.antlrv4.code.gen.YangLexer;
33 import org.opendaylight.controller.antlrv4.code.gen.YangParser;
34 import org.opendaylight.controller.yang.common.QName;
35 import org.opendaylight.controller.yang.model.api.DataSchemaNode;
36 import org.opendaylight.controller.yang.model.api.ExtensionDefinition;
37 import org.opendaylight.controller.yang.model.api.Module;
38 import org.opendaylight.controller.yang.model.api.ModuleImport;
39 import org.opendaylight.controller.yang.model.api.MustDefinition;
40 import org.opendaylight.controller.yang.model.api.NotificationDefinition;
41 import org.opendaylight.controller.yang.model.api.RpcDefinition;
42 import org.opendaylight.controller.yang.model.api.SchemaContext;
43 import org.opendaylight.controller.yang.model.api.SchemaPath;
44 import org.opendaylight.controller.yang.model.api.TypeDefinition;
45 import org.opendaylight.controller.yang.model.api.type.BinaryTypeDefinition;
46 import org.opendaylight.controller.yang.model.api.type.DecimalTypeDefinition;
47 import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition;
48 import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
49 import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
50 import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
51 import org.opendaylight.controller.yang.model.api.type.StringTypeDefinition;
52 import org.opendaylight.controller.yang.model.parser.api.YangModelParser;
53 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationSchemaBuilder;
54 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationTargetBuilder;
55 import org.opendaylight.controller.yang.model.parser.builder.api.Builder;
56 import org.opendaylight.controller.yang.model.parser.builder.api.ChildNodeBuilder;
57 import org.opendaylight.controller.yang.model.parser.builder.api.DataSchemaNodeBuilder;
58 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;
59 import org.opendaylight.controller.yang.model.parser.builder.api.TypeAwareBuilder;
60 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;
61 import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
62 import org.opendaylight.controller.yang.model.parser.builder.impl.AnyXmlBuilder;
63 import org.opendaylight.controller.yang.model.parser.builder.impl.ChoiceBuilder;
64 import org.opendaylight.controller.yang.model.parser.builder.impl.ContainerSchemaNodeBuilder;
65 import org.opendaylight.controller.yang.model.parser.builder.impl.IdentitySchemaNodeBuilder;
66 import org.opendaylight.controller.yang.model.parser.builder.impl.IdentityrefTypeBuilder;
67 import org.opendaylight.controller.yang.model.parser.builder.impl.LeafListSchemaNodeBuilder;
68 import org.opendaylight.controller.yang.model.parser.builder.impl.LeafSchemaNodeBuilder;
69 import org.opendaylight.controller.yang.model.parser.builder.impl.ListSchemaNodeBuilder;
70 import org.opendaylight.controller.yang.model.parser.builder.impl.ModuleBuilder;
71 import org.opendaylight.controller.yang.model.parser.builder.impl.TypedefBuilder;
72 import org.opendaylight.controller.yang.model.parser.builder.impl.UnionTypeBuilder;
73 import org.opendaylight.controller.yang.model.parser.util.ParserUtils;
74 import org.opendaylight.controller.yang.model.parser.util.RefineHolder;
75 import org.opendaylight.controller.yang.model.parser.util.RefineHolder.Refine;
76 import org.opendaylight.controller.yang.model.parser.util.TypeConstraints;
77 import org.opendaylight.controller.yang.model.parser.util.YangParseException;
78 import org.opendaylight.controller.yang.model.util.ExtendedType;
79 import org.opendaylight.controller.yang.model.util.IdentityrefType;
80 import org.opendaylight.controller.yang.model.util.UnknownType;
81 import org.opendaylight.controller.yang.model.validator.YangModelBasicValidator;
82 import org.slf4j.Logger;
83 import org.slf4j.LoggerFactory;
84
85 public class YangModelParserImpl implements YangModelParser {
86
87     private static final Logger logger = LoggerFactory
88             .getLogger(YangModelParserImpl.class);
89
90     @Override
91     public Module parseYangModel(final String yangFile) {
92         final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangFile);
93         final Set<Module> result = build(modules);
94         return result.iterator().next();
95     }
96
97     @Override
98     public Set<Module> parseYangModels(final String... yangFiles) {
99         final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangFiles);
100         return build(modules);
101     }
102
103     @Override
104     public Set<Module> parseYangModelsFromStreams(
105             final InputStream... yangModelStreams) {
106         final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams);
107         return build(modules);
108     }
109
110     @Override
111     public SchemaContext resolveSchemaContext(final Set<Module> modules) {
112         return new SchemaContextImpl(modules);
113     }
114
115     private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(
116             final String... yangFiles) {
117         final InputStream[] streams = loadStreams(yangFiles);
118         Map<String, TreeMap<Date, ModuleBuilder>> result = Collections
119                 .emptyMap();
120
121         if (streams != null) {
122             result = resolveModuleBuilders(streams);
123             closeStreams(streams);
124         }
125         return result;
126     }
127
128     private InputStream[] loadStreams(final String... yangFiles) {
129         final InputStream[] streams = new InputStream[yangFiles.length];
130         for (int i = 0; i < yangFiles.length; i++) {
131             final String yangFileName = yangFiles[i];
132             final File yangFile = new File(yangFileName);
133             try {
134                 streams[i] = new FileInputStream(yangFile);
135             } catch (FileNotFoundException e) {
136                 logger.warn("Exception while reading yang stream: "
137                         + streams[i], e);
138             }
139         }
140         return streams;
141     }
142
143     private void closeStreams(final InputStream[] streams) {
144         if (streams != null) {
145             for (int i = 0; i < streams.length; i++) {
146                 try {
147                     if (streams[i] != null) {
148                         streams[i].close();
149                     }
150                 } catch (IOException e) {
151                     logger.warn("Exception while closing yang stream: "
152                             + streams[i], e);
153                 }
154             }
155         }
156     }
157
158     private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(
159             final InputStream... yangFiles) {
160         final Map<String, TreeMap<Date, ModuleBuilder>> modules = new HashMap<String, TreeMap<Date, ModuleBuilder>>();
161         final ParseTreeWalker walker = new ParseTreeWalker();
162         final List<ParseTree> trees = parseStreams(yangFiles);
163         final ModuleBuilder[] builders = new ModuleBuilder[trees.size()];
164
165         // validate yang
166         new YangModelBasicValidator(walker).validate(trees);
167
168         YangModelParserListenerImpl yangModelParser = null;
169         for (int i = 0; i < trees.size(); i++) {
170             yangModelParser = new YangModelParserListenerImpl();
171             walker.walk(yangModelParser, trees.get(i));
172             builders[i] = yangModelParser.getModuleBuilder();
173         }
174
175         for (ModuleBuilder builder : builders) {
176             final String builderName = builder.getName();
177             Date builderRevision = builder.getRevision();
178             if (builderRevision == null) {
179                 builderRevision = new Date(0L);
180             }
181             TreeMap<Date, ModuleBuilder> builderByRevision = modules
182                     .get(builderName);
183             if (builderByRevision == null) {
184                 builderByRevision = new TreeMap<Date, ModuleBuilder>();
185             }
186             builderByRevision.put(builderRevision, builder);
187             modules.put(builderName, builderByRevision);
188         }
189         return modules;
190     }
191
192     private List<ParseTree> parseStreams(final InputStream... yangStreams) {
193         final List<ParseTree> trees = new ArrayList<ParseTree>();
194         for (InputStream yangStream : yangStreams) {
195             trees.add(parseStream(yangStream));
196         }
197         return trees;
198     }
199
200     private ParseTree parseStream(final InputStream yangStream) {
201         ParseTree result = null;
202         try {
203             final ANTLRInputStream input = new ANTLRInputStream(yangStream);
204             final YangLexer lexer = new YangLexer(input);
205             final CommonTokenStream tokens = new CommonTokenStream(lexer);
206             final YangParser parser = new YangParser(tokens);
207             result = parser.yang();
208         } catch (IOException e) {
209             logger.warn("Exception while reading yang file: " + yangStream, e);
210         }
211         return result;
212     }
213
214     private Set<Module> build(
215             final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
216         // fix unresolved nodes
217         for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules
218                 .entrySet()) {
219             for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue()
220                     .entrySet()) {
221                 final ModuleBuilder moduleBuilder = childEntry.getValue();
222                 fixUnresolvedNodes(modules, moduleBuilder);
223             }
224         }
225         resolveAugments(modules);
226
227         // build
228         final Set<Module> result = new HashSet<Module>();
229         for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules
230                 .entrySet()) {
231             final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();
232             for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue()
233                     .entrySet()) {
234                 final ModuleBuilder moduleBuilder = childEntry.getValue();
235                 final Module module = moduleBuilder.build();
236                 modulesByRevision.put(childEntry.getKey(), module);
237                 result.add(module);
238             }
239         }
240         return result;
241     }
242
243     private void fixUnresolvedNodes(
244             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
245             final ModuleBuilder builder) {
246         resolveDirtyNodes(modules, builder);
247         resolveIdentities(modules, builder);
248         resolveUses(modules, builder);
249     }
250
251     /**
252      * Search for dirty nodes (node which contains UnknownType) and resolve
253      * unknown types.
254      *
255      * @param modules
256      *            all available modules
257      * @param module
258      *            current module
259      */
260     private void resolveDirtyNodes(
261             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
262             final ModuleBuilder module) {
263         final Map<List<String>, TypeAwareBuilder> dirtyNodes = module
264                 .getDirtyNodes();
265         if (!dirtyNodes.isEmpty()) {
266             for (Map.Entry<List<String>, TypeAwareBuilder> entry : dirtyNodes
267                     .entrySet()) {
268
269                 final TypeAwareBuilder nodeToResolve = entry.getValue();
270                 // different handling for union types
271                 if (nodeToResolve instanceof UnionTypeBuilder) {
272                     final UnionTypeBuilder union = (UnionTypeBuilder) nodeToResolve;
273                     final List<TypeDefinition<?>> unionTypes = union.getTypes();
274                     final List<UnknownType> toRemove = new ArrayList<UnknownType>();
275                     for (TypeDefinition<?> td : unionTypes) {
276                         if (td instanceof UnknownType) {
277                             final UnknownType unknownType = (UnknownType) td;
278                             final TypeDefinitionBuilder resolvedType = resolveTypeUnion(
279                                     nodeToResolve, unknownType, modules, module);
280                             union.setType(resolvedType);
281                             toRemove.add(unknownType);
282                         }
283                     }
284                     unionTypes.removeAll(toRemove);
285                 } else if(nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
286                     IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder)nodeToResolve.getTypedef();
287                     nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref)));
288                 } else {
289                     final TypeDefinitionBuilder resolvedType = resolveType(
290                             nodeToResolve, modules, module);
291                     nodeToResolve.setType(resolvedType);
292                 }
293             }
294         }
295     }
296
297     private TypeDefinitionBuilder resolveType(
298             final TypeAwareBuilder typeToResolve,
299             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
300             final ModuleBuilder builder) {
301         final TypeConstraints constraints = new TypeConstraints();
302
303         final TypeDefinitionBuilder targetType = getTypedefBuilder(
304                 typeToResolve, modules, builder);
305         final TypeConstraints tConstraints = findConstraints(typeToResolve,
306                 constraints, modules, builder);
307         targetType.setRanges(tConstraints.getRange());
308         targetType.setLengths(tConstraints.getLength());
309         targetType.setPatterns(tConstraints.getPatterns());
310         targetType.setFractionDigits(tConstraints.getFractionDigits());
311
312         return targetType;
313     }
314
315     private TypeDefinitionBuilder resolveTypeUnion(
316             final TypeAwareBuilder typeToResolve,
317             final UnknownType unknownType,
318             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
319             final ModuleBuilder builder) {
320         final TypeConstraints constraints = new TypeConstraints();
321
322         final TypeDefinitionBuilder targetType = getUnionBuilder(typeToResolve,
323                 unknownType, modules, builder);
324         final TypeConstraints tConstraints = findConstraints(typeToResolve,
325                 constraints, modules, builder);
326         targetType.setRanges(tConstraints.getRange());
327         targetType.setLengths(tConstraints.getLength());
328         targetType.setPatterns(tConstraints.getPatterns());
329         targetType.setFractionDigits(tConstraints.getFractionDigits());
330
331         return targetType;
332     }
333
334     private TypeDefinitionBuilder getTypedefBuilder(
335             final TypeAwareBuilder nodeToResolve,
336             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
337             final ModuleBuilder builder) {
338
339         final TypeDefinition<?> nodeToResolveBase = nodeToResolve.getType();
340         if (nodeToResolveBase != null
341                 && !(nodeToResolveBase instanceof UnknownType)) {
342             return (TypeDefinitionBuilder) nodeToResolve;
343         }
344
345         final UnknownType unknownType = (UnknownType) nodeToResolve.getType();
346         final QName unknownTypeQName = unknownType.getQName();
347
348         // search for module which contains referenced typedef
349         final ModuleBuilder dependentModule = findDependentModule(modules,
350                 builder, unknownTypeQName.getPrefix());
351         final TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilderByName(
352                 dependentModule, unknownTypeQName.getLocalName());
353
354         final TypeDefinitionBuilder lookedUpBuilderCopy = copyTypedefBuilder(
355                 lookedUpBuilder, nodeToResolve instanceof TypeDefinitionBuilder);
356         final TypeDefinitionBuilder resolvedCopy = resolveCopiedBuilder(
357                 lookedUpBuilderCopy, modules, dependentModule);
358         return resolvedCopy;
359     }
360
361     private TypeDefinitionBuilder getUnionBuilder(
362             final TypeAwareBuilder nodeToResolve,
363             final UnknownType unknownType,
364             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
365             final ModuleBuilder module) {
366
367         final TypeDefinition<?> baseTypeToResolve = nodeToResolve.getType();
368         if (baseTypeToResolve != null
369                 && !(baseTypeToResolve instanceof UnknownType)) {
370             return (TypeDefinitionBuilder) nodeToResolve;
371         }
372
373         final QName unknownTypeQName = unknownType.getQName();
374         // search for module which contains referenced typedef
375         final ModuleBuilder dependentModule = findDependentModule(modules,
376                 module, unknownTypeQName.getPrefix());
377         final TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilderByName(
378                 dependentModule, unknownTypeQName.getLocalName());
379
380         final TypeDefinitionBuilder lookedUpBuilderCopy = copyTypedefBuilder(
381                 lookedUpBuilder, nodeToResolve instanceof TypeDefinitionBuilder);
382         final TypeDefinitionBuilder resolvedCopy = resolveCopiedBuilder(
383                 lookedUpBuilderCopy, modules, dependentModule);
384         return resolvedCopy;
385     }
386
387     private TypeDefinitionBuilder copyTypedefBuilder(
388             final TypeDefinitionBuilder old, final boolean seekByTypedefBuilder) {
389         if (old instanceof UnionTypeBuilder) {
390             final UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
391             final UnionTypeBuilder newUnion = new UnionTypeBuilder();
392             for (TypeDefinition<?> td : oldUnion.getTypes()) {
393                 newUnion.setType(td);
394             }
395             for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
396                 newUnion.setType(copyTypedefBuilder(tdb, true));
397             }
398             return newUnion;
399         }
400
401         final QName oldName = old.getQName();
402         final QName newName = new QName(oldName.getNamespace(),
403                 oldName.getRevision(), oldName.getPrefix(),
404                 oldName.getLocalName());
405         final TypeDefinitionBuilder tdb = new TypedefBuilder(newName);
406
407         tdb.setRanges(old.getRanges());
408         tdb.setLengths(old.getLengths());
409         tdb.setPatterns(old.getPatterns());
410         tdb.setFractionDigits(old.getFractionDigits());
411
412         final TypeDefinition<?> oldType = old.getType();
413         if (oldType == null) {
414             tdb.setType(old.getTypedef());
415         } else {
416             tdb.setType(oldType);
417         }
418
419         if (!seekByTypedefBuilder) {
420             tdb.setDescription(old.getDescription());
421             tdb.setReference(old.getReference());
422             tdb.setStatus(old.getStatus());
423             tdb.setDefaultValue(old.getDefaultValue());
424             tdb.setUnits(old.getUnits());
425         }
426         return tdb;
427     }
428
429     private TypeDefinitionBuilder resolveCopiedBuilder(
430             final TypeDefinitionBuilder copy,
431             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
432             final ModuleBuilder builder) {
433
434         if (copy instanceof UnionTypeBuilder) {
435             final UnionTypeBuilder union = (UnionTypeBuilder) copy;
436             final List<TypeDefinition<?>> unionTypes = union.getTypes();
437             final List<UnknownType> toRemove = new ArrayList<UnknownType>();
438             for (TypeDefinition<?> td : unionTypes) {
439                 if (td instanceof UnknownType) {
440                     final UnknownType unknownType = (UnknownType) td;
441                     final TypeDefinitionBuilder resolvedType = resolveTypeUnion(
442                             union, unknownType, modules, builder);
443                     union.setType(resolvedType);
444                     toRemove.add(unknownType);
445                 }
446             }
447             unionTypes.removeAll(toRemove);
448
449             return union;
450         }
451
452         final TypeDefinition<?> base = copy.getType();
453         final TypeDefinitionBuilder baseTdb = copy.getTypedef();
454         if (base != null && !(base instanceof UnknownType)) {
455             return copy;
456         } else if (base instanceof UnknownType) {
457             final UnknownType unknownType = (UnknownType) base;
458             final QName unknownTypeQName = unknownType.getQName();
459             final String unknownTypePrefix = unknownTypeQName.getPrefix();
460             final ModuleBuilder dependentModule = findDependentModule(modules,
461                     builder, unknownTypePrefix);
462             final TypeDefinitionBuilder utBuilder = getTypedefBuilder(copy,
463                     modules, dependentModule);
464             copy.setType(utBuilder);
465             return copy;
466         } else if (base == null && baseTdb != null) {
467             // make a copy of baseTypeDef and call again
468             final TypeDefinitionBuilder baseTdbCopy = copyTypedefBuilder(
469                     baseTdb, true);
470             final TypeDefinitionBuilder baseTdbCopyResolved = resolveCopiedBuilder(
471                     baseTdbCopy, modules, builder);
472             copy.setType(baseTdbCopyResolved);
473             return copy;
474         } else {
475             throw new IllegalStateException(
476                     "TypeDefinitionBuilder in unexpected state");
477         }
478     }
479
480     private TypeDefinitionBuilder findTypedefBuilder(
481             final QName unknownTypeQName,
482             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
483             final ModuleBuilder builder) {
484
485         // search for module which contains referenced typedef
486         final ModuleBuilder dependentModule = findDependentModule(modules,
487                 builder, unknownTypeQName.getPrefix());
488
489         final TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilderByName(
490                 dependentModule, unknownTypeQName.getLocalName());
491
492         return copyTypedefBuilder(lookedUpBuilder, true);
493     }
494
495     private TypeConstraints findConstraints(
496             final TypeAwareBuilder nodeToResolve,
497             final TypeConstraints constraints,
498             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
499             final ModuleBuilder builder) {
500
501         // union type cannot be restricted
502         if (nodeToResolve instanceof UnionTypeBuilder) {
503             return constraints;
504         }
505
506         // if referenced type is UnknownType again, search recursively with
507         // current constraints
508         final TypeDefinition<?> referencedType = nodeToResolve.getType();
509         List<RangeConstraint> ranges = Collections.emptyList();
510         List<LengthConstraint> lengths = Collections.emptyList();
511         List<PatternConstraint> patterns = Collections.emptyList();
512         Integer fractionDigits = null;
513         if (referencedType == null) {
514             final TypeDefinitionBuilder tdb = (TypeDefinitionBuilder) nodeToResolve;
515             ranges = tdb.getRanges();
516             constraints.addRanges(ranges);
517             lengths = tdb.getLengths();
518             constraints.addLengths(lengths);
519             patterns = tdb.getPatterns();
520             constraints.addPatterns(patterns);
521             fractionDigits = tdb.getFractionDigits();
522             constraints.setFractionDigits(fractionDigits);
523             return constraints;
524         } else if (referencedType instanceof ExtendedType) {
525             final ExtendedType ext = (ExtendedType) referencedType;
526             ranges = ext.getRanges();
527             constraints.addRanges(ranges);
528             lengths = ext.getLengths();
529             constraints.addLengths(lengths);
530             patterns = ext.getPatterns();
531             constraints.addPatterns(patterns);
532             fractionDigits = ext.getFractionDigits();
533             constraints.setFractionDigits(fractionDigits);
534             return findConstraints(
535                     findTypedefBuilder(ext.getQName(), modules, builder),
536                     constraints, modules, builder);
537         } else if (referencedType instanceof UnknownType) {
538             final UnknownType unknown = (UnknownType) referencedType;
539             ranges = unknown.getRangeStatements();
540             constraints.addRanges(ranges);
541             lengths = unknown.getLengthStatements();
542             constraints.addLengths(lengths);
543             patterns = unknown.getPatterns();
544             constraints.addPatterns(patterns);
545             fractionDigits = unknown.getFractionDigits();
546             constraints.setFractionDigits(fractionDigits);
547
548             String unknownTypePrefix = unknown.getQName().getPrefix();
549             if (unknownTypePrefix == null || "".equals(unknownTypePrefix)) {
550                 unknownTypePrefix = builder.getPrefix();
551             }
552             final ModuleBuilder dependentModule = findDependentModule(modules,
553                     builder, unknown.getQName().getPrefix());
554             final TypeDefinitionBuilder utBuilder = findTypedefBuilder(
555                     unknown.getQName(), modules, builder);
556             return findConstraints(utBuilder, constraints, modules,
557                     dependentModule);
558         } else {
559             // HANDLE BASE YANG TYPE
560             mergeConstraints(referencedType, constraints);
561             return constraints;
562         }
563
564     }
565
566     /**
567      * Go through all typedef statements from given module and search for one
568      * with given name
569      *
570      * @param typedefs
571      *            typedef statements to search
572      * @param name
573      *            name of searched typedef
574      * @return typedef with name equals to given name
575      */
576     private TypeDefinitionBuilder findTypedefBuilderByName(
577             final ModuleBuilder dependentModule, final String name) {
578         TypeDefinitionBuilder result = null;
579         final Set<TypeDefinitionBuilder> typedefs = dependentModule
580                 .getModuleTypedefs();
581         for (TypeDefinitionBuilder td : typedefs) {
582             if (td.getQName().getLocalName().equals(name)) {
583                 result = td;
584                 break;
585             }
586         }
587         if (result == null) {
588             throw new YangParseException("Target module '"
589                     + dependentModule.getName()
590                     + "' does not contain typedef '" + name + "'.");
591         }
592         return result;
593     }
594
595     /**
596      * Pull restriction from referenced type and add them to given constraints
597      *
598      * @param referencedType
599      * @param constraints
600      */
601     private void mergeConstraints(final TypeDefinition<?> referencedType,
602             final TypeConstraints constraints) {
603
604         if (referencedType instanceof DecimalTypeDefinition) {
605             constraints.addRanges(((DecimalTypeDefinition) referencedType)
606                     .getRangeStatements());
607             constraints
608                     .setFractionDigits(((DecimalTypeDefinition) referencedType)
609                             .getFractionDigits());
610         } else if (referencedType instanceof IntegerTypeDefinition) {
611             constraints.addRanges(((IntegerTypeDefinition) referencedType)
612                     .getRangeStatements());
613         } else if (referencedType instanceof StringTypeDefinition) {
614             constraints.addPatterns(((StringTypeDefinition) referencedType)
615                     .getPatterns());
616             constraints.addLengths(((StringTypeDefinition) referencedType)
617                     .getLengthStatements());
618         } else if (referencedType instanceof BinaryTypeDefinition) {
619             constraints.addLengths(((BinaryTypeDefinition) referencedType)
620                     .getLengthConstraints());
621         }
622     }
623
624     /**
625      * Go through all augmentation definitions and resolve them. This method
626      * also finds referenced node and add child nodes to it.
627      *
628      * @param modules
629      *            all available modules
630      */
631     private void resolveAugments(
632             final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
633         final List<ModuleBuilder> allModulesList = new ArrayList<ModuleBuilder>();
634         final Set<ModuleBuilder> allModulesSet = new HashSet<ModuleBuilder>();
635         for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules
636                 .entrySet()) {
637             for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue()
638                     .entrySet()) {
639                 allModulesList.add(inner.getValue());
640                 allModulesSet.add(inner.getValue());
641             }
642         }
643
644         for (int i = 0; i < allModulesList.size(); i++) {
645             final ModuleBuilder module = allModulesList.get(i);
646             // try to resolve augments in module
647             resolveAugment(modules, module);
648             // while all augments are not resolved
649             final Iterator<ModuleBuilder> allModulesIterator = allModulesSet
650                     .iterator();
651             while (!(module.getAugmentsResolved() == module.getAddedAugments()
652                     .size())) {
653                 ModuleBuilder nextModule = null;
654                 // try resolve other module augments
655                 try {
656                     nextModule = allModulesIterator.next();
657                     resolveAugment(modules, nextModule);
658                 } catch (NoSuchElementException e) {
659                     throw new YangParseException(
660                             "Failed to resolve augments in module '"
661                                     + module.getName() + "'.", e);
662                 }
663                 // then try to resolve first module again
664                 resolveAugment(modules, module);
665             }
666         }
667     }
668
669     private void resolveAugment(
670             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
671             final ModuleBuilder module) {
672         if (module.getAugmentsResolved() < module.getAddedAugments().size()) {
673             for (AugmentationSchemaBuilder augmentBuilder : module
674                     .getAddedAugments()) {
675                 final SchemaPath augmentTargetSchemaPath = augmentBuilder
676                         .getTargetPath();
677                 final List<QName> path = augmentTargetSchemaPath.getPath();
678
679                 int i = 0;
680                 final QName qname = path.get(i);
681                 String prefix = qname.getPrefix();
682                 if(prefix == null) {
683                     prefix = module.getPrefix();
684                 }
685
686                 DataSchemaNodeBuilder currentParent = null;
687                 final ModuleBuilder dependentModule = findDependentModule(
688                         modules, module, prefix);
689                 for (DataSchemaNodeBuilder child : dependentModule
690                         .getChildNodes()) {
691                     final QName childQName = child.getQName();
692                     if (childQName.getLocalName().equals(qname.getLocalName())) {
693                         currentParent = child;
694                         i++;
695                         break;
696                     }
697                 }
698
699                 for (; i < path.size(); i++) {
700                     final QName currentQName = path.get(i);
701                     DataSchemaNodeBuilder newParent = null;
702                     for (DataSchemaNodeBuilder child : ((ChildNodeBuilder) currentParent)
703                             .getChildNodes()) {
704                         final QName childQName = child.getQName();
705                         if (childQName.getLocalName().equals(
706                                 currentQName.getLocalName())) {
707                             newParent = child;
708                             break;
709                         }
710                     }
711                     if (newParent == null) {
712                         break; // node not found, quit search
713                     } else {
714                         currentParent = newParent;
715                     }
716                 }
717
718                 final QName currentQName = currentParent.getQName();
719                 final QName lastAugmentPathElement = path.get(path.size() - 1);
720                 if (currentQName.getLocalName().equals(
721                         lastAugmentPathElement.getLocalName())) {
722                     fillAugmentTarget(augmentBuilder,
723                             (ChildNodeBuilder) currentParent);
724                     ((AugmentationTargetBuilder) currentParent)
725                             .addAugmentation(augmentBuilder);
726                     module.augmentResolved();
727                 }
728             }
729         }
730     }
731
732     /**
733      * Add all augment's child nodes to given target.
734      *
735      * @param augment
736      * @param target
737      */
738     private void fillAugmentTarget(final AugmentationSchemaBuilder augment,
739             final ChildNodeBuilder target) {
740         for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
741             builder.setAugmenting(true);
742             target.addChildNode(builder);
743         }
744     }
745
746     /**
747      * Go through identity statements defined in current module and resolve
748      * their 'base' statement if present.
749      *
750      * @param modules
751      *            all modules
752      * @param module
753      *            module being resolved
754      */
755     private void resolveIdentities(
756             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
757             final ModuleBuilder module) {
758         final Set<IdentitySchemaNodeBuilder> identities = module
759                 .getAddedIdentities();
760         for (IdentitySchemaNodeBuilder identity : identities) {
761             final String baseIdentityName = identity.getBaseIdentityName();
762             if (baseIdentityName != null) {
763                 String baseIdentityPrefix = null;
764                 String baseIdentityLocalName = null;
765                 if (baseIdentityName.contains(":")) {
766                     final String[] splitted = baseIdentityName.split(":");
767                     baseIdentityPrefix = splitted[0];
768                     baseIdentityLocalName = splitted[1];
769                 } else {
770                     baseIdentityPrefix = module.getPrefix();
771                     baseIdentityLocalName = baseIdentityName;
772                 }
773                 final ModuleBuilder dependentModule = findDependentModule(
774                         modules, module, baseIdentityPrefix);
775
776                 final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModule
777                         .getAddedIdentities();
778                 for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {
779                     if (idBuilder.getQName().getLocalName()
780                             .equals(baseIdentityLocalName)) {
781                         identity.setBaseIdentity(idBuilder);
782                     }
783                 }
784             }
785         }
786     }
787
788     /**
789      * Go through uses statements defined in current module and resolve their
790      * refine statements.
791      *
792      * @param modules
793      *            all modules
794      * @param module
795      *            module being resolved
796      */
797     private void resolveUses(
798             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
799             final ModuleBuilder module) {
800         final Map<List<String>, UsesNodeBuilder> moduleUses = module
801                 .getAddedUsesNodes();
802         for (Map.Entry<List<String>, UsesNodeBuilder> entry : moduleUses
803                 .entrySet()) {
804             final List<String> key = entry.getKey();
805             final UsesNodeBuilder usesNode = entry.getValue();
806
807             final String groupingName = key.get(key.size() - 1);
808
809             final List<RefineHolder> refines = usesNode.getRefines();
810             for (RefineHolder refine : refines) {
811                 final Refine refineType = refine.getType();
812                 // refine statements
813                 final String defaultStr = refine.getDefaultStr();
814                 final Boolean mandatory = refine.isMandatory();
815                 final MustDefinition must = refine.getMust();
816                 final Boolean presence = refine.isPresence();
817                 final Integer min = refine.getMinElements();
818                 final Integer max = refine.getMaxElements();
819
820                 switch (refineType) {
821                 case LEAF:
822                     final LeafSchemaNodeBuilder leaf = (LeafSchemaNodeBuilder) getRefineTargetBuilder(
823                             groupingName, refine, modules, module);
824                     if (defaultStr != null && !("".equals(defaultStr))) {
825                         leaf.setDefaultStr(defaultStr);
826                     }
827                     if (mandatory != null) {
828                         leaf.getConstraints().setMandatory(mandatory);
829                     }
830                     if (must != null) {
831                         leaf.getConstraints().addMustDefinition(must);
832                     }
833                     usesNode.addRefineNode(leaf);
834                     break;
835                 case CONTAINER:
836                     final ContainerSchemaNodeBuilder container = (ContainerSchemaNodeBuilder) getRefineTargetBuilder(
837                             groupingName, refine, modules, module);
838                     if (presence != null) {
839                         container.setPresence(presence);
840                     }
841                     if (must != null) {
842                         container.getConstraints().addMustDefinition(must);
843                     }
844                     usesNode.addRefineNode(container);
845                     break;
846                 case LIST:
847                     final ListSchemaNodeBuilder list = (ListSchemaNodeBuilder) getRefineTargetBuilder(
848                             groupingName, refine, modules, module);
849                     if (must != null) {
850                         list.getConstraints().addMustDefinition(must);
851                     }
852                     if (min != null) {
853                         list.getConstraints().setMinElements(min);
854                     }
855                     if (max != null) {
856                         list.getConstraints().setMaxElements(max);
857                     }
858                     break;
859                 case LEAF_LIST:
860                     final LeafListSchemaNodeBuilder leafList = (LeafListSchemaNodeBuilder) getRefineTargetBuilder(
861                             groupingName, refine, modules, module);
862                     if (must != null) {
863                         leafList.getConstraints().addMustDefinition(must);
864                     }
865                     if (min != null) {
866                         leafList.getConstraints().setMinElements(min);
867                     }
868                     if (max != null) {
869                         leafList.getConstraints().setMaxElements(max);
870                     }
871                     break;
872                 case CHOICE:
873                     final ChoiceBuilder choice = (ChoiceBuilder) getRefineTargetBuilder(
874                             groupingName, refine, modules, module);
875                     if (defaultStr != null) {
876                         choice.setDefaultCase(defaultStr);
877                     }
878                     if (mandatory != null) {
879                         choice.getConstraints().setMandatory(mandatory);
880                     }
881                     break;
882                 case ANYXML:
883                     final AnyXmlBuilder anyXml = (AnyXmlBuilder) getRefineTargetBuilder(
884                             groupingName, refine, modules, module);
885                     if (mandatory != null) {
886                         anyXml.getConstraints().setMandatory(mandatory);
887                     }
888                     if (must != null) {
889                         anyXml.getConstraints().addMustDefinition(must);
890                     }
891                 }
892             }
893         }
894     }
895
896     /**
897      * Find original builder of refine node and return copy of this builder.
898      *
899      * @param groupingPath
900      *            path to grouping which contains node to refine
901      * @param refine
902      *            refine object containing informations about refine
903      * @param modules
904      *            all loaded modules
905      * @param module
906      *            current module
907      * @return copy of Builder object of node to be refined if it is present in
908      *         grouping, null otherwise
909      */
910     private Builder getRefineTargetBuilder(final String groupingPath,
911             final RefineHolder refine,
912             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
913             final ModuleBuilder module) {
914         Builder result = null;
915         final Builder lookedUpBuilder = findRefineTargetBuilder(groupingPath,
916                 refine.getName(), modules, module);
917         if (lookedUpBuilder instanceof LeafSchemaNodeBuilder) {
918             result = ParserUtils
919                     .copyLeafBuilder((LeafSchemaNodeBuilder) lookedUpBuilder);
920         } else if (lookedUpBuilder instanceof ContainerSchemaNodeBuilder) {
921             result = ParserUtils
922                     .copyContainerBuilder((ContainerSchemaNodeBuilder) lookedUpBuilder);
923         } else if (lookedUpBuilder instanceof ListSchemaNodeBuilder) {
924             result = ParserUtils
925                     .copyListBuilder((ListSchemaNodeBuilder) lookedUpBuilder);
926         } else if (lookedUpBuilder instanceof LeafListSchemaNodeBuilder) {
927             result = ParserUtils
928                     .copyLeafListBuilder((LeafListSchemaNodeBuilder) lookedUpBuilder);
929         } else if (lookedUpBuilder instanceof ChoiceBuilder) {
930             result = ParserUtils
931                     .copyChoiceBuilder((ChoiceBuilder) lookedUpBuilder);
932         } else if (lookedUpBuilder instanceof AnyXmlBuilder) {
933             result = ParserUtils
934                     .copyAnyXmlBuilder((AnyXmlBuilder) lookedUpBuilder);
935         } else {
936             throw new YangParseException("Target '" + refine.getName()
937                     + "' can not be refined");
938         }
939         return result;
940     }
941
942     /**
943      * Find builder of refine node.
944      *
945      * @param groupingPath
946      *            path to grouping which contains node to refine
947      * @param refineNodeName
948      *            name of node to be refined
949      * @param modules
950      *            all loaded modules
951      * @param module
952      *            current module
953      * @return Builder object of refine node if it is present in grouping, null
954      *         otherwise
955      */
956     private Builder findRefineTargetBuilder(final String groupingPath,
957             final String refineNodeName,
958             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
959             final ModuleBuilder module) {
960         final SchemaPath path = ParserUtils.parseUsesPath(groupingPath);
961         final List<String> builderPath = new ArrayList<String>();
962         String prefix = null;
963         for (QName qname : path.getPath()) {
964             builderPath.add(qname.getLocalName());
965             prefix = qname.getPrefix();
966         }
967         if (prefix == null) {
968             prefix = module.getPrefix();
969         }
970
971         final ModuleBuilder dependentModule = findDependentModule(modules,
972                 module, prefix);
973         builderPath.add(0, "grouping");
974         builderPath.add(0, dependentModule.getName());
975         final GroupingBuilder builder = (GroupingBuilder) dependentModule
976                 .getNode(builderPath);
977
978         return builder.getChildNode(refineNodeName);
979     }
980
981     private QName findFullQName(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
982             final ModuleBuilder module, final IdentityrefTypeBuilder idref) {
983         QName result = null;
984         String baseString = idref.getBaseString();
985         if(baseString.contains(":")) {
986             String[] splittedBase = baseString.split(":");
987             if(splittedBase.length > 2) {
988                 throw new YangParseException("Failed to parse identityref base: "+ baseString);
989             }
990             String prefix = splittedBase[0];
991             String name = splittedBase[1];
992             ModuleBuilder dependentModule = findDependentModule(modules, module, prefix);
993             result = new QName(dependentModule.getNamespace(), dependentModule.getRevision(), prefix, name);
994         } else {
995             result = new QName(module.getNamespace(), module.getRevision(), module.getPrefix(), baseString);
996         }
997         return result;
998     }
999
1000     /**
1001      * Find dependent module based on given prefix
1002      *
1003      * @param modules
1004      *            all available modules
1005      * @param module
1006      *            current module
1007      * @param prefix
1008      *            target module prefix
1009      * @return
1010      */
1011     private ModuleBuilder findDependentModule(
1012             final Map<String, TreeMap<Date, ModuleBuilder>> modules,
1013             final ModuleBuilder module, final String prefix) {
1014         ModuleBuilder dependentModule = null;
1015         Date dependentModuleRevision = null;
1016
1017         if (prefix.equals(module.getPrefix())) {
1018             dependentModule = module;
1019         } else {
1020             final ModuleImport dependentModuleImport = ParserUtils.getModuleImport(module,
1021                     prefix);
1022             if (dependentModuleImport == null) {
1023                 throw new YangParseException("No import found with prefix '"
1024                         + prefix + "' in module " + module.getName() + "'.");
1025             }
1026             final String dependentModuleName = dependentModuleImport
1027                     .getModuleName();
1028             dependentModuleRevision = dependentModuleImport.getRevision();
1029
1030             final TreeMap<Date, ModuleBuilder> moduleBuildersByRevision = modules
1031                     .get(dependentModuleName);
1032             if (moduleBuildersByRevision == null) {
1033                 throw new YangParseException(
1034                         "Failed to find dependent module '"
1035                                 + dependentModuleName + "' needed by module '"
1036                                 + module.getName() + "'.");
1037             }
1038             if (dependentModuleRevision == null) {
1039                 dependentModule = moduleBuildersByRevision.lastEntry()
1040                         .getValue();
1041             } else {
1042                 dependentModule = moduleBuildersByRevision
1043                         .get(dependentModuleRevision);
1044             }
1045         }
1046
1047         if (dependentModule == null) {
1048             throw new YangParseException(
1049                     "Failed to find dependent module with prefix '" + prefix
1050                             + "' and revision '" + dependentModuleRevision
1051                             + "'.");
1052         }
1053         return dependentModule;
1054     }
1055
1056
1057     private static class SchemaContextImpl implements SchemaContext {
1058         private final Set<Module> modules;
1059
1060         private SchemaContextImpl(final Set<Module> modules) {
1061             this.modules = modules;
1062         }
1063
1064         @Override
1065         public Set<DataSchemaNode> getDataDefinitions() {
1066             final Set<DataSchemaNode> dataDefs = new HashSet<DataSchemaNode>();
1067             for (Module m : modules) {
1068                 dataDefs.addAll(m.getChildNodes());
1069             }
1070             return dataDefs;
1071         }
1072
1073         @Override
1074         public Set<Module> getModules() {
1075             return modules;
1076         }
1077
1078         @Override
1079         public Set<NotificationDefinition> getNotifications() {
1080             final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();
1081             for (Module m : modules) {
1082                 notifications.addAll(m.getNotifications());
1083             }
1084             return notifications;
1085         }
1086
1087         @Override
1088         public Set<RpcDefinition> getOperations() {
1089             final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();
1090             for (Module m : modules) {
1091                 rpcs.addAll(m.getRpcs());
1092             }
1093             return rpcs;
1094         }
1095
1096         @Override
1097         public Set<ExtensionDefinition> getExtensions() {
1098             final Set<ExtensionDefinition> extensions = new HashSet<ExtensionDefinition>();
1099             for (Module m : modules) {
1100                 extensions.addAll(m.getExtensionSchemaNodes());
1101             }
1102             return extensions;
1103         }
1104
1105         @Override
1106         public Module findModuleByName(final String name, final Date revision) {
1107             if ((name != null) && (revision != null)) {
1108                 for (final Module module : modules) {
1109                     if (module.getName().equals(name)
1110                             && module.getRevision().equals(revision)) {
1111                         return module;
1112                     }
1113                 }
1114             }
1115             return null;
1116         }
1117
1118         @Override
1119         public Module findModuleByNamespace(final URI namespace) {
1120             if (namespace != null) {
1121                 for (final Module module : modules) {
1122                     if (module.getNamespace().equals(namespace)) {
1123                         return module;
1124                     }
1125                 }
1126             }
1127             return null;
1128         }
1129     }
1130
1131 }