2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
\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
8 package org.opendaylight.controller.model.parser.impl;
\r
10 import static org.opendaylight.controller.model.parser.util.YangModelBuilderHelper.*;
\r
12 import java.net.URI;
\r
13 import java.net.URISyntaxException;
\r
14 import java.text.DateFormat;
\r
15 import java.text.ParseException;
\r
16 import java.text.SimpleDateFormat;
\r
17 import java.util.Date;
\r
18 import java.util.List;
\r
19 import java.util.Stack;
\r
21 import org.antlr.v4.runtime.tree.ParseTree;
\r
22 import org.opendaylight.controller.antlrv4.code.gen.YangParser;
\r
23 import org.opendaylight.controller.antlrv4.code.gen.YangParserBaseListener;
\r
24 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Config_argContext;
\r
25 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Config_stmtContext;
\r
26 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Container_stmtContext;
\r
27 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Description_stmtContext;
\r
28 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_add_stmtContext;
\r
29 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_delete_stmtContext;
\r
30 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_not_supported_stmtContext;
\r
31 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_replace_stmtContext;
\r
32 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Import_stmtContext;
\r
33 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Key_stmtContext;
\r
34 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_list_stmtContext;
\r
35 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_stmtContext;
\r
36 import org.opendaylight.controller.antlrv4.code.gen.YangParser.List_stmtContext;
\r
37 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Module_header_stmtsContext;
\r
38 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Namespace_stmtContext;
\r
39 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Ordered_by_argContext;
\r
40 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Ordered_by_stmtContext;
\r
41 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Prefix_stmtContext;
\r
42 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Presence_stmtContext;
\r
43 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Reference_stmtContext;
\r
44 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_date_stmtContext;
\r
45 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtContext;
\r
46 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtsContext;
\r
47 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Status_stmtContext;
\r
48 import org.opendaylight.controller.antlrv4.code.gen.YangParser.StringContext;
\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.model.api.type.EnumTypeDefinition;
\r
52 import org.opendaylight.controller.model.api.type.LengthConstraint;
\r
53 import org.opendaylight.controller.model.api.type.PatternConstraint;
\r
54 import org.opendaylight.controller.model.api.type.RangeConstraint;
\r
55 import org.opendaylight.controller.model.parser.api.AugmentationSchemaBuilder;
\r
56 import org.opendaylight.controller.model.parser.api.GroupingBuilder;
\r
57 import org.opendaylight.controller.model.parser.builder.ContainerSchemaNodeBuilder;
\r
58 import org.opendaylight.controller.model.parser.builder.DeviationBuilder;
\r
59 import org.opendaylight.controller.model.parser.builder.FeatureBuilder;
\r
60 import org.opendaylight.controller.model.parser.builder.LeafListSchemaNodeBuilder;
\r
61 import org.opendaylight.controller.model.parser.builder.LeafSchemaNodeBuilder;
\r
62 import org.opendaylight.controller.model.parser.builder.ListSchemaNodeBuilder;
\r
63 import org.opendaylight.controller.model.parser.builder.ModuleBuilder;
\r
64 import org.opendaylight.controller.model.parser.builder.MustDefinitionBuilder;
\r
65 import org.opendaylight.controller.model.parser.builder.NotificationBuilder;
\r
66 import org.opendaylight.controller.model.parser.builder.RpcDefinitionBuilder;
\r
67 import org.opendaylight.controller.model.parser.builder.TypedefBuilder;
\r
68 import org.opendaylight.controller.model.parser.util.YangModelBuilderHelper;
\r
69 import org.opendaylight.controller.model.util.BitsType;
\r
70 import org.opendaylight.controller.model.util.EnumerationType;
\r
71 import org.opendaylight.controller.model.util.Leafref;
\r
72 import org.opendaylight.controller.model.util.StringType;
\r
73 import org.opendaylight.controller.model.util.YangTypesConverter;
\r
74 import org.opendaylight.controller.yang.common.QName;
\r
75 import org.opendaylight.controller.yang.model.api.RevisionAwareXPath;
\r
76 import org.opendaylight.controller.yang.model.api.Status;
\r
77 import org.opendaylight.controller.yang.model.api.TypeDefinition;
\r
78 import org.slf4j.Logger;
\r
79 import org.slf4j.LoggerFactory;
\r
81 public class YangModelParserImpl extends YangParserBaseListener {
\r
83 private static final Logger logger = LoggerFactory
\r
84 .getLogger(YangModelParserImpl.class);
\r
86 private ModuleBuilder moduleBuilder;
\r
88 private String moduleName;
\r
89 private URI namespace;
\r
90 private String yangModelPrefix;
\r
91 private Date revision;
\r
93 private final DateFormat simpleDateFormat = new SimpleDateFormat(
\r
95 private final Stack<String> actualPath = new Stack<String>();
\r
98 public void enterModule_stmt(YangParser.Module_stmtContext ctx) {
\r
99 moduleName = stringFromNode(ctx);
\r
100 actualPath.push(moduleName);
\r
101 moduleBuilder = new ModuleBuilder(moduleName);
\r
105 public void exitModule_stmt(YangParser.Module_stmtContext ctx) {
\r
106 final String moduleName = actualPath.pop();
\r
107 logger.debug("Exiting module " + moduleName);
\r
111 public void enterModule_header_stmts(final Module_header_stmtsContext ctx) {
\r
112 super.enterModule_header_stmts(ctx);
\r
114 for (int i = 0; i < ctx.getChildCount(); ++i) {
\r
115 final ParseTree treeNode = ctx.getChild(i);
\r
116 if (treeNode instanceof Namespace_stmtContext) {
\r
117 String namespaceStr = stringFromNode(treeNode);
\r
119 this.namespace = new URI(namespaceStr);
\r
120 moduleBuilder.setNamespace(namespace);
\r
121 } catch (URISyntaxException e) {
\r
122 logger.warn("Failed to parse module namespace", e);
\r
124 } else if (treeNode instanceof Prefix_stmtContext) {
\r
125 yangModelPrefix = stringFromNode(treeNode);
\r
126 moduleBuilder.setPrefix(yangModelPrefix);
\r
127 } else if (treeNode instanceof Yang_version_stmtContext) {
\r
128 final String yangVersion = stringFromNode(treeNode);
\r
129 moduleBuilder.setYangVersion(yangVersion);
\r
134 // TODO: resolve submodule parsing
\r
136 public void enterSubmodule_header_stmts(
\r
137 YangParser.Submodule_header_stmtsContext ctx) {
\r
138 String submoduleName = stringFromNode(ctx);
\r
139 QName submoduleQName = new QName(namespace, revision, yangModelPrefix,
\r
141 moduleBuilder.addSubmodule(submoduleQName);
\r
142 updatePath(submoduleName);
\r
146 public void exitSubmodule_header_stmts(
\r
147 YangParser.Submodule_header_stmtsContext ctx) {
\r
148 final String submodule = actualPath.pop();
\r
149 logger.debug("exiting submodule " + submodule);
\r
153 public void enterOrganization_stmt(YangParser.Organization_stmtContext ctx) {
\r
154 final String organization = stringFromNode(ctx);
\r
155 moduleBuilder.setOrganization(organization);
\r
159 public void enterContact_stmt(YangParser.Contact_stmtContext ctx) {
\r
160 String contact = stringFromNode(ctx);
\r
161 moduleBuilder.setContact(contact);
\r
165 public void enterRevision_stmts(Revision_stmtsContext ctx) {
\r
166 for (int i = 0; i < ctx.getChildCount(); ++i) {
\r
167 final ParseTree treeNode = ctx.getChild(i);
\r
168 if (treeNode instanceof Revision_stmtContext) {
\r
169 final String revisionDateStr = stringFromNode(treeNode);
\r
171 revision = simpleDateFormat.parse(revisionDateStr);
\r
172 } catch (ParseException e) {
\r
173 logger.warn("Failed to parse revision string: "
\r
174 + revisionDateStr);
\r
181 public void enterDescription_stmt(YangParser.Description_stmtContext ctx) {
\r
182 // if this is module description...
\r
183 if (actualPath.size() == 1) {
\r
184 moduleBuilder.setDescription(stringFromNode(ctx));
\r
189 public void enterImport_stmt(Import_stmtContext ctx) {
\r
190 super.enterImport_stmt(ctx);
\r
192 final String importName = stringFromNode(ctx);
\r
193 String importPrefix = null;
\r
194 Date importRevision = null;
\r
196 for (int i = 0; i < ctx.getChildCount(); ++i) {
\r
197 final ParseTree treeNode = ctx.getChild(i);
\r
198 if (treeNode instanceof Prefix_stmtContext) {
\r
199 importPrefix = stringFromNode(treeNode);
\r
201 if (treeNode instanceof Revision_date_stmtContext) {
\r
202 String importRevisionStr = stringFromNode(treeNode);
\r
204 importRevision = simpleDateFormat.parse(importRevisionStr);
\r
205 } catch (Exception e) {
\r
206 logger.warn("Failed to parse import revision-date.", e);
\r
210 moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
\r
214 public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
\r
215 final String augmentPath = stringFromNode(ctx);
\r
216 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(
\r
217 augmentPath, actualPath);
\r
218 updatePath(augmentPath);
\r
220 for (int i = 0; i < ctx.getChildCount(); i++) {
\r
221 ParseTree child = ctx.getChild(i);
\r
222 if (child instanceof Description_stmtContext) {
\r
223 String desc = stringFromNode(child);
\r
224 builder.setDescription(desc);
\r
225 } else if (child instanceof Reference_stmtContext) {
\r
226 String ref = stringFromNode(child);
\r
227 builder.setReference(ref);
\r
228 } else if (child instanceof Status_stmtContext) {
\r
229 Status status = getStatus((Status_stmtContext) child);
\r
230 builder.setStatus(status);
\r
236 public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {
\r
237 final String augment = actualPath.pop();
\r
238 logger.debug("exiting augment " + augment);
\r
242 public void enterMust_stmt(YangParser.Must_stmtContext ctx) {
\r
243 String mustText = "";
\r
244 String description = null;
\r
245 String reference = null;
\r
246 for (int i = 0; i < ctx.getChildCount(); ++i) {
\r
247 ParseTree child = ctx.getChild(i);
\r
248 if (child instanceof StringContext) {
\r
249 final StringContext context = (StringContext) child;
\r
250 for (int j = 0; j < context.getChildCount(); j++) {
\r
251 String mustPart = context.getChild(j).getText();
\r
253 mustText += mustPart
\r
254 .substring(0, mustPart.length() - 1);
\r
258 mustText += mustPart.substring(1);
\r
261 } else if (child instanceof Description_stmtContext) {
\r
262 description = stringFromNode(child);
\r
263 } else if (child instanceof Reference_stmtContext) {
\r
264 reference = stringFromNode(child);
\r
267 MustDefinitionBuilder builder = moduleBuilder.addMustDefinition(
\r
268 mustText, actualPath);
\r
269 builder.setDescription(description);
\r
270 builder.setReference(reference);
\r
274 public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
\r
275 String typedefName = stringFromNode(ctx);
\r
276 QName typedefQName = new QName(namespace, revision, yangModelPrefix,
\r
278 TypedefBuilder builder = moduleBuilder.addTypedef(typedefQName,
\r
280 updatePath(typedefName);
\r
282 builder.setPath(getActualSchemaPath(actualPath, namespace, revision,
\r
284 parseSchemaNodeArgs(ctx, builder);
\r
288 public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
\r
289 final String actContainer = actualPath.pop();
\r
290 logger.debug("exiting " + actContainer);
\r
294 public void enterType_stmt(YangParser.Type_stmtContext ctx) {
\r
295 String typeName = stringFromNode(ctx);
\r
297 if (typeName.contains(":")) {
\r
298 String[] splittedName = typeName.split(":");
\r
299 // if this type contains prefix, it means that it point to type in
\r
301 typeQName = new QName(null, null, splittedName[0], splittedName[1]);
\r
303 typeQName = new QName(namespace, revision, yangModelPrefix,
\r
307 TypeDefinition<?> type = null;
\r
309 if (!YangTypesConverter.isBaseYangType(typeName)) {
\r
310 if (typeName.equals("leafref")) {
\r
311 // TODO: RevisionAwareXPath implementation
\r
312 type = new Leafref(new RevisionAwareXPath() {
\r
315 type = parseUnknownType(typeQName, ctx);
\r
316 // mark parent node of this type statement as dirty
\r
317 moduleBuilder.addDirtyNode(actualPath);
\r
321 Type_body_stmtsContext typeBody = null;
\r
322 for (int i = 0; i < ctx.getChildCount(); i++) {
\r
323 if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
\r
324 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
\r
329 if (typeBody == null) {
\r
330 // if there are no constraints, just grab default base yang type
\r
331 type = YangTypesConverter.javaTypeForBaseYangType(typeName);
\r
333 List<RangeConstraint> rangeStatements = getRangeConstraints(typeBody);
\r
334 Integer fractionDigits = getFractionDigits(typeBody);
\r
335 List<LengthConstraint> lengthStatements = getLengthConstraints(typeBody);
\r
336 List<PatternConstraint> patternStatements = getPatternConstraint(typeBody);
\r
337 List<EnumTypeDefinition.EnumPair> enumConstants = YangModelBuilderHelper
\r
338 .getEnumConstants(typeBody);
\r
340 if (typeName.equals("decimal64")) {
\r
341 type = YangTypesConverter.javaTypeForBaseYangDecimal64Type(
\r
342 rangeStatements, fractionDigits);
\r
343 } else if (typeName.startsWith("int")
\r
344 || typeName.startsWith("uint")) {
\r
345 type = YangTypesConverter.javaTypeForBaseYangIntegerType(
\r
346 typeName, rangeStatements);
\r
347 } else if (typeName.equals("enumeration")) {
\r
348 type = new EnumerationType(enumConstants);
\r
349 } else if (typeName.equals("string")) {
\r
350 type = new StringType(lengthStatements, patternStatements);
\r
351 } else if (typeName.equals("bits")) {
\r
352 type = new BitsType(getBits(typeBody, actualPath,
\r
353 namespace, revision, yangModelPrefix));
\r
355 // TODO: implement binary + instance-identifier types
\r
361 moduleBuilder.setType(type, actualPath);
\r
362 updatePath(typeName);
\r
366 public void exitType_stmt(YangParser.Type_stmtContext ctx) {
\r
367 final String actContainer = actualPath.pop();
\r
368 logger.debug("exiting " + actContainer);
\r
372 public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
\r
373 final String groupName = stringFromNode(ctx);
\r
374 QName groupQName = new QName(namespace, revision, yangModelPrefix,
\r
376 GroupingBuilder groupBuilder = moduleBuilder.addGrouping(groupQName,
\r
378 updatePath("grouping");
\r
379 updatePath(groupName);
\r
380 parseSchemaNodeArgs(ctx, groupBuilder);
\r
384 public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
\r
385 String actContainer = actualPath.pop();
\r
386 actContainer += "-" + actualPath.pop();
\r
387 logger.debug("exiting " + actContainer);
\r
391 public void enterContainer_stmt(Container_stmtContext ctx) {
\r
392 super.enterContainer_stmt(ctx);
\r
393 String containerName = stringFromNode(ctx);
\r
394 QName containerQName = new QName(namespace, revision, yangModelPrefix,
\r
396 ContainerSchemaNodeBuilder containerBuilder = moduleBuilder
\r
397 .addContainerNode(containerQName, actualPath);
\r
398 updatePath(containerName);
\r
400 containerBuilder.setPath(getActualSchemaPath(actualPath, namespace,
\r
401 revision, yangModelPrefix));
\r
402 parseSchemaNodeArgs(ctx, containerBuilder);
\r
404 for (int i = 0; i < ctx.getChildCount(); ++i) {
\r
405 final ParseTree childNode = ctx.getChild(i);
\r
406 if (childNode instanceof Presence_stmtContext) {
\r
407 containerBuilder.setPresenceContainer(true);
\r
408 } else if (childNode instanceof Config_stmtContext) {
\r
409 for (int j = 0; j < childNode.getChildCount(); j++) {
\r
410 ParseTree configArg = childNode.getChild(j);
\r
411 if (configArg instanceof Config_argContext) {
\r
412 String config = stringFromNode(configArg);
\r
413 if (config.equals("true")) {
\r
414 containerBuilder.setConfiguration(true);
\r
416 containerBuilder.setConfiguration(false);
\r
425 public void exitContainer_stmt(Container_stmtContext ctx) {
\r
426 super.exitContainer_stmt(ctx);
\r
427 final String actContainer = actualPath.pop();
\r
428 logger.debug("exiting " + actContainer);
\r
431 private boolean isLeafReadOnly(final ParseTree leaf) {
\r
432 if (leaf != null) {
\r
433 for (int i = 0; i < leaf.getChildCount(); ++i) {
\r
434 final ParseTree configContext = leaf.getChild(i);
\r
435 if (configContext instanceof Config_argContext) {
\r
436 final String value = stringFromNode(configContext);
\r
437 if (value.equals("true")) {
\r
447 public void enterLeaf_stmt(Leaf_stmtContext ctx) {
\r
448 super.enterLeaf_stmt(ctx);
\r
450 final String leafName = stringFromNode(ctx);
\r
451 QName leafQName = new QName(namespace, revision, yangModelPrefix,
\r
453 LeafSchemaNodeBuilder leafBuilder = moduleBuilder.addLeafNode(
\r
454 leafQName, actualPath);
\r
455 updatePath(leafName);
\r
457 leafBuilder.setPath(getActualSchemaPath(actualPath, namespace,
\r
458 revision, yangModelPrefix));
\r
459 parseSchemaNodeArgs(ctx, leafBuilder);
\r
461 for (int i = 0; i < ctx.getChildCount(); i++) {
\r
462 ParseTree child = ctx.getChild(i);
\r
463 if (child instanceof Config_stmtContext) {
\r
464 leafBuilder.setConfiguration(isLeafReadOnly(child));
\r
470 public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
\r
471 final String actLeaf = actualPath.pop();
\r
472 logger.debug("exiting " + actLeaf);
\r
476 public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
\r
477 final String groupingPathStr = stringFromNode(ctx);
\r
478 moduleBuilder.addUsesNode(groupingPathStr, actualPath);
\r
479 updatePath(groupingPathStr);
\r
483 public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
\r
484 final String actContainer = actualPath.pop();
\r
485 logger.debug("exiting " + actContainer);
\r
489 public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
\r
490 super.enterLeaf_list_stmt(ctx);
\r
492 final String leafListName = stringFromNode(ctx);
\r
493 QName leafListQName = new QName(namespace, revision, yangModelPrefix,
\r
495 LeafListSchemaNodeBuilder leafListBuilder = moduleBuilder
\r
496 .addLeafListNode(leafListQName, actualPath);
\r
497 updatePath(leafListName);
\r
499 parseSchemaNodeArgs(ctx, leafListBuilder);
\r
501 for (int i = 0; i < ctx.getChildCount(); ++i) {
\r
502 final ParseTree childNode = ctx.getChild(i);
\r
503 if (childNode instanceof Config_stmtContext) {
\r
504 leafListBuilder.setConfiguration(isLeafReadOnly(childNode));
\r
505 } else if (childNode instanceof Ordered_by_stmtContext) {
\r
506 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
\r
507 final boolean userOrdered = parseUserOrdered(orderedBy);
\r
508 leafListBuilder.setUserOrdered(userOrdered);
\r
514 public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
\r
515 final String actContainer = actualPath.pop();
\r
516 logger.debug("exiting " + actContainer);
\r
520 public void enterList_stmt(List_stmtContext ctx) {
\r
521 super.enterList_stmt(ctx);
\r
523 final String containerName = stringFromNode(ctx);
\r
524 QName containerQName = new QName(namespace, revision, yangModelPrefix,
\r
526 ListSchemaNodeBuilder listBuilder = moduleBuilder.addListNode(
\r
527 containerQName, actualPath);
\r
528 updatePath(containerName);
\r
530 listBuilder.setPath(getActualSchemaPath(actualPath, namespace,
\r
531 revision, yangModelPrefix));
\r
532 parseSchemaNodeArgs(ctx, listBuilder);
\r
534 String keyDefinition = "";
\r
535 for (int i = 0; i < ctx.getChildCount(); ++i) {
\r
536 ParseTree childNode = ctx.getChild(i);
\r
538 if (childNode instanceof Ordered_by_stmtContext) {
\r
539 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
\r
540 final boolean userOrdered = parseUserOrdered(orderedBy);
\r
541 listBuilder.setUserOrdered(userOrdered);
\r
542 } else if (childNode instanceof Key_stmtContext) {
\r
543 List<QName> key = createListKey(keyDefinition, namespace,
\r
544 revision, keyDefinition);
\r
545 listBuilder.setKeyDefinition(key);
\r
551 public void exitList_stmt(List_stmtContext ctx) {
\r
552 final String actContainer = actualPath.pop();
\r
553 logger.debug("exiting " + actContainer);
\r
557 public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
\r
558 final String notificationName = stringFromNode(ctx);
\r
559 QName notificationQName = new QName(namespace, revision,
\r
560 yangModelPrefix, notificationName);
\r
561 NotificationBuilder notificationBuilder = moduleBuilder
\r
562 .addNotification(notificationQName, actualPath);
\r
563 updatePath(notificationName);
\r
565 notificationBuilder.setPath(getActualSchemaPath(actualPath, namespace,
\r
566 revision, yangModelPrefix));
\r
567 parseSchemaNodeArgs(ctx, notificationBuilder);
\r
571 public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
\r
572 final String actContainer = actualPath.pop();
\r
573 logger.debug("exiting " + actContainer);
\r
577 public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
\r
578 final String rpcName = stringFromNode(ctx);
\r
579 QName rpcQName = new QName(namespace, revision, yangModelPrefix,
\r
581 RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(rpcQName,
\r
583 updatePath(rpcName);
\r
585 rpcBuilder.setPath(getActualSchemaPath(actualPath, namespace, revision,
\r
587 parseSchemaNodeArgs(ctx, rpcBuilder);
\r
591 public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
\r
592 final String actContainer = actualPath.pop();
\r
593 logger.debug("exiting " + actContainer);
\r
597 public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
\r
598 updatePath("input");
\r
602 public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
\r
603 final String actContainer = actualPath.pop();
\r
604 logger.debug("exiting " + actContainer);
\r
608 public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
\r
609 updatePath("output");
\r
613 public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
\r
614 final String actContainer = actualPath.pop();
\r
615 logger.debug("exiting " + actContainer);
\r
619 public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
\r
620 final String featureName = stringFromNode(ctx);
\r
621 QName featureQName = new QName(namespace, revision, yangModelPrefix,
\r
623 FeatureBuilder featureBuilder = moduleBuilder.addFeature(featureQName,
\r
625 updatePath(featureName);
\r
627 featureBuilder.setPath(getActualSchemaPath(actualPath, namespace,
\r
628 revision, yangModelPrefix));
\r
629 parseSchemaNodeArgs(ctx, featureBuilder);
\r
633 public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
\r
634 final String actContainer = actualPath.pop();
\r
635 logger.debug("exiting " + actContainer);
\r
639 public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
\r
640 final String targetPath = stringFromNode(ctx);
\r
641 String reference = null;
\r
642 String deviate = null;
\r
643 DeviationBuilder builder = moduleBuilder.addDeviation(targetPath);
\r
644 updatePath(targetPath);
\r
646 for (int i = 0; i < ctx.getChildCount(); i++) {
\r
647 ParseTree child = ctx.getChild(i);
\r
648 if (child instanceof Reference_stmtContext) {
\r
649 reference = stringFromNode(child);
\r
650 } else if (child instanceof Deviate_not_supported_stmtContext) {
\r
651 deviate = stringFromNode(child);
\r
652 } else if (child instanceof Deviate_add_stmtContext) {
\r
653 deviate = stringFromNode(child);
\r
654 } else if (child instanceof Deviate_replace_stmtContext) {
\r
655 deviate = stringFromNode(child);
\r
656 } else if (child instanceof Deviate_delete_stmtContext) {
\r
657 deviate = stringFromNode(child);
\r
660 builder.setReference(reference);
\r
661 builder.setDeviate(deviate);
\r
665 public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
\r
666 final String actContainer = actualPath.pop();
\r
667 logger.debug("exiting " + actContainer);
\r
670 public ModuleBuilder getModuleBuilder() {
\r
671 return moduleBuilder;
\r
674 private void updatePath(String containerName) {
\r
675 actualPath.push(containerName);
\r
679 * Parse ordered-by statement.
\r
682 * Ordered_by_stmtContext
\r
683 * @return true, if ordered-by contains value 'user' or false otherwise
\r
685 private boolean parseUserOrdered(Ordered_by_stmtContext childNode) {
\r
686 boolean result = false;
\r
687 for (int j = 0; j < childNode.getChildCount(); j++) {
\r
688 ParseTree orderArg = childNode.getChild(j);
\r
689 if (orderArg instanceof Ordered_by_argContext) {
\r
690 String orderStr = stringFromNode(orderArg);
\r
691 if (orderStr.equals("system")) {
\r
693 } else if (orderStr.equals("user")) {
\r
696 logger.warn("Invalid 'ordered-by' statement.");
\r