6e6206594cc419acab737c26fa281868386d3046
[controller.git] / opendaylight / sal / yang-prototype / code-generator / yang-model-parser-impl / src / main / java / org / opendaylight / controller / yang / model / parser / impl / YangModelParserListenerImpl.java
1 /*\r
2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.\r
3  *\r
4  * This program and the accompanying materials are made available under the\r
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
7  */\r
8 package org.opendaylight.controller.yang.model.parser.impl;\r
9 \r
10 import static org.opendaylight.controller.yang.model.parser.util.YangModelBuilderUtil.*;\r
11 \r
12 import java.net.URI;\r
13 import java.text.DateFormat;\r
14 import java.text.ParseException;\r
15 import java.text.SimpleDateFormat;\r
16 import java.util.Collections;\r
17 import java.util.Date;\r
18 import java.util.List;\r
19 import java.util.Stack;\r
20 import java.util.TreeMap;\r
21 \r
22 import org.antlr.v4.runtime.tree.ParseTree;\r
23 import org.opendaylight.controller.antlrv4.code.gen.YangParser;\r
24 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Argument_stmtContext;\r
25 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Base_stmtContext;\r
26 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Contact_stmtContext;\r
27 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Container_stmtContext;\r
28 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Description_stmtContext;\r
29 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_add_stmtContext;\r
30 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_delete_stmtContext;\r
31 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_not_supported_stmtContext;\r
32 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_replace_stmtContext;\r
33 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Import_stmtContext;\r
34 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Key_stmtContext;\r
35 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_list_stmtContext;\r
36 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_stmtContext;\r
37 import org.opendaylight.controller.antlrv4.code.gen.YangParser.List_stmtContext;\r
38 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Module_header_stmtsContext;\r
39 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Namespace_stmtContext;\r
40 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Ordered_by_stmtContext;\r
41 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Organization_stmtContext;\r
42 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Prefix_stmtContext;\r
43 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Presence_stmtContext;\r
44 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Reference_stmtContext;\r
45 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_date_stmtContext;\r
46 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtContext;\r
47 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtsContext;\r
48 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Status_stmtContext;\r
49 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Type_body_stmtsContext;\r
50 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Yang_version_stmtContext;\r
51 import org.opendaylight.controller.antlrv4.code.gen.YangParserBaseListener;\r
52 import org.opendaylight.controller.yang.common.QName;\r
53 import org.opendaylight.controller.yang.model.api.Status;\r
54 import org.opendaylight.controller.yang.model.api.TypeDefinition;\r
55 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationSchemaBuilder;\r
56 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;\r
57 import org.opendaylight.controller.yang.model.parser.builder.impl.ContainerSchemaNodeBuilder;\r
58 import org.opendaylight.controller.yang.model.parser.builder.impl.DeviationBuilder;\r
59 import org.opendaylight.controller.yang.model.parser.builder.impl.ExtensionBuilder;\r
60 import org.opendaylight.controller.yang.model.parser.builder.impl.FeatureBuilder;\r
61 import org.opendaylight.controller.yang.model.parser.builder.impl.IdentitySchemaNodeBuilder;\r
62 import org.opendaylight.controller.yang.model.parser.builder.impl.LeafListSchemaNodeBuilder;\r
63 import org.opendaylight.controller.yang.model.parser.builder.impl.LeafSchemaNodeBuilder;\r
64 import org.opendaylight.controller.yang.model.parser.builder.impl.ListSchemaNodeBuilder;\r
65 import org.opendaylight.controller.yang.model.parser.builder.impl.ModuleBuilder;\r
66 import org.opendaylight.controller.yang.model.parser.builder.impl.NotificationBuilder;\r
67 import org.opendaylight.controller.yang.model.parser.builder.impl.RpcDefinitionBuilder;\r
68 import org.opendaylight.controller.yang.model.parser.builder.impl.TypedefBuilder;\r
69 import org.opendaylight.controller.yang.model.parser.builder.impl.UnknownSchemaNodeBuilder;\r
70 import org.opendaylight.controller.yang.model.util.YangTypesConverter;\r
71 import org.slf4j.Logger;\r
72 import org.slf4j.LoggerFactory;\r
73 \r
74 final class YangModelParserListenerImpl extends YangParserBaseListener {\r
75 \r
76     private static final Logger logger = LoggerFactory\r
77             .getLogger(YangModelParserListenerImpl.class);\r
78 \r
79     private ModuleBuilder moduleBuilder;\r
80 \r
81     private String moduleName;\r
82     private URI namespace;\r
83     private String yangModelPrefix;\r
84     private Date revision;\r
85 \r
86     private final DateFormat simpleDateFormat = new SimpleDateFormat(\r
87             "yyyy-mm-dd");\r
88     private final Stack<String> actualPath = new Stack<String>();\r
89 \r
90 \r
91     @Override\r
92     public void enterModule_stmt(YangParser.Module_stmtContext ctx) {\r
93         moduleName = stringFromNode(ctx);\r
94         actualPath.push(moduleName);\r
95         moduleBuilder = new ModuleBuilder(moduleName);\r
96 \r
97         String description = null;\r
98         String reference = null;\r
99 \r
100         for (int i = 0; i < ctx.getChildCount(); i++) {\r
101             ParseTree child = ctx.getChild(i);\r
102             if (child instanceof Description_stmtContext) {\r
103                 description = stringFromNode(child);\r
104             } else if (child instanceof Reference_stmtContext) {\r
105                 reference = stringFromNode(child);\r
106             } else {\r
107                 if (description != null && reference != null) {\r
108                     break;\r
109                 }\r
110             }\r
111         }\r
112         moduleBuilder.setDescription(description);\r
113         moduleBuilder.setReference(reference);\r
114     }\r
115 \r
116     @Override\r
117     public void exitModule_stmt(YangParser.Module_stmtContext ctx) {\r
118         final String moduleName = actualPath.pop();\r
119         logger.debug("Exiting module " + moduleName);\r
120     }\r
121 \r
122     @Override\r
123     public void enterModule_header_stmts(final Module_header_stmtsContext ctx) {\r
124         super.enterModule_header_stmts(ctx);\r
125 \r
126         for (int i = 0; i < ctx.getChildCount(); ++i) {\r
127             final ParseTree treeNode = ctx.getChild(i);\r
128             if (treeNode instanceof Namespace_stmtContext) {\r
129                 final String namespaceStr = stringFromNode(treeNode);\r
130                 namespace = URI.create(namespaceStr);\r
131                 moduleBuilder.setNamespace(namespace);\r
132             } else if (treeNode instanceof Prefix_stmtContext) {\r
133                 yangModelPrefix = stringFromNode(treeNode);\r
134                 moduleBuilder.setPrefix(yangModelPrefix);\r
135             } else if (treeNode instanceof Yang_version_stmtContext) {\r
136                 final String yangVersion = stringFromNode(treeNode);\r
137                 moduleBuilder.setYangVersion(yangVersion);\r
138             }\r
139         }\r
140     }\r
141 \r
142     @Override\r
143     public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) {\r
144         for (int i = 0; i < ctx.getChildCount(); i++) {\r
145             ParseTree child = ctx.getChild(i);\r
146             if (child instanceof Organization_stmtContext) {\r
147                 final String organization = stringFromNode(child);\r
148                 moduleBuilder.setOrganization(organization);\r
149             } else if (child instanceof Contact_stmtContext) {\r
150                 final String contact = stringFromNode(child);\r
151                 moduleBuilder.setContact(contact);\r
152             } else if (child instanceof Description_stmtContext) {\r
153                 final String description = stringFromNode(child);\r
154                 moduleBuilder.setDescription(description);\r
155             } else if (child instanceof Reference_stmtContext) {\r
156                 final String reference = stringFromNode(child);\r
157                 moduleBuilder.setReference(reference);\r
158             }\r
159         }\r
160     }\r
161 \r
162     @Override\r
163     public void exitSubmodule_header_stmts(\r
164             YangParser.Submodule_header_stmtsContext ctx) {\r
165         final String submodule = actualPath.pop();\r
166         logger.debug("exiting submodule " + submodule);\r
167     }\r
168 \r
169     @Override\r
170     public void enterRevision_stmts(Revision_stmtsContext ctx) {\r
171         TreeMap<Date, Revision_stmtContext> revisions = new TreeMap<Date, Revision_stmtContext>();\r
172 \r
173         for (int i = 0; i < ctx.getChildCount(); ++i) {\r
174             final ParseTree treeNode = ctx.getChild(i);\r
175             if (treeNode instanceof Revision_stmtContext) {\r
176                 final String revisionDateStr = stringFromNode(treeNode);\r
177                 try {\r
178                     Date revision = simpleDateFormat.parse(revisionDateStr);\r
179                     revisions.put(revision, (Revision_stmtContext)treeNode);\r
180 \r
181                 } catch (ParseException e) {\r
182                     final String message = "Failed to parse revision string: "+ revisionDateStr;\r
183                     logger.warn(message);\r
184                 }\r
185             }\r
186         }\r
187         if(revisions.size() > 0) {\r
188             Revision_stmtContext revisionCtx = revisions.firstEntry().getValue();\r
189             moduleBuilder.setRevision(revisions.firstKey());\r
190             revision = revisions.firstKey();\r
191 \r
192             for(int i = 0; i < revisionCtx.getChildCount(); i++) {\r
193                 ParseTree child = revisionCtx.getChild(i);\r
194                 if(child instanceof Reference_stmtContext) {\r
195                     moduleBuilder.setReference(stringFromNode(child));\r
196                 }\r
197             }\r
198         }\r
199     }\r
200 \r
201     @Override\r
202     public void enterImport_stmt(Import_stmtContext ctx) {\r
203         super.enterImport_stmt(ctx);\r
204 \r
205         final String importName = stringFromNode(ctx);\r
206         String importPrefix = null;\r
207         Date importRevision = null;\r
208 \r
209         for (int i = 0; i < ctx.getChildCount(); ++i) {\r
210             final ParseTree treeNode = ctx.getChild(i);\r
211             if (treeNode instanceof Prefix_stmtContext) {\r
212                 importPrefix = stringFromNode(treeNode);\r
213             }\r
214             if (treeNode instanceof Revision_date_stmtContext) {\r
215                 String importRevisionStr = stringFromNode(treeNode);\r
216                 try {\r
217                     importRevision = simpleDateFormat.parse(importRevisionStr);\r
218                 } catch(ParseException e) {\r
219                     logger.warn("Failed to parse import revision-date: "+ importRevisionStr);\r
220                 }\r
221             }\r
222         }\r
223         moduleBuilder.addModuleImport(importName, importRevision, importPrefix);\r
224     }\r
225 \r
226     @Override\r
227     public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {\r
228         final String augmentPath = stringFromNode(ctx);\r
229         AugmentationSchemaBuilder builder = moduleBuilder.addAugment(\r
230                 augmentPath, getActualPath());\r
231         updatePath(augmentPath);\r
232 \r
233         for (int i = 0; i < ctx.getChildCount(); i++) {\r
234             ParseTree child = ctx.getChild(i);\r
235             if (child instanceof Description_stmtContext) {\r
236                 String desc = stringFromNode(child);\r
237                 builder.setDescription(desc);\r
238             } else if (child instanceof Reference_stmtContext) {\r
239                 String ref = stringFromNode(child);\r
240                 builder.setReference(ref);\r
241             } else if (child instanceof Status_stmtContext) {\r
242                 Status status = parseStatus((Status_stmtContext) child);\r
243                 builder.setStatus(status);\r
244             }\r
245         }\r
246     }\r
247 \r
248     @Override\r
249     public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {\r
250         final String augment = actualPath.pop();\r
251         logger.debug("exiting augment " + augment);\r
252     }\r
253 \r
254     @Override\r
255     public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {\r
256         String extName = stringFromNode(ctx);\r
257         QName qname = new QName(namespace, revision, yangModelPrefix, extName);\r
258         ExtensionBuilder builder = moduleBuilder.addExtension(qname);\r
259         parseSchemaNodeArgs(ctx, builder);\r
260 \r
261         String argument = null;\r
262         boolean yin = false;\r
263         for(int i = 0; i < ctx.getChildCount(); i++) {\r
264             ParseTree child = ctx.getChild(i);\r
265             if(child instanceof Argument_stmtContext) {\r
266                 argument = stringFromNode(child);\r
267                 yin = parseYinValue((Argument_stmtContext)child);\r
268                 break;\r
269             }\r
270         }\r
271         builder.setArgument(argument);\r
272         builder.setYinElement(yin);\r
273     }\r
274 \r
275     @Override\r
276     public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {\r
277         String typedefName = stringFromNode(ctx);\r
278         QName typedefQName = new QName(namespace, revision, yangModelPrefix,\r
279                 typedefName);\r
280         TypedefBuilder builder = moduleBuilder.addTypedef(typedefQName,\r
281                 getActualPath());\r
282         updatePath(typedefName);\r
283 \r
284         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,\r
285                 yangModelPrefix));\r
286         parseSchemaNodeArgs(ctx, builder);\r
287         builder.setUnits(parseUnits(ctx));\r
288     }\r
289 \r
290     @Override\r
291     public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {\r
292         final String actContainer = actualPath.pop();\r
293         logger.debug("exiting " + actContainer);\r
294     }\r
295 \r
296     @Override\r
297     public void enterType_stmt(YangParser.Type_stmtContext ctx) {\r
298         String typeName = stringFromNode(ctx);\r
299         QName typeQName = parseQName(typeName);\r
300 \r
301         TypeDefinition<?> type = null;\r
302         Type_body_stmtsContext typeBody = null;\r
303         for (int i = 0; i < ctx.getChildCount(); i++) {\r
304             if (ctx.getChild(i) instanceof Type_body_stmtsContext) {\r
305                 typeBody = (Type_body_stmtsContext) ctx.getChild(i);\r
306                 break;\r
307             }\r
308         }\r
309 \r
310         // if this is base yang type...\r
311         if(YangTypesConverter.isBaseYangType(typeName)) {\r
312             if (typeBody == null) {\r
313                 // if there are no constraints, just grab default base yang type\r
314                 type = YangTypesConverter.javaTypeForBaseYangType(typeName);\r
315                 moduleBuilder.setType(type, actualPath);\r
316             } else {\r
317                 if(typeName.equals("union")) {\r
318                     moduleBuilder.addUnionType(actualPath);\r
319                 } else {\r
320                     type = parseTypeBody(typeName, typeBody, actualPath, namespace, revision, yangModelPrefix);\r
321                     moduleBuilder.setType(type, actualPath);\r
322                 }\r
323             }\r
324         } else {\r
325             type = parseUnknownTypeBody(typeQName, typeBody);\r
326             // mark parent node of this type statement as dirty\r
327             moduleBuilder.addDirtyNode(actualPath);\r
328             moduleBuilder.setType(type, actualPath);\r
329         }\r
330 \r
331         updatePath(typeName);\r
332     }\r
333 \r
334     private QName parseQName(String typeName) {\r
335         QName typeQName;\r
336         if (typeName.contains(":")) {\r
337             String[] splittedName = typeName.split(":");\r
338             String prefix = splittedName[0];\r
339             String name = splittedName[1];\r
340             if (prefix.equals(yangModelPrefix)) {\r
341                 typeQName = new QName(namespace, revision, prefix, name);\r
342             } else {\r
343                 typeQName = new QName(null, null, prefix, name);\r
344             }\r
345         } else {\r
346             typeQName = new QName(namespace, revision, yangModelPrefix,\r
347                     typeName);\r
348         }\r
349         return typeQName;\r
350     }\r
351 \r
352     @Override\r
353     public void exitType_stmt(YangParser.Type_stmtContext ctx) {\r
354         final String actContainer = actualPath.pop();\r
355         logger.debug("exiting " + actContainer);\r
356     }\r
357 \r
358     @Override\r
359     public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {\r
360         final String groupName = stringFromNode(ctx);\r
361         QName groupQName = new QName(namespace, revision, yangModelPrefix,\r
362                 groupName);\r
363         GroupingBuilder groupBuilder = moduleBuilder.addGrouping(groupQName,\r
364                 actualPath);\r
365         updatePath("grouping");\r
366         updatePath(groupName);\r
367         parseSchemaNodeArgs(ctx, groupBuilder);\r
368     }\r
369 \r
370     @Override\r
371     public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {\r
372         String actContainer = actualPath.pop();\r
373         actContainer += "-" + actualPath.pop();\r
374         logger.debug("exiting " + actContainer);\r
375     }\r
376 \r
377     @Override\r
378     public void enterContainer_stmt(Container_stmtContext ctx) {\r
379         super.enterContainer_stmt(ctx);\r
380         String containerName = stringFromNode(ctx);\r
381         QName containerQName = new QName(namespace, revision, yangModelPrefix,\r
382                 containerName);\r
383         ContainerSchemaNodeBuilder containerBuilder = moduleBuilder\r
384                 .addContainerNode(containerQName, actualPath);\r
385         updatePath(containerName);\r
386 \r
387         containerBuilder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));\r
388         parseSchemaNodeArgs(ctx, containerBuilder);\r
389         parseConstraints(ctx, containerBuilder.getConstraintsBuilder());\r
390 \r
391         for (int i = 0; i < ctx.getChildCount(); ++i) {\r
392             final ParseTree childNode = ctx.getChild(i);\r
393             if (childNode instanceof Presence_stmtContext) {\r
394                 containerBuilder.setPresenceContainer(true);\r
395                 break;\r
396             }\r
397         }\r
398     }\r
399 \r
400     @Override\r
401     public void exitContainer_stmt(Container_stmtContext ctx) {\r
402         super.exitContainer_stmt(ctx);\r
403         final String actContainer = actualPath.pop();\r
404         logger.debug("exiting " + actContainer);\r
405     }\r
406 \r
407     @Override\r
408     public void enterLeaf_stmt(Leaf_stmtContext ctx) {\r
409         super.enterLeaf_stmt(ctx);\r
410 \r
411         final String leafName = stringFromNode(ctx);\r
412         QName leafQName = new QName(namespace, revision, yangModelPrefix,\r
413                 leafName);\r
414         LeafSchemaNodeBuilder leafBuilder = moduleBuilder.addLeafNode(\r
415                 leafQName, actualPath);\r
416         updatePath(leafName);\r
417 \r
418         leafBuilder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));\r
419         parseSchemaNodeArgs(ctx, leafBuilder);\r
420         parseConstraints(ctx, leafBuilder.getConstraintsBuilder());\r
421     }\r
422 \r
423     @Override\r
424     public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {\r
425         final String actLeaf = actualPath.pop();\r
426         logger.debug("exiting " + actLeaf);\r
427     }\r
428 \r
429     @Override\r
430     public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {\r
431         final String groupingPathStr = stringFromNode(ctx);\r
432         moduleBuilder.addUsesNode(groupingPathStr, actualPath);\r
433         updatePath(groupingPathStr);\r
434     }\r
435 \r
436     @Override\r
437     public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {\r
438         final String actContainer = actualPath.pop();\r
439         logger.debug("exiting " + actContainer);\r
440     }\r
441 \r
442     @Override\r
443     public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {\r
444         super.enterLeaf_list_stmt(ctx);\r
445 \r
446         final String leafListName = stringFromNode(ctx);\r
447         QName leafListQName = new QName(namespace, revision, yangModelPrefix,\r
448                 leafListName);\r
449         LeafListSchemaNodeBuilder leafListBuilder = moduleBuilder\r
450                 .addLeafListNode(leafListQName, actualPath);\r
451         updatePath(leafListName);\r
452 \r
453         parseSchemaNodeArgs(ctx, leafListBuilder);\r
454         parseConstraints(ctx, leafListBuilder.getConstraintsBuilder());\r
455 \r
456         for (int i = 0; i < ctx.getChildCount(); ++i) {\r
457             final ParseTree childNode = ctx.getChild(i);\r
458             if (childNode instanceof Ordered_by_stmtContext) {\r
459                 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;\r
460                 final boolean userOrdered = parseUserOrdered(orderedBy);\r
461                 leafListBuilder.setUserOrdered(userOrdered);\r
462                 break;\r
463             }\r
464         }\r
465     }\r
466 \r
467     @Override\r
468     public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {\r
469         final String actContainer = actualPath.pop();\r
470         logger.debug("exiting " + actContainer);\r
471     }\r
472 \r
473     @Override\r
474     public void enterList_stmt(List_stmtContext ctx) {\r
475         super.enterList_stmt(ctx);\r
476 \r
477         final String containerName = stringFromNode(ctx);\r
478         QName containerQName = new QName(namespace, revision, yangModelPrefix,\r
479                 containerName);\r
480         ListSchemaNodeBuilder listBuilder = moduleBuilder.addListNode(\r
481                 containerQName, actualPath);\r
482         updatePath(containerName);\r
483 \r
484         listBuilder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));\r
485         parseSchemaNodeArgs(ctx, listBuilder);\r
486         parseConstraints(ctx, listBuilder.getConstraintsBuilder());\r
487 \r
488         String keyDefinition = "";\r
489         for (int i = 0; i < ctx.getChildCount(); ++i) {\r
490             ParseTree childNode = ctx.getChild(i);\r
491             if (childNode instanceof Ordered_by_stmtContext) {\r
492                 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;\r
493                 final boolean userOrdered = parseUserOrdered(orderedBy);\r
494                 listBuilder.setUserOrdered(userOrdered);\r
495             } else if (childNode instanceof Key_stmtContext) {\r
496                 keyDefinition = stringFromNode(childNode);\r
497                 List<QName> key = createListKey(keyDefinition, namespace,\r
498                         revision, yangModelPrefix);\r
499                 listBuilder.setKeyDefinition(key);\r
500             }\r
501         }\r
502     }\r
503 \r
504     @Override\r
505     public void exitList_stmt(List_stmtContext ctx) {\r
506         final String actContainer = actualPath.pop();\r
507         logger.debug("exiting " + actContainer);\r
508     }\r
509 \r
510     @Override\r
511     public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {\r
512         final String notificationName = stringFromNode(ctx);\r
513         QName notificationQName = new QName(namespace, revision,\r
514                 yangModelPrefix, notificationName);\r
515         NotificationBuilder notificationBuilder = moduleBuilder\r
516                 .addNotification(notificationQName, actualPath);\r
517         updatePath(notificationName);\r
518 \r
519         notificationBuilder.setPath(createActualSchemaPath(actualPath, namespace,\r
520                 revision, yangModelPrefix));\r
521         parseSchemaNodeArgs(ctx, notificationBuilder);\r
522     }\r
523 \r
524     @Override\r
525     public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {\r
526         final String actContainer = actualPath.pop();\r
527         logger.debug("exiting " + actContainer);\r
528     }\r
529 \r
530     // Unknown types\r
531     @Override\r
532     public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {\r
533         String name = stringFromNode(ctx);\r
534 \r
535         QName qname;\r
536         if(name != null) {\r
537             String[] splittedName = name.split(":");\r
538             if(splittedName.length == 2) {\r
539                 qname = new QName(null, null, splittedName[0], splittedName[1]);\r
540             } else {\r
541                 qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]);\r
542             }\r
543         } else {\r
544             qname = new QName(namespace, revision, yangModelPrefix, name);\r
545         }\r
546 \r
547         UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(qname, getActualPath());\r
548         updatePath(name);\r
549 \r
550         builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));\r
551         parseSchemaNodeArgs(ctx, builder);\r
552     }\r
553 \r
554     @Override\r
555     public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {\r
556         final String actContainer = actualPath.pop();\r
557         logger.debug("exiting " + actContainer);\r
558     }\r
559 \r
560     @Override\r
561     public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {\r
562         final String rpcName = stringFromNode(ctx);\r
563         QName rpcQName = new QName(namespace, revision, yangModelPrefix,\r
564                 rpcName);\r
565         RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(rpcQName,\r
566                 actualPath);\r
567         updatePath(rpcName);\r
568 \r
569         rpcBuilder.setPath(createActualSchemaPath(actualPath, namespace, revision,\r
570                 yangModelPrefix));\r
571         parseSchemaNodeArgs(ctx, rpcBuilder);\r
572     }\r
573 \r
574     @Override\r
575     public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {\r
576         final String actContainer = actualPath.pop();\r
577         logger.debug("exiting " + actContainer);\r
578     }\r
579 \r
580     @Override\r
581     public void enterInput_stmt(YangParser.Input_stmtContext ctx) {\r
582         updatePath("input");\r
583     }\r
584 \r
585     @Override\r
586     public void exitInput_stmt(YangParser.Input_stmtContext ctx) {\r
587         final String actContainer = actualPath.pop();\r
588         logger.debug("exiting " + actContainer);\r
589     }\r
590 \r
591     @Override\r
592     public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {\r
593         updatePath("output");\r
594     }\r
595 \r
596     @Override\r
597     public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {\r
598         final String actContainer = actualPath.pop();\r
599         logger.debug("exiting " + actContainer);\r
600     }\r
601 \r
602     @Override\r
603     public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {\r
604         final String featureName = stringFromNode(ctx);\r
605         QName featureQName = new QName(namespace, revision, yangModelPrefix,\r
606                 featureName);\r
607         FeatureBuilder featureBuilder = moduleBuilder.addFeature(featureQName,\r
608                 actualPath);\r
609         updatePath(featureName);\r
610 \r
611         featureBuilder.setPath(createActualSchemaPath(actualPath, namespace,\r
612                 revision, yangModelPrefix));\r
613         parseSchemaNodeArgs(ctx, featureBuilder);\r
614     }\r
615 \r
616     @Override\r
617     public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {\r
618         final String actContainer = actualPath.pop();\r
619         logger.debug("exiting " + actContainer);\r
620     }\r
621 \r
622     @Override\r
623     public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {\r
624         final String targetPath = stringFromNode(ctx);\r
625         String reference = null;\r
626         String deviate = null;\r
627         DeviationBuilder builder = moduleBuilder.addDeviation(targetPath);\r
628         updatePath(targetPath);\r
629 \r
630         for (int i = 0; i < ctx.getChildCount(); i++) {\r
631             ParseTree child = ctx.getChild(i);\r
632             if (child instanceof Reference_stmtContext) {\r
633                 reference = stringFromNode(child);\r
634             } else if (child instanceof Deviate_not_supported_stmtContext) {\r
635                 deviate = stringFromNode(child);\r
636             } else if (child instanceof Deviate_add_stmtContext) {\r
637                 deviate = stringFromNode(child);\r
638             } else if (child instanceof Deviate_replace_stmtContext) {\r
639                 deviate = stringFromNode(child);\r
640             } else if (child instanceof Deviate_delete_stmtContext) {\r
641                 deviate = stringFromNode(child);\r
642             }\r
643         }\r
644         builder.setReference(reference);\r
645         builder.setDeviate(deviate);\r
646     }\r
647 \r
648     @Override\r
649     public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {\r
650         final String actContainer = actualPath.pop();\r
651         logger.debug("exiting " + actContainer);\r
652     }\r
653 \r
654     @Override\r
655     public void enterConfig_stmt(YangParser.Config_stmtContext ctx) {\r
656         boolean configuration = parseConfig(ctx);\r
657         moduleBuilder.addConfiguration(configuration, actualPath);\r
658     }\r
659 \r
660     @Override\r
661     public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {\r
662         final String identityName = stringFromNode(ctx);\r
663         final QName identityQName = new QName(namespace, revision,\r
664                 yangModelPrefix, identityName);\r
665         IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName);\r
666         updatePath(identityName);\r
667 \r
668         builder.setPath(createActualSchemaPath(actualPath, namespace,\r
669                 revision, yangModelPrefix));\r
670         parseSchemaNodeArgs(ctx, builder);\r
671 \r
672         for(int i = 0; i < ctx.getChildCount(); i++) {\r
673             ParseTree child = ctx.getChild(i);\r
674             if(child instanceof Base_stmtContext) {\r
675                 String baseIdentityName = stringFromNode(child);\r
676                 builder.setBaseIdentityName(baseIdentityName);\r
677             }\r
678         }\r
679     }\r
680 \r
681     @Override\r
682     public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {\r
683         final String actContainer = actualPath.pop();\r
684         logger.debug("exiting " + actContainer);\r
685     }\r
686 \r
687     public ModuleBuilder getModuleBuilder() {\r
688         return moduleBuilder;\r
689     }\r
690 \r
691     private void updatePath(String containerName) {\r
692         actualPath.push(containerName);\r
693     }\r
694 \r
695     private List<String> getActualPath() {\r
696         return Collections.unmodifiableList(actualPath);\r
697     }\r
698
699 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.