2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.yangtools.yang.model.export;
10 import com.google.common.annotations.Beta;
11 import com.google.common.base.Preconditions;
12 import com.google.common.base.Predicates;
13 import com.google.common.base.Strings;
14 import com.google.common.collect.Collections2;
15 import com.google.common.primitives.UnsignedInteger;
17 import java.util.Collection;
18 import java.util.Date;
19 import java.util.Iterator;
20 import java.util.List;
22 import java.util.Map.Entry;
23 import java.util.Objects;
24 import java.util.Optional;
26 import javax.annotation.Nonnull;
27 import javax.annotation.Nullable;
28 import javax.annotation.concurrent.NotThreadSafe;
29 import org.opendaylight.yangtools.yang.common.QName;
30 import org.opendaylight.yangtools.yang.common.YangVersion;
31 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
32 import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
35 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
36 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
38 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
40 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
41 import org.opendaylight.yangtools.yang.model.api.Deviation;
42 import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
43 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
44 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
45 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
46 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
47 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
48 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
49 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
50 import org.opendaylight.yangtools.yang.model.api.Module;
51 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
52 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
53 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
54 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
55 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
56 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
57 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
58 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
59 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
60 import org.opendaylight.yangtools.yang.model.api.Status;
61 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
62 import org.opendaylight.yangtools.yang.model.api.UniqueConstraint;
63 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
64 import org.opendaylight.yangtools.yang.model.api.UsesNode;
65 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
66 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
67 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
68 import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
69 import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
70 import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
71 import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
72 import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
73 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
74 import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
75 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
76 import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
77 import org.opendaylight.yangtools.yang.model.api.stmt.BodyGroup;
78 import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
79 import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
80 import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
81 import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
82 import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
83 import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionContainer;
84 import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
85 import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
86 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
87 import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
88 import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
89 import org.opendaylight.yangtools.yang.model.api.stmt.DocumentationGroup;
90 import org.opendaylight.yangtools.yang.model.api.stmt.DocumentedConstraintGroup;
91 import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
92 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
93 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
94 import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
95 import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
96 import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
97 import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
98 import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
99 import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
100 import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
101 import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
102 import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
103 import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
104 import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement;
105 import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
106 import org.opendaylight.yangtools.yang.model.api.stmt.LinkageGroup;
107 import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
108 import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
109 import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
110 import org.opendaylight.yangtools.yang.model.api.stmt.MetaGroup;
111 import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
112 import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
113 import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
114 import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
115 import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
116 import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
117 import org.opendaylight.yangtools.yang.model.api.stmt.OperationGroup;
118 import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
119 import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
120 import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
121 import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
122 import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
123 import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
124 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
125 import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
126 import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
127 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
128 import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
129 import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
130 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
131 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionGroup;
132 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
133 import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
134 import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
135 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
136 import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
137 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
138 import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
139 import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
140 import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
141 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
142 import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
143 import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
144 import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
145 import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
146 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
147 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
148 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
149 import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
150 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
151 import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
152 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
153 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
154 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
155 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
156 import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
157 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
158 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
159 import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
160 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
161 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
162 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
163 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
164 import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
165 import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
169 abstract class SchemaContextEmitter {
171 final YangModuleWriter writer;
172 final boolean emitInstantiated;
173 final boolean emitUses;
174 final Map<QName, StatementDefinition> extensions;
175 final YangVersion yangVersion;
177 SchemaContextEmitter(final YangModuleWriter writer, final Map<QName, StatementDefinition> extensions,
178 final YangVersion yangVersion) {
179 this(writer, extensions, yangVersion, false, true);
182 SchemaContextEmitter(final YangModuleWriter writer, final Map<QName, StatementDefinition> extensions,
183 final YangVersion yangVersion, final boolean emitInstantiated, final boolean emitUses) {
184 this.writer = Preconditions.checkNotNull(writer);
185 this.emitInstantiated = emitInstantiated;
186 this.emitUses = emitUses;
187 this.extensions = Preconditions.checkNotNull(extensions);
188 this.yangVersion = yangVersion;
191 static void writeToStatementWriter(final Module module, final SchemaContext ctx,
192 final StatementTextWriter statementWriter, final boolean emitInstantiated) {
193 final YangModuleWriter yangSchemaWriter = SchemaToStatementWriterAdaptor.from(statementWriter);
194 final Map<QName, StatementDefinition> extensions = ExtensionStatement.mapFrom(ctx.getExtensions());
195 if (module instanceof EffectiveStatement && !emitInstantiated) {
197 * if module is an effective statement and we don't want to export
198 * instantiated statements (e.g. statements added by uses or
199 * augment) we can get declared form i.e. ModuleStatement and then
200 * use DeclaredSchemaContextEmitter
202 new DeclaredSchemaContextEmitter(yangSchemaWriter, extensions,
203 YangVersion.parse(module.getYangVersion()).orElse(null))
204 .emitModule(((EffectiveStatement<?, ?>) module).getDeclared());
207 * if we don't have access to declared form of supplied module or we
208 * want to emit also instantiated statements (e.g. statements added
209 * by uses or augment), we use EffectiveSchemaContextEmitter.
211 new EffectiveSchemaContextEmitter(yangSchemaWriter, extensions,
212 YangVersion.parse(module.getYangVersion()).orElse(null), emitInstantiated).emitModule(module);
216 // FIXME: Probably should be moved to utils bundle.
217 static <T> boolean isPrefix(final Iterable<T> prefix, final Iterable<T> other) {
218 final Iterator<T> prefixIt = prefix.iterator();
219 final Iterator<T> otherIt = other.iterator();
220 while (prefixIt.hasNext()) {
221 if (!otherIt.hasNext()) {
224 if (!Objects.deepEquals(prefixIt.next(), otherIt.next())) {
231 static class DeclaredSchemaContextEmitter extends SchemaContextEmitter {
233 DeclaredSchemaContextEmitter(final YangModuleWriter writer, final Map<QName, StatementDefinition> extensions,
234 final YangVersion yangVersion) {
235 super(writer, extensions, yangVersion);
238 void emitModule(final DeclaredStatement<?> declaredRootStmt) {
239 if (declaredRootStmt instanceof ModuleStatement) {
240 emitModule((ModuleStatement) declaredRootStmt);
241 } else if (declaredRootStmt instanceof SubmoduleStatement) {
242 emitSubmodule((SubmoduleStatement) declaredRootStmt);
244 throw new UnsupportedOperationException(
245 String.format("Yin export: unsupported declared statement %s", declaredRootStmt));
249 private void emitModule(final ModuleStatement module) {
250 super.writer.startModuleNode(module.rawArgument());
251 emitModuleHeader(module);
252 emitLinkageNodes(module);
253 emitMetaNodes(module);
254 emitRevisionNodes(module);
255 emitBodyNodes(module);
256 emitUnknownStatementNodes(module);
257 super.writer.endNode();
260 private void emitModuleHeader(final ModuleStatement input) {
261 emitYangVersionNode(input.getYangVersion());
262 emitNamespace(input.getNamespace());
263 emitPrefixNode(input.getPrefix());
266 private void emitSubmodule(final SubmoduleStatement submodule) {
267 super.writer.startSubmoduleNode(submodule.rawArgument());
268 emitSubmoduleHeaderNodes(submodule);
269 emitLinkageNodes(submodule);
270 emitMetaNodes(submodule);
271 emitRevisionNodes(submodule);
272 emitBodyNodes(submodule);
273 emitUnknownStatementNodes(submodule);
274 super.writer.endNode();
277 private void emitSubmoduleHeaderNodes(final SubmoduleStatement input) {
278 emitYangVersionNode(input.getYangVersion());
279 emitBelongsTo(input.getBelongsTo());
282 private void emitBelongsTo(final BelongsToStatement belongsTo) {
283 super.writer.startBelongsToNode(belongsTo.rawArgument());
284 emitPrefixNode(belongsTo.getPrefix());
285 super.writer.endNode();
288 private void emitMetaNodes(final MetaGroup input) {
289 emitOrganizationNode(input.getOrganization());
290 emitContact(input.getContact());
291 emitDescriptionNode(input.getDescription());
292 emitReferenceNode(input.getReference());
295 private void emitLinkageNodes(final LinkageGroup input) {
296 for (final ImportStatement importNode : input.getImports()) {
297 emitImport(importNode);
299 for (final IncludeStatement importNode : input.getIncludes()) {
300 emitInclude(importNode);
304 private void emitRevisionNodes(final RevisionGroup input) {
305 emitRevisions(input.getRevisions());
308 private void emitBodyNodes(final BodyGroup input) {
310 for (final org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement extension : input
312 emitExtension(extension);
314 for (final FeatureStatement definition : input.getFeatures()) {
315 emitFeature(definition);
317 for (final IdentityStatement identity : input.getIdentities()) {
318 emitIdentity(identity);
320 for (final DeviationStatement deviation : input.getDeviations()) {
321 emitDeviation(deviation);
324 emitDataNodeContainer(input);
326 for (final AugmentStatement augmentation : input.getAugments()) {
327 emitAugment(augmentation);
329 for (final RpcStatement rpc : input.getRpcs()) {
333 emitNotifications(input.getNotifications());
336 private void emitDataNodeContainer(final DataDefinitionContainer input) {
337 for (final DataDefinitionStatement child : input.getDataDefinitions()) {
338 emitDataSchemaNode(child);
342 private void emitDataNodeContainer(final DataDefinitionContainer.WithReusableDefinitions input) {
343 for (final TypedefStatement typedef : input.getTypedefs()) {
344 emitTypedefNode(typedef);
346 for (final GroupingStatement grouping : input.getGroupings()) {
347 emitGrouping(grouping);
349 for (final DataDefinitionStatement child : input.getDataDefinitions()) {
350 emitDataSchemaNode(child);
354 private void emitDataSchemaNode(final DataDefinitionStatement child) {
355 if (child instanceof ContainerStatement) {
356 emitContainer((ContainerStatement) child);
357 } else if (child instanceof LeafStatement) {
358 emitLeaf((LeafStatement) child);
359 } else if (child instanceof LeafListStatement) {
360 emitLeafList((LeafListStatement) child);
361 } else if (child instanceof ListStatement) {
362 emitList((ListStatement) child);
363 } else if (child instanceof ChoiceStatement) {
364 emitChoice((ChoiceStatement) child);
365 } else if (child instanceof AnyxmlStatement) {
366 emitAnyxml((AnyxmlStatement) child);
367 } else if (child instanceof AnydataStatement) {
368 emitAnydata((AnydataStatement) child);
369 } else if (child instanceof UsesStatement) {
370 emitUsesNode((UsesStatement) child);
372 throw new UnsupportedOperationException("Not supported DataStatement type " + child.getClass());
376 private void emitYangVersionNode(@Nullable final YangVersionStatement yangVersionStatement) {
377 if (yangVersionStatement != null) {
378 super.writer.startYangVersionNode(yangVersionStatement.rawArgument());
379 super.writer.endNode();
383 private void emitImport(final ImportStatement importNode) {
384 super.writer.startImportNode(importNode.rawArgument());
385 emitDocumentedNode(importNode);
386 emitPrefixNode(importNode.getPrefix());
387 emitRevisionDateNode(importNode.getRevisionDate());
388 super.writer.endNode();
391 private void emitInclude(final IncludeStatement include) {
392 super.writer.startIncludeNode(include.rawArgument());
393 emitDocumentedNode(include);
394 emitRevisionDateNode(include.getRevisionDate());
395 super.writer.endNode();
398 private void emitNamespace(final NamespaceStatement namespaceStatement) {
399 Preconditions.checkNotNull(namespaceStatement, "Namespace must not be null");
400 super.writer.startNamespaceNode(namespaceStatement.getUri());
401 super.writer.endNode();
404 private void emitPrefixNode(final PrefixStatement prefixStatement) {
405 Preconditions.checkNotNull(prefixStatement, "Prefix must not be null");
406 super.writer.startPrefixNode(prefixStatement.rawArgument());
407 super.writer.endNode();
410 private void emitOrganizationNode(@Nullable final OrganizationStatement organizationStatement) {
411 if (organizationStatement != null) {
412 super.writer.startOrganizationNode(organizationStatement.rawArgument());
413 super.writer.endNode();
417 private void emitContact(@Nullable final ContactStatement contactStatement) {
418 if (contactStatement != null) {
419 super.writer.startContactNode(contactStatement.rawArgument());
420 super.writer.endNode();
424 private void emitDescriptionNode(@Nullable final DescriptionStatement descriptionStatement) {
425 if (descriptionStatement != null) {
426 super.writer.startDescriptionNode(descriptionStatement.rawArgument());
427 super.writer.endNode();
431 private void emitReferenceNode(@Nullable final ReferenceStatement referenceStatement) {
432 if (referenceStatement != null) {
433 super.writer.startReferenceNode(referenceStatement.rawArgument());
434 super.writer.endNode();
438 private void emitUnitsNode(@Nullable final UnitsStatement unitsStatement) {
439 if (unitsStatement != null) {
440 super.writer.startUnitsNode(unitsStatement.rawArgument());
441 super.writer.endNode();
445 private void emitRevisions(final Collection<? extends RevisionStatement> revisions) {
446 for (final RevisionStatement revisionStatement : revisions) {
447 emitRevision(revisionStatement);
451 private void emitRevision(final RevisionStatement revision) {
452 super.writer.startRevisionNode(revision.rawArgument());
453 emitDocumentedNode(revision);
454 super.writer.endNode();
457 private void emitRevisionDateNode(@Nullable final RevisionDateStatement revisionDateStatement) {
458 if (revisionDateStatement != null) {
459 super.writer.startRevisionDateNode(revisionDateStatement.rawArgument());
460 super.writer.endNode();
464 private void emitExtension(final org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement extension) {
465 super.writer.startExtensionNode(extension.rawArgument());
466 emitArgument(extension.getArgument());
467 emitDocumentedNodeWithStatus(extension);
468 emitUnknownStatementNodes(extension);
469 super.writer.endNode();
472 private void emitArgument(@Nullable final ArgumentStatement input) {
474 super.writer.startArgumentNode(input.rawArgument());
475 emitYinElement(input.getYinElement());
476 super.writer.endNode();
480 private void emitYinElement(@Nullable final YinElementStatement yinElementStatement) {
481 if (yinElementStatement != null) {
482 super.writer.startYinElementNode(yinElementStatement.rawArgument());
483 super.writer.endNode();
487 private void emitIdentity(final IdentityStatement identity) {
488 super.writer.startIdentityNode(identity.rawArgument());
489 emitBaseIdentities(identity.getBases());
490 emitStatusNode(identity.getStatus());
491 emitDescriptionNode(identity.getDescription());
492 emitReferenceNode(identity.getReference());
493 super.writer.endNode();
496 private void emitBaseIdentities(final Collection<? extends BaseStatement> collection) {
497 for (final BaseStatement baseStmt : collection) {
502 private void emitBase(final BaseStatement baseStmt) {
503 super.writer.startBaseNode(baseStmt.rawArgument());
504 super.writer.endNode();
507 private void emitFeature(final FeatureStatement feature) {
508 super.writer.startFeatureNode(feature.rawArgument());
509 emitIfFeatures(feature.getIfFeatures());
510 emitDocumentedNodeWithStatus(feature);
511 super.writer.endNode();
514 private void emitIfFeatures(final Collection<? extends IfFeatureStatement> ifFeatures) {
515 for (final IfFeatureStatement ifFeatureStatement : ifFeatures) {
516 emitIfFeature(ifFeatureStatement);
520 private void emitIfFeature(final IfFeatureStatement ifFeature) {
521 super.writer.startIfFeatureNode(ifFeature.rawArgument());
522 super.writer.endNode();
525 private void emitTypedefNode(final TypedefStatement typedef) {
526 super.writer.startTypedefNode(typedef.rawArgument());
527 emitType(typedef.getType());
528 emitUnitsNode(typedef.getUnits());
529 emitDefaultNode(typedef.getDefault());
530 emitStatusNode(typedef.getStatus());
531 emitDescriptionNode(typedef.getDescription());
532 emitReferenceNode(typedef.getReference());
533 emitUnknownStatementNodes(typedef);
534 super.writer.endNode();
537 private void emitType(final TypeStatement typeStatement) {
538 super.writer.startTypeNode(typeStatement.rawArgument());
539 for (final DeclaredStatement<?> typeSubstmt : typeStatement.declaredSubstatements()) {
540 if (typeSubstmt instanceof RangeStatement) {
541 emitRange((RangeStatement) typeSubstmt);
542 } else if (typeSubstmt instanceof LengthStatement) {
543 emitLength((LengthStatement) typeSubstmt);
544 } else if (typeSubstmt instanceof PatternStatement) {
545 emitPattern((PatternStatement) typeSubstmt);
546 } else if (typeSubstmt instanceof FractionDigitsStatement) {
547 emitFractionDigits((FractionDigitsStatement) typeSubstmt);
548 } else if (typeSubstmt instanceof EnumStatement) {
549 emitEnum((EnumStatement) typeSubstmt);
550 } else if (typeSubstmt instanceof PathStatement) {
551 emitPath((PathStatement) typeSubstmt);
552 } else if (typeSubstmt instanceof RequireInstanceStatement) {
553 emitRequireInstance((RequireInstanceStatement) typeSubstmt);
554 } else if (typeSubstmt instanceof BaseStatement) {
555 emitBase((BaseStatement) typeSubstmt);
556 } else if (typeSubstmt instanceof BitStatement) {
557 emitBit((BitStatement) typeSubstmt);
558 } else if (typeSubstmt instanceof TypeStatement) {
559 emitType((TypeStatement) typeSubstmt);
562 super.writer.endNode();
565 private void emitRange(final RangeStatement range) {
566 super.writer.startRangeNode(range.rawArgument());
567 emitDocumentedConstraint(range);
568 super.writer.endNode();
571 private void emitFractionDigits(final FractionDigitsStatement fractionDigits) {
572 super.writer.startFractionDigitsNode(fractionDigits.rawArgument());
573 super.writer.endNode();
576 private void emitLength(final LengthStatement lengthStatement) {
577 super.writer.startLengthNode(lengthStatement.rawArgument());
578 emitDocumentedConstraint(lengthStatement);
579 super.writer.endNode();
582 private void emitPattern(final PatternStatement pattern) {
583 super.writer.startPatternNode(pattern.rawArgument());
584 emitModifier(pattern.getModifierStatement());
585 emitDocumentedConstraint(pattern);
586 super.writer.endNode();
589 private void emitModifier(final ModifierStatement modifierStatement) {
590 if (modifierStatement != null) {
591 super.writer.startModifierNode(modifierStatement.rawArgument());
592 super.writer.endNode();
596 private void emitDefaultNodes(final Collection<? extends DefaultStatement> collection) {
597 for (final DefaultStatement defaultValue : collection) {
598 emitDefaultNode(defaultValue);
602 private void emitDefaultNode(@Nullable final DefaultStatement defaultStmt) {
603 if (defaultStmt != null) {
604 super.writer.startDefaultNode(defaultStmt.rawArgument());
605 super.writer.endNode();
609 private void emitEnum(final EnumStatement enumStmt) {
610 super.writer.startEnumNode(enumStmt.rawArgument());
611 emitDocumentedNodeWithStatus(enumStmt);
612 emitValueNode(enumStmt.getValue());
613 super.writer.endNode();
616 private void emitPath(final PathStatement path) {
617 super.writer.startPathNode(path.rawArgument());
618 super.writer.endNode();
621 private void emitRequireInstance(final RequireInstanceStatement require) {
622 super.writer.startRequireInstanceNode(require.rawArgument());
623 super.writer.endNode();
626 private void emitBit(final BitStatement bit) {
627 super.writer.startBitNode(bit.rawArgument());
628 emitPositionNode(bit.getPosition());
629 emitDocumentedNodeWithStatus(bit);
630 super.writer.endNode();
633 private void emitPositionNode(@Nullable final PositionStatement positionStatement) {
634 if (positionStatement != null) {
635 super.writer.startPositionNode(positionStatement.rawArgument());
636 super.writer.endNode();
640 private void emitStatusNode(@Nullable final StatusStatement statusStatement) {
641 if (statusStatement != null) {
642 super.writer.startStatusNode(statusStatement.rawArgument());
643 super.writer.endNode();
647 private void emitConfigNode(@Nullable final ConfigStatement configStatement) {
648 if (configStatement != null) {
649 super.writer.startConfigNode(configStatement.rawArgument());
650 super.writer.endNode();
654 private void emitMandatoryNode(@Nullable final MandatoryStatement mandatoryStatement) {
655 if (mandatoryStatement != null) {
656 super.writer.startMandatoryNode(mandatoryStatement.rawArgument());
657 super.writer.endNode();
661 private void emitPresenceNode(@Nullable final PresenceStatement presenceStatement) {
662 if (presenceStatement != null) {
663 super.writer.startPresenceNode(presenceStatement.rawArgument());
664 super.writer.endNode();
668 private void emitOrderedBy(@Nullable final OrderedByStatement orderedByStatement) {
669 if (orderedByStatement != null) {
670 super.writer.startOrderedByNode(orderedByStatement.rawArgument());
671 super.writer.endNode();
675 private void emitMust(@Nullable final MustStatement must) {
677 super.writer.startMustNode(must.rawArgument());
678 emitErrorMessageNode(must.getErrorMessageStatement());
679 emitErrorAppTagNode(must.getErrorAppTagStatement());
680 emitDescriptionNode(must.getDescription());
681 emitReferenceNode(must.getReference());
682 super.writer.endNode();
686 private void emitErrorMessageNode(@Nullable final ErrorMessageStatement errorMessageStatement) {
687 if (errorMessageStatement != null) {
688 super.writer.startErrorMessageNode(errorMessageStatement.rawArgument());
689 super.writer.endNode();
693 private void emitErrorAppTagNode(@Nullable final ErrorAppTagStatement errorAppTagStatement) {
694 if (errorAppTagStatement != null) {
695 super.writer.startErrorAppTagNode(errorAppTagStatement.rawArgument());
696 super.writer.endNode();
700 private void emitMinElementsNode(@Nullable final MinElementsStatement minElementsStatement) {
701 if (minElementsStatement != null) {
702 super.writer.startMinElementsNode(minElementsStatement.rawArgument());
703 super.writer.endNode();
707 private void emitMaxElementsNode(@Nullable final MaxElementsStatement maxElementsStatement) {
708 if (maxElementsStatement != null) {
709 super.writer.startMaxElementsNode(maxElementsStatement.rawArgument());
710 super.writer.endNode();
714 private void emitValueNode(@Nullable final ValueStatement valueStatement) {
715 if (valueStatement != null) {
716 super.writer.startValueNode(valueStatement.rawArgument());
717 super.writer.endNode();
721 private void emitDocumentedNodeWithStatus(final DocumentationGroup.WithStatus input) {
722 emitStatusNode(input.getStatus());
723 emitDocumentedNode(input);
726 private void emitDocumentedNode(final DocumentationGroup input) {
727 emitDescriptionNode(input.getDescription());
728 emitReferenceNode(input.getReference());
731 private void emitDocumentedConstraint(final DocumentedConstraintGroup input) {
732 emitDescriptionNode(input.getDescription());
733 emitReferenceNode(input.getReference());
734 emitErrorMessageNode(input.getErrorMessageStatement());
735 emitErrorAppTagNode(input.getErrorAppTagStatement());
738 private void emitGrouping(final GroupingStatement grouping) {
739 super.writer.startGroupingNode(grouping.rawArgument());
740 emitDocumentedNodeWithStatus(grouping);
741 emitDataNodeContainer(grouping);
742 emitUnknownStatementNodes(grouping);
743 emitNotifications(grouping.getNotifications());
744 emitActions(grouping.getActions());
745 super.writer.endNode();
749 private void emitContainer(final ContainerStatement container) {
750 super.writer.startContainerNode(container.rawArgument());
751 emitWhen(container.getWhenStatement());
752 emitMustNodes(container.getMusts());
753 emitIfFeatures(container.getIfFeatures());
754 emitPresenceNode(container.getPresence());
755 emitConfigNode(container.getConfig());
756 emitDocumentedNodeWithStatus(container);
757 emitDataNodeContainer(container);
758 emitUnknownStatementNodes(container);
759 emitNotifications(container.getNotifications());
760 emitActions(container.getActions());
761 super.writer.endNode();
765 private void emitLeaf(final LeafStatement leaf) {
766 super.writer.startLeafNode(leaf.rawArgument());
767 emitWhen(leaf.getWhenStatement());
768 emitIfFeatures(leaf.getIfFeatures());
769 emitType(leaf.getType());
770 emitUnitsNode(leaf.getUnits());
771 emitMustNodes(leaf.getMusts());
772 emitDefaultNode(leaf.getDefault());
773 emitConfigNode(leaf.getConfig());
774 emitMandatoryNode(leaf.getMandatory());
775 emitDocumentedNodeWithStatus(leaf);
776 emitUnknownStatementNodes(leaf);
777 super.writer.endNode();
780 private void emitLeafList(final LeafListStatement leafList) {
781 super.writer.startLeafListNode(leafList.rawArgument());
782 emitWhen(leafList.getWhenStatement());
783 emitIfFeatures(leafList.getIfFeatures());
784 emitType(leafList.getType());
785 emitUnitsNode(leafList.getUnits());
786 emitMustNodes(leafList.getMusts());
787 emitConfigNode(leafList.getConfig());
788 emitDefaultNodes(leafList.getDefaults());
789 emitMinElementsNode(leafList.getMinElements());
790 emitMaxElementsNode(leafList.getMaxElements());
791 emitOrderedBy(leafList.getOrderedBy());
792 emitDocumentedNodeWithStatus(leafList);
793 emitUnknownStatementNodes(leafList);
794 super.writer.endNode();
797 private void emitList(final ListStatement list) {
798 super.writer.startListNode(list.rawArgument());
799 emitWhen(list.getWhenStatement());
800 emitIfFeatures(list.getIfFeatures());
801 emitMustNodes(list.getMusts());
802 emitKey(list.getKey());
803 emitUniqueConstraints(list.getUnique());
804 emitConfigNode(list.getConfig());
805 emitMinElementsNode(list.getMinElements());
806 emitMaxElementsNode(list.getMaxElements());
807 emitOrderedBy(list.getOrderedBy());
808 emitDocumentedNodeWithStatus(list);
809 emitDataNodeContainer(list);
810 emitUnknownStatementNodes(list);
811 emitNotifications(list.getNotifications());
812 emitActions(list.getActions());
813 super.writer.endNode();
816 private void emitMustNodes(final Collection<? extends MustStatement> collection) {
817 for (final MustStatement must : collection) {
822 private void emitKey(final KeyStatement keyStatement) {
823 if (keyStatement != null) {
824 super.writer.startKeyNode(keyStatement.rawArgument());
825 super.writer.endNode();
829 private void emitUniqueConstraints(final Collection<? extends UniqueStatement> collection) {
830 for (final UniqueStatement uniqueConstraint : collection) {
831 emitUnique(uniqueConstraint);
835 private void emitUnique(final UniqueStatement uniqueConstraint) {
836 if (uniqueConstraint != null) {
837 super.writer.startUniqueNode(uniqueConstraint.rawArgument());
838 super.writer.endNode();
842 private void emitChoice(final ChoiceStatement choice) {
843 super.writer.startChoiceNode(choice.rawArgument());
844 emitWhen(choice.getWhenStatement());
845 emitIfFeatures(choice.getIfFeatures());
846 emitDefaultNode(choice.getDefault());
847 emitConfigNode(choice.getConfig());
848 emitMandatoryNode(choice.getMandatory());
849 emitDocumentedNodeWithStatus(choice);
850 emitCases(choice.getCases());
851 emitUnknownStatementNodes(choice);
852 super.writer.endNode();
855 private void emitShortCases(final Collection<? extends DeclaredStatement<?>> declaredSubstatements) {
856 for (final DeclaredStatement<?> child : declaredSubstatements) {
857 if (child instanceof ContainerStatement) {
858 emitContainer((ContainerStatement) child);
859 } else if (child instanceof LeafStatement) {
860 emitLeaf((LeafStatement) child);
861 } else if (child instanceof LeafListStatement) {
862 emitLeafList((LeafListStatement) child);
863 } else if (child instanceof ListStatement) {
864 emitList((ListStatement) child);
865 } else if (child instanceof ChoiceStatement) {
866 emitChoice((ChoiceStatement) child);
867 } else if (child instanceof AnyxmlStatement) {
868 emitAnyxml((AnyxmlStatement) child);
869 } else if (child instanceof AnydataStatement) {
870 emitAnydata((AnydataStatement) child);
875 private void emitCases(final Collection<? extends CaseStatement> cases) {
876 for (final CaseStatement caze : cases) {
877 if (isExplicitStatement(caze)) {
880 final Collection<? extends DeclaredStatement<?>> shortCaseChilds = caze.declaredSubstatements();
881 Preconditions.checkState(shortCaseChilds.size() == 1,
882 "Only one child is allowed for each short case node");
883 emitShortCases(shortCaseChilds);
888 private void emitCaseNode(final CaseStatement caze) {
889 super.writer.startCaseNode(caze.rawArgument());
890 emitWhen(caze.getWhenStatement());
891 emitIfFeatures(caze.getIfFeatures());
892 emitDocumentedNodeWithStatus(caze);
893 emitDataNodeContainer(caze);
894 emitUnknownStatementNodes(caze);
895 super.writer.endNode();
898 private void emitAnyxml(final AnyxmlStatement anyxml) {
899 super.writer.startAnyxmlNode(anyxml.rawArgument());
900 emitDocumentedNodeWithStatus(anyxml);
901 emitWhen(anyxml.getWhenStatement());
902 emitIfFeatures(anyxml.getIfFeatures());
903 emitMustNodes(anyxml.getMusts());
904 emitConfigNode(anyxml.getConfig());
905 emitMandatoryNode(anyxml.getMandatory());
906 emitDocumentedNodeWithStatus(anyxml);
907 emitUnknownStatementNodes(anyxml);
908 super.writer.endNode();
911 private void emitAnydata(final AnydataStatement anydata) {
912 super.writer.startAnydataNode(anydata.rawArgument());
913 emitWhen(anydata.getWhenStatement());
914 emitIfFeatures(anydata.getIfFeatures());
915 emitMustNodes(anydata.getMusts());
916 emitConfigNode(anydata.getConfig());
917 emitMandatoryNode(anydata.getMandatory());
918 emitDocumentedNodeWithStatus(anydata);
919 emitUnknownStatementNodes(anydata);
920 super.writer.endNode();
923 private void emitUsesNode(final UsesStatement uses) {
924 super.writer.startUsesNode(uses.rawArgument());
925 emitWhen(uses.getWhenStatement());
926 emitIfFeatures(uses.getIfFeatures());
927 emitDocumentedNodeWithStatus(uses);
928 for (final RefineStatement refine : uses.getRefines()) {
931 for (final AugmentStatement aug : uses.getAugments()) {
932 emitUsesAugmentNode(aug);
934 super.writer.endNode();
937 private void emitRefine(final RefineStatement refine) {
938 super.writer.startRefineNode(refine.rawArgument());
939 emitDocumentedNode(refine);
940 emitIfFeatures(refine.getIfFeatures());
941 emitMustNodes(refine.getMusts());
942 emitPresenceNode(refine.getPresence());
943 emitDefaultNodes(refine.getDefaults());
944 emitConfigNode(refine.getConfig());
945 emitMandatoryNode(refine.getMandatory());
946 emitMinElementsNode(refine.getMinElements());
947 emitMaxElementsNode(refine.getMaxElements());
948 super.writer.endNode();
951 private void emitUsesAugmentNode(final AugmentStatement aug) {
953 * differs only in location in schema, otherwise currently (as of
954 * RFC6020) it is same, so we could freely reuse path.
959 private void emitAugment(final AugmentStatement augmentation) {
960 super.writer.startAugmentNode(augmentation.rawArgument());
961 emitIfFeatures(augmentation.getIfFeatures());
962 emitWhen(augmentation.getWhenStatement());
963 emitDocumentedNodeWithStatus(augmentation);
964 emitDataNodeContainer(augmentation);
965 emitCases(augmentation.getCases());
966 emitUnknownStatementNodes(augmentation);
967 emitNotifications(augmentation.getNotifications());
968 emitActions(augmentation.getActions());
969 super.writer.endNode();
972 private void emitUnknownStatementNodes(final DeclaredStatement<?> decaredStmt) {
973 final Collection<? extends DeclaredStatement<?>> unknownStmts = Collections2
974 .filter(decaredStmt.declaredSubstatements(), Predicates.instanceOf(UnknownStatement.class));
975 for (final DeclaredStatement<?> unknonwnStmt : unknownStmts) {
976 emitUnknownStatementNode(unknonwnStmt);
980 private void emitUnknownStatementNode(final DeclaredStatement<?> unknonwnStmt) {
981 final StatementDefinition def = unknonwnStmt.statementDefinition();
982 if (def.getArgumentName() == null) {
983 super.writer.startUnknownNode(def);
985 super.writer.startUnknownNode(def, unknonwnStmt.rawArgument());
987 emitUnknownStatementNodes(unknonwnStmt);
988 super.writer.endNode();
991 private void emitWhen(final WhenStatement whenStatement) {
992 if (whenStatement != null) {
993 super.writer.startWhenNode(whenStatement.rawArgument());
994 emitDocumentedNode(whenStatement);
995 super.writer.endNode();
999 private void emitRpc(final RpcStatement rpc) {
1000 super.writer.startRpcNode(rpc.rawArgument());
1001 emitOperationBody(rpc);
1002 emitUnknownStatementNodes(rpc);
1003 super.writer.endNode();
1006 private void emitOperationBody(final OperationGroup operationStmt) {
1007 emitIfFeatures(operationStmt.getIfFeatures());
1008 emitStatusNode(operationStmt.getStatus());
1009 emitDescriptionNode(operationStmt.getDescription());
1010 emitReferenceNode(operationStmt.getReference());
1012 for (final TypedefStatement typedef : operationStmt.getTypedefs()) {
1013 emitTypedefNode(typedef);
1015 for (final GroupingStatement grouping : operationStmt.getGroupings()) {
1016 emitGrouping(grouping);
1018 emitInput(operationStmt.getInput());
1019 emitOutput(operationStmt.getOutput());
1022 private void emitActions(final Collection<? extends ActionStatement> collection) {
1023 for (final ActionStatement actionDefinition : collection) {
1024 emitAction(actionDefinition);
1028 private void emitAction(final ActionStatement actionDefinition) {
1029 super.writer.startActionNode(actionDefinition.rawArgument());
1030 emitOperationBody(actionDefinition);
1031 emitUnknownStatementNodes(actionDefinition);
1032 super.writer.endNode();
1035 private void emitInput(final InputStatement inputStatement) {
1036 if (isExplicitStatement(inputStatement)) {
1037 super.writer.startInputNode();
1038 emitMustNodes(inputStatement.getMusts());
1039 emitDataNodeContainer(inputStatement);
1040 emitUnknownStatementNodes(inputStatement);
1041 super.writer.endNode();
1045 private void emitOutput(final OutputStatement output) {
1046 if (isExplicitStatement(output)) {
1047 super.writer.startOutputNode();
1048 emitMustNodes(output.getMusts());
1049 emitDataNodeContainer(output);
1050 emitUnknownStatementNodes(output);
1051 super.writer.endNode();
1055 private static boolean isExplicitStatement(final DeclaredStatement<?> stmt) {
1056 return stmt != null && stmt.getStatementSource() == StatementSource.DECLARATION;
1059 private void emitNotifications(final Collection<? extends NotificationStatement> collection) {
1060 for (final NotificationStatement notification : collection) {
1061 emitNotificationNode(notification);
1065 private void emitNotificationNode(final NotificationStatement notification) {
1066 super.writer.startNotificationNode(notification.rawArgument());
1067 emitIfFeatures(notification.getIfFeatures());
1068 emitMustNodes(notification.getMusts());
1069 emitDocumentedNodeWithStatus(notification);
1070 emitDataNodeContainer(notification);
1071 emitUnknownStatementNodes(notification);
1072 super.writer.endNode();
1075 private void emitDeviation(final DeviationStatement deviation) {
1076 super.writer.startDeviationNode(deviation.rawArgument());
1077 emitDeviateStatements(deviation.getDeviateStatements());
1078 emitUnknownStatementNodes(deviation);
1079 super.writer.endNode();
1082 private void emitDeviateStatements(final Collection<? extends DeviateStatement> deviateStatements) {
1083 for (final DeviateStatement deviateStatement : deviateStatements) {
1084 emitDeviate(deviateStatement);
1088 private void emitDeviate(final DeviateStatement deviateStatement) {
1089 super.writer.startDeviateNode(deviateStatement.rawArgument());
1091 * :FIXME Currently, DeviateStatementImpl contains implementation
1092 * for all deviate types (i.e. add, replace, delete). However it
1093 * would be better to create subinterfaces of DeviateStatement for
1094 * each deviate type (i.e. AddDeviateStatement,
1095 * ReplaceDeviateStatement,..) and create argument specific supports
1096 * (i.e. definitions) for each deviate type (very similarly like by
1099 for (final DeclaredStatement<?> child : deviateStatement.declaredSubstatements()) {
1100 if (child instanceof MustStatement) {
1101 emitMust((MustStatement) child);
1102 } else if (child instanceof DefaultStatement) {
1103 emitDefaultNode((DefaultStatement) child);
1104 } else if (child instanceof UniqueStatement) {
1105 emitUnique((UniqueStatement) child);
1106 } else if (child instanceof UnitsStatement) {
1107 emitUnitsNode((UnitsStatement) child);
1108 } else if (child instanceof TypeStatement) {
1109 emitType((TypeStatement) child);
1110 } else if (child instanceof MinElementsStatement) {
1111 emitMinElementsNode((MinElementsStatement) child);
1112 } else if (child instanceof MaxElementsStatement) {
1113 emitMaxElementsNode((MaxElementsStatement) child);
1114 } else if (child instanceof MandatoryStatement) {
1115 emitMandatoryNode((MandatoryStatement) child);
1116 } else if (child instanceof ConfigStatement) {
1117 emitConfigNode((ConfigStatement) child);
1118 } else if (child instanceof UnknownStatement) {
1119 emitUnknownStatementNode((UnknownStatement<?>) child);
1122 super.writer.endNode();
1126 static class EffectiveSchemaContextEmitter extends SchemaContextEmitter {
1128 EffectiveSchemaContextEmitter(final YangModuleWriter writer, final Map<QName, StatementDefinition> extensions,
1129 final YangVersion yangVersion, final boolean emitInstantiated) {
1130 super(writer, extensions, yangVersion, emitInstantiated, true);
1133 void emitModule(final Module input) {
1134 super.writer.startModuleNode(input.getName());
1135 emitModuleHeader(input);
1136 emitLinkageNodes(input);
1137 emitMetaNodes(input);
1138 emitRevisionNodes(input);
1139 emitBodyNodes(input);
1140 super.writer.endNode();
1143 private void emitModuleHeader(final Module input) {
1144 emitYangVersionNode(input.getYangVersion());
1145 emitNamespace(input.getNamespace());
1146 emitPrefixNode(input.getPrefix());
1149 @SuppressWarnings("unused")
1150 private void emitSubmodule(final String input) {
1152 * FIXME: BUG-2444: Implement submodule export
1154 * submoduleHeaderNodes linkageNodes metaNodes revisionNodes
1155 * bodyNodes super.writer.endNode();
1159 @SuppressWarnings("unused")
1160 private void emitSubmoduleHeaderNodes(final Module input) {
1162 * FIXME: BUG-2444: Implement submodule headers properly
1164 * :yangVersionNode //Optional
1170 private void emitMetaNodes(final Module input) {
1171 emitOrganizationNode(input.getOrganization());
1172 emitContact(input.getContact());
1173 emitDescriptionNode(input.getDescription());
1174 emitReferenceNode(input.getReference());
1177 private void emitLinkageNodes(final Module input) {
1178 for (final ModuleImport importNode : input.getImports()) {
1179 emitImport(importNode);
1182 * FIXME: BUG-2444: Emit include statements
1186 private void emitRevisionNodes(final Module input) {
1188 * FIXME: BUG-2444: emit revisions properly, when parsed model will
1189 * provide enough information
1191 emitRevision(input.getRevision());
1195 private void emitBodyNodes(final Module input) {
1197 for (final ExtensionDefinition extension : input.getExtensionSchemaNodes()) {
1198 emitExtension(extension);
1200 for (final FeatureDefinition definition : input.getFeatures()) {
1201 emitFeature(definition);
1203 for (final IdentitySchemaNode identity : input.getIdentities()) {
1204 emitIdentity(identity);
1206 for (final Deviation deviation : input.getDeviations()) {
1207 emitDeviation(deviation);
1210 emitDataNodeContainer(input);
1212 for (final AugmentationSchema augmentation : input.getAugmentations()) {
1213 emitAugment(augmentation);
1215 for (final RpcDefinition rpc : input.getRpcs()) {
1219 emitNotifications(input.getNotifications());
1222 private void emitDataNodeContainer(final DataNodeContainer input) {
1223 for (final TypeDefinition<?> typedef : input.getTypeDefinitions()) {
1224 emitTypedefNode(typedef);
1226 for (final GroupingDefinition grouping : input.getGroupings()) {
1227 emitGrouping(grouping);
1229 for (final DataSchemaNode child : input.getChildNodes()) {
1230 emitDataSchemaNode(child);
1232 for (final UsesNode usesNode : input.getUses()) {
1233 emitUsesNode(usesNode);
1237 private void emitDataSchemaNode(final DataSchemaNode child) {
1238 if (!super.emitInstantiated && (child.isAddedByUses() || child.isAugmenting())) {
1239 // We skip instantiated nodes.
1243 if (child instanceof ContainerSchemaNode) {
1244 emitContainer((ContainerSchemaNode) child);
1245 } else if (child instanceof LeafSchemaNode) {
1246 emitLeaf((LeafSchemaNode) child);
1247 } else if (child instanceof LeafListSchemaNode) {
1248 emitLeafList((LeafListSchemaNode) child);
1249 } else if (child instanceof ListSchemaNode) {
1250 emitList((ListSchemaNode) child);
1251 } else if (child instanceof ChoiceSchemaNode) {
1252 emitChoice((ChoiceSchemaNode) child);
1253 } else if (child instanceof AnyXmlSchemaNode) {
1254 emitAnyxml((AnyXmlSchemaNode) child);
1255 } else if (child instanceof AnyDataSchemaNode) {
1256 emitAnydata((AnyDataSchemaNode) child);
1258 throw new UnsupportedOperationException("Not supported DataSchemaNode type " + child.getClass());
1262 private void emitYangVersionNode(final String input) {
1263 super.writer.startYangVersionNode(input);
1264 super.writer.endNode();
1267 private void emitImport(final ModuleImport importNode) {
1268 super.writer.startImportNode(importNode.getModuleName());
1269 emitDescriptionNode(importNode.getDescription());
1270 emitReferenceNode(importNode.getReference());
1271 emitPrefixNode(importNode.getPrefix());
1272 emitRevisionDateNode(importNode.getRevision());
1273 super.writer.endNode();
1276 @SuppressWarnings("unused")
1277 private void emitInclude(final String input) {
1279 * FIXME: BUG-2444: Implement proper export of include statements
1280 * startIncludeNode(IdentifierHelper.getIdentifier(String :input));
1283 * :revisionDateNode :super.writer.endNode();)
1287 private void emitNamespace(final URI uri) {
1288 super.writer.startNamespaceNode(uri);
1289 super.writer.endNode();
1293 private void emitPrefixNode(final String input) {
1294 super.writer.startPrefixNode(input);
1295 super.writer.endNode();
1299 @SuppressWarnings("unused")
1300 private void emitBelongsTo(final String input) {
1302 * FIXME: BUG-2444: Implement proper export of belongs-to statements
1303 * startIncludeNode(IdentifierHelper.getIdentifier(String :input));
1306 * :super.writer.startBelongsToNode(IdentifierHelper.getIdentifier(
1310 * :prefixNode :super.writer.endNode();
1316 private void emitOrganizationNode(final String input) {
1317 if (!Strings.isNullOrEmpty(input)) {
1318 super.writer.startOrganizationNode(input);
1319 super.writer.endNode();
1323 private void emitContact(final String input) {
1324 if (!Strings.isNullOrEmpty(input)) {
1325 super.writer.startContactNode(input);
1326 super.writer.endNode();
1330 private void emitDescriptionNode(@Nullable final String input) {
1331 if (!Strings.isNullOrEmpty(input)) {
1332 super.writer.startDescriptionNode(input);
1333 super.writer.endNode();
1337 private void emitReferenceNode(@Nullable final String input) {
1338 if (!Strings.isNullOrEmpty(input)) {
1339 super.writer.startReferenceNode(input);
1340 super.writer.endNode();
1344 private void emitUnitsNode(@Nullable final String input) {
1345 if (!Strings.isNullOrEmpty(input)) {
1346 super.writer.startUnitsNode(input);
1347 super.writer.endNode();
1351 private void emitRevision(final Date date) {
1352 super.writer.startRevisionNode(date);
1355 // FIXME: BUG-2444: FIXME: BUG-2444: BUG-2417: descriptionNode
1356 // //FIXME: BUG-2444: Optional
1357 // FIXME: BUG-2444: FIXME: BUG-2444: BUG-2417: referenceNode
1358 // //FIXME: BUG-2444: Optional
1359 super.writer.endNode();
1363 private void emitRevisionDateNode(@Nullable final Date date) {
1365 super.writer.startRevisionDateNode(date);
1366 super.writer.endNode();
1370 private void emitExtension(final ExtensionDefinition extension) {
1371 super.writer.startExtensionNode(extension.getQName());
1372 emitArgument(extension.getArgument(), extension.isYinElement());
1373 emitStatusNode(extension.getStatus());
1374 emitDescriptionNode(extension.getDescription());
1375 emitReferenceNode(extension.getReference());
1376 emitUnknownStatementNodes(extension.getUnknownSchemaNodes());
1377 super.writer.endNode();
1381 private void emitArgument(final @Nullable String input, final boolean yinElement) {
1382 if (input != null) {
1383 super.writer.startArgumentNode(input);
1384 emitYinElement(yinElement);
1385 super.writer.endNode();
1390 private void emitYinElement(final boolean yinElement) {
1391 super.writer.startYinElementNode(yinElement);
1392 super.writer.endNode();
1396 private void emitIdentity(final IdentitySchemaNode identity) {
1397 super.writer.startIdentityNode(identity.getQName());
1398 emitBaseIdentities(identity.getBaseIdentities());
1399 emitStatusNode(identity.getStatus());
1400 emitDescriptionNode(identity.getDescription());
1401 emitReferenceNode(identity.getReference());
1402 super.writer.endNode();
1405 private void emitBaseIdentities(final Set<IdentitySchemaNode> identities) {
1406 for (final IdentitySchemaNode identitySchemaNode : identities) {
1407 emitBase(identitySchemaNode.getQName());
1411 private void emitBase(final QName qName) {
1412 super.writer.startBaseNode(qName);
1413 super.writer.endNode();
1416 private void emitFeature(final FeatureDefinition definition) {
1417 super.writer.startFeatureNode(definition.getQName());
1419 // FIXME: BUG-2444: FIXME: BUG-2444: Expose ifFeature
1420 // *(ifFeatureNode )
1421 emitStatusNode(definition.getStatus());
1422 emitDescriptionNode(definition.getDescription());
1423 emitReferenceNode(definition.getReference());
1424 super.writer.endNode();
1428 @SuppressWarnings("unused")
1429 private void emitIfFeature(final String input) {
1431 * FIXME: BUG-2444: Implement proper export of include statements
1432 * startIncludeNode(IdentifierHelper.getIdentifier(String :input));
1437 private void emitTypedefNode(final TypeDefinition<?> typedef) {
1438 super.writer.startTypedefNode(typedef.getQName());
1439 // Differentiate between derived type and existing type
1441 emitTypeNodeDerived(typedef);
1442 emitUnitsNode(typedef.getUnits());
1443 emitDefaultNode(typedef.getDefaultValue());
1444 emitStatusNode(typedef.getStatus());
1445 emitDescriptionNode(typedef.getDescription());
1446 emitReferenceNode(typedef.getReference());
1447 emitUnknownStatementNodes(typedef.getUnknownSchemaNodes());
1448 super.writer.endNode();
1452 private void emitTypeNode(final SchemaPath parentPath, final TypeDefinition<?> subtype) {
1453 final SchemaPath path = subtype.getPath();
1454 if (isPrefix(parentPath.getPathFromRoot(), path.getPathFromRoot())) {
1455 emitTypeNodeDerived(subtype);
1457 emitTypeNodeReferenced(subtype);
1461 private void emitTypeNodeReferenced(final TypeDefinition<?> typeDefinition) {
1462 super.writer.startTypeNode(typeDefinition.getQName());
1463 super.writer.endNode();
1467 private void emitTypeNodeDerived(final TypeDefinition<?> typeDefinition) {
1468 final TypeDefinition<?> b = typeDefinition.getBaseType();
1469 final TypeDefinition<?> baseType = b == null ? typeDefinition : b;
1470 super.writer.startTypeNode(baseType.getQName());
1471 emitTypeBodyNodes(typeDefinition);
1472 super.writer.endNode();
1476 private void emitTypeBodyNodes(final TypeDefinition<?> typeDef) {
1477 if (typeDef instanceof UnsignedIntegerTypeDefinition) {
1478 emitUnsignedIntegerSpecification((UnsignedIntegerTypeDefinition) typeDef);
1479 } else if (typeDef instanceof IntegerTypeDefinition) {
1480 emitIntegerSpefication((IntegerTypeDefinition) typeDef);
1481 } else if (typeDef instanceof DecimalTypeDefinition) {
1482 emitDecimal64Specification((DecimalTypeDefinition) typeDef);
1483 } else if (typeDef instanceof StringTypeDefinition) {
1484 emitStringRestrictions((StringTypeDefinition) typeDef);
1485 } else if (typeDef instanceof EnumTypeDefinition) {
1486 emitEnumSpecification((EnumTypeDefinition) typeDef);
1487 } else if (typeDef instanceof LeafrefTypeDefinition) {
1488 emitLeafrefSpecification((LeafrefTypeDefinition) typeDef);
1489 } else if (typeDef instanceof IdentityrefTypeDefinition) {
1490 emitIdentityrefSpecification((IdentityrefTypeDefinition) typeDef);
1491 } else if (typeDef instanceof InstanceIdentifierTypeDefinition) {
1492 emitInstanceIdentifierSpecification((InstanceIdentifierTypeDefinition) typeDef);
1493 } else if (typeDef instanceof BitsTypeDefinition) {
1494 emitBitsSpecification((BitsTypeDefinition) typeDef);
1495 } else if (typeDef instanceof UnionTypeDefinition) {
1496 emitUnionSpecification((UnionTypeDefinition) typeDef);
1497 } else if (typeDef instanceof BinaryTypeDefinition) {
1498 emitLength(((BinaryTypeDefinition) typeDef).getLengthConstraints());
1499 } else if (typeDef instanceof BooleanTypeDefinition || typeDef instanceof EmptyTypeDefinition) {
1502 throw new IllegalArgumentException("Not supported type " + typeDef.getClass());
1506 private void emitIntegerSpefication(final IntegerTypeDefinition typeDef) {
1507 emitRangeNodeOptional(typeDef.getRangeConstraints());
1510 private void emitUnsignedIntegerSpecification(final UnsignedIntegerTypeDefinition typeDef) {
1511 emitRangeNodeOptional(typeDef.getRangeConstraints());
1515 private void emitRangeNodeOptional(final List<RangeConstraint> list) {
1516 // FIXME: BUG-2444: Wrong decomposition in API, should be
1518 // which contains ranges.
1519 if (!list.isEmpty()) {
1520 super.writer.startRangeNode(toRangeString(list));
1521 final RangeConstraint first = list.iterator().next();
1522 emitErrorMessageNode(first.getErrorMessage());
1523 emitErrorAppTagNode(first.getErrorAppTag());
1524 emitDescriptionNode(first.getDescription());
1525 emitReferenceNode(first.getReference());
1526 super.writer.endNode();
1531 private void emitDecimal64Specification(final DecimalTypeDefinition typeDefinition) {
1532 emitFranctionDigitsNode(typeDefinition.getFractionDigits());
1533 emitRangeNodeOptional(typeDefinition.getRangeConstraints());
1537 private void emitFranctionDigitsNode(final Integer fractionDigits) {
1538 super.writer.startFractionDigitsNode(fractionDigits);
1539 super.writer.endNode();
1542 private void emitStringRestrictions(final StringTypeDefinition typeDef) {
1544 // FIXME: BUG-2444: Wrong decomposition in API, should be
1546 // which contains ranges.
1547 emitLength(typeDef.getLengthConstraints());
1549 for (final PatternConstraint pattern : typeDef.getPatternConstraints()) {
1550 emitPatternNode(pattern);
1555 private void emitLength(final List<LengthConstraint> list) {
1556 if (!list.isEmpty()) {
1557 super.writer.startLengthNode(toLengthString(list));
1558 // FIXME: BUG-2444: Workaround for incorrect decomposition in
1560 final LengthConstraint first = list.iterator().next();
1561 emitErrorMessageNode(first.getErrorMessage());
1562 emitErrorAppTagNode(first.getErrorAppTag());
1563 emitDescriptionNode(first.getDescription());
1564 emitReferenceNode(first.getReference());
1565 super.writer.endNode();
1569 private static String toLengthString(final List<LengthConstraint> list) {
1570 final Iterator<LengthConstraint> it = list.iterator();
1571 if (!it.hasNext()) {
1575 final StringBuilder sb = new StringBuilder();
1578 final LengthConstraint current = it.next();
1579 haveNext = it.hasNext();
1580 appendRange(sb, current.getMin(), current.getMax(), haveNext);
1583 return sb.toString();
1586 private static String toRangeString(final List<RangeConstraint> list) {
1587 final Iterator<RangeConstraint> it = list.iterator();
1588 if (!it.hasNext()) {
1592 final StringBuilder sb = new StringBuilder();
1595 final RangeConstraint current = it.next();
1596 haveNext = it.hasNext();
1597 appendRange(sb, current.getMin(), current.getMax(), haveNext);
1600 return sb.toString();
1603 private static void appendRange(final StringBuilder sb, final Number min, final Number max,
1604 final boolean haveNext) {
1606 if (!min.equals(max)) {
1615 private void emitPatternNode(final PatternConstraint pattern) {
1616 super.writer.startPatternNode(pattern.getRawRegularExpression());
1617 // FIXME: BUG-2444: Optional
1618 emitErrorMessageNode(pattern.getErrorMessage());
1619 // FIXME: BUG-2444: Optional
1620 emitErrorAppTagNode(pattern.getErrorAppTag());
1621 emitDescriptionNode(pattern.getDescription());
1622 emitModifier(pattern.getModifier());
1623 super.writer.endNode();
1626 private void emitModifier(final ModifierKind modifier) {
1627 if (modifier != null) {
1628 super.writer.startModifierNode(modifier);
1629 super.writer.endNode();
1633 private void emitDefaultNodes(final Collection<String> defaults) {
1634 for (final String defaultValue : defaults) {
1635 emitDefaultNode(defaultValue);
1639 private void emitDefaultNode(@Nullable final Object object) {
1640 if (object != null) {
1641 super.writer.startDefaultNode(object.toString());
1642 super.writer.endNode();
1646 private void emitEnumSpecification(final EnumTypeDefinition typeDefinition) {
1647 for (final EnumPair enumValue : typeDefinition.getValues()) {
1648 emitEnumNode(enumValue);
1652 private void emitEnumNode(final EnumPair enumValue) {
1653 super.writer.startEnumNode(enumValue.getName());
1654 emitValueNode(enumValue.getValue());
1655 emitStatusNode(enumValue.getStatus());
1656 emitDescriptionNode(enumValue.getDescription());
1657 emitReferenceNode(enumValue.getReference());
1658 super.writer.endNode();
1661 private void emitLeafrefSpecification(final LeafrefTypeDefinition typeDefinition) {
1662 emitPathNode(typeDefinition.getPathStatement());
1663 if (YangVersion.VERSION_1_1 == super.yangVersion) {
1664 emitRequireInstanceNode(typeDefinition.requireInstance());
1668 private void emitPathNode(final RevisionAwareXPath revisionAwareXPath) {
1669 super.writer.startPathNode(revisionAwareXPath);
1670 super.writer.endNode();
1673 private void emitRequireInstanceNode(final boolean require) {
1674 super.writer.startRequireInstanceNode(require);
1675 super.writer.endNode();
1678 private void emitInstanceIdentifierSpecification(final InstanceIdentifierTypeDefinition typeDefinition) {
1679 emitRequireInstanceNode(typeDefinition.requireInstance());
1682 private void emitIdentityrefSpecification(final IdentityrefTypeDefinition typeDefinition) {
1683 emitBaseIdentities(typeDefinition.getIdentities());
1686 private void emitUnionSpecification(final UnionTypeDefinition typeDefinition) {
1687 for (final TypeDefinition<?> subtype : typeDefinition.getTypes()) {
1688 // FIXME: BUG-2444: What if we have locally modified types here?
1689 // is solution to look-up in schema path?
1690 emitTypeNode(typeDefinition.getPath(), subtype);
1694 private void emitBitsSpecification(final BitsTypeDefinition typeDefinition) {
1695 for (final Bit bit : typeDefinition.getBits()) {
1700 private void emitBit(final Bit bit) {
1701 super.writer.startBitNode(bit.getName());
1702 emitPositionNode(bit.getPosition());
1703 emitStatusNode(bit.getStatus());
1704 emitDescriptionNode(bit.getDescription());
1705 emitReferenceNode(bit.getReference());
1706 super.writer.endNode();
1709 private void emitPositionNode(@Nullable final Long position) {
1710 if (position != null) {
1711 super.writer.startPositionNode(UnsignedInteger.valueOf(position));
1712 super.writer.endNode();
1716 private void emitStatusNode(@Nullable final Status status) {
1717 if (status != null) {
1718 super.writer.startStatusNode(status);
1719 super.writer.endNode();
1723 private void emitConfigNode(final boolean config) {
1724 super.writer.startConfigNode(config);
1725 super.writer.endNode();
1728 private void emitMandatoryNode(final boolean mandatory) {
1729 super.writer.startMandatoryNode(mandatory);
1730 super.writer.endNode();
1733 private void emitPresenceNode(final boolean presence) {
1734 super.writer.startPresenceNode(presence);
1735 super.writer.endNode();
1738 private void emitOrderedBy(final boolean userOrdered) {
1740 super.writer.startOrderedByNode("user");
1742 super.writer.startOrderedByNode("system");
1744 super.writer.endNode();
1747 private void emitMust(@Nullable final MustDefinition mustCondition) {
1748 if (mustCondition != null && mustCondition.getXpath() != null) {
1749 super.writer.startMustNode(mustCondition.getXpath());
1750 emitErrorMessageNode(mustCondition.getErrorMessage());
1751 emitErrorAppTagNode(mustCondition.getErrorAppTag());
1752 emitDescriptionNode(mustCondition.getDescription());
1753 emitReferenceNode(mustCondition.getReference());
1754 super.writer.endNode();
1759 private void emitErrorMessageNode(@Nullable final String input) {
1760 if (input != null && !input.isEmpty()) {
1761 super.writer.startErrorMessageNode(input);
1762 super.writer.endNode();
1766 private void emitErrorAppTagNode(final String input) {
1767 if (input != null && !input.isEmpty()) {
1768 super.writer.startErrorAppTagNode(input);
1769 super.writer.endNode();
1773 private void emitMinElementsNode(final Integer min) {
1775 super.writer.startMinElementsNode(min);
1776 super.writer.endNode();
1780 private void emitMaxElementsNode(final Integer max) {
1782 super.writer.startMaxElementsNode(max);
1783 super.writer.endNode();
1787 private void emitValueNode(@Nullable final Integer value) {
1788 if (value != null) {
1789 super.writer.startValueNode(value);
1790 super.writer.endNode();
1794 private void emitDocumentedNode(final DocumentedNode.WithStatus input) {
1795 emitStatusNode(input.getStatus());
1796 emitDescriptionNode(input.getDescription());
1797 emitReferenceNode(input.getReference());
1800 private void emitGrouping(final GroupingDefinition grouping) {
1801 super.writer.startGroupingNode(grouping.getQName());
1802 emitDocumentedNode(grouping);
1803 emitDataNodeContainer(grouping);
1804 emitUnknownStatementNodes(grouping.getUnknownSchemaNodes());
1805 emitNotifications(grouping.getNotifications());
1806 emitActions(grouping.getActions());
1807 super.writer.endNode();
1811 private void emitContainer(final ContainerSchemaNode child) {
1812 super.writer.startContainerNode(child.getQName());
1816 emitConstraints(child.getConstraints());
1817 // FIXME: BUG-2444: whenNode //:Optional
1818 // FIXME: BUG-2444: *(ifFeatureNode )
1819 emitPresenceNode(child.isPresenceContainer());
1820 emitConfigNode(child.isConfiguration());
1821 emitDocumentedNode(child);
1822 emitDataNodeContainer(child);
1823 emitUnknownStatementNodes(child.getUnknownSchemaNodes());
1824 emitNotifications(child.getNotifications());
1825 emitActions(child.getActions());
1826 super.writer.endNode();
1830 private void emitConstraints(final ConstraintDefinition constraints) {
1831 emitWhen(constraints.getWhenCondition());
1832 for (final MustDefinition mustCondition : constraints.getMustConstraints()) {
1833 emitMust(mustCondition);
1837 private void emitLeaf(final LeafSchemaNode child) {
1838 super.writer.startLeafNode(child.getQName());
1839 emitWhen(child.getConstraints().getWhenCondition());
1840 // FIXME: BUG-2444: *(ifFeatureNode )
1841 emitTypeNode(child.getPath(), child.getType());
1842 emitUnitsNode(child.getUnits());
1843 emitMustNodes(child.getConstraints().getMustConstraints());
1844 emitDefaultNode(child.getDefault());
1845 emitConfigNode(child.isConfiguration());
1846 emitMandatoryNode(child.getConstraints().isMandatory());
1847 emitDocumentedNode(child);
1848 emitUnknownStatementNodes(child.getUnknownSchemaNodes());
1849 super.writer.endNode();
1853 private void emitLeafList(final LeafListSchemaNode child) {
1854 super.writer.startLeafListNode(child.getQName());
1856 emitWhen(child.getConstraints().getWhenCondition());
1857 // FIXME: BUG-2444: *(ifFeatureNode )
1858 emitTypeNode(child.getPath(), child.getType());
1859 emitUnitsNode(child.getType().getUnits());
1860 // FIXME: BUG-2444: unitsNode /Optional
1861 emitMustNodes(child.getConstraints().getMustConstraints());
1862 emitConfigNode(child.isConfiguration());
1863 emitDefaultNodes(child.getDefaults());
1864 emitMinElementsNode(child.getConstraints().getMinElements());
1865 emitMaxElementsNode(child.getConstraints().getMaxElements());
1866 emitOrderedBy(child.isUserOrdered());
1867 emitDocumentedNode(child);
1868 emitUnknownStatementNodes(child.getUnknownSchemaNodes());
1869 super.writer.endNode();
1873 private void emitList(final ListSchemaNode child) {
1874 super.writer.startListNode(child.getQName());
1875 emitWhen(child.getConstraints().getWhenCondition());
1877 // FIXME: BUG-2444: *(ifFeatureNode )
1878 emitMustNodes(child.getConstraints().getMustConstraints());
1879 emitKey(child.getKeyDefinition());
1880 emitUniqueConstraints(child.getUniqueConstraints());
1881 emitConfigNode(child.isConfiguration());
1882 emitMinElementsNode(child.getConstraints().getMinElements());
1883 emitMaxElementsNode(child.getConstraints().getMaxElements());
1884 emitOrderedBy(child.isUserOrdered());
1885 emitDocumentedNode(child);
1886 emitDataNodeContainer(child);
1887 emitUnknownStatementNodes(child.getUnknownSchemaNodes());
1888 emitNotifications(child.getNotifications());
1889 emitActions(child.getActions());
1890 super.writer.endNode();
1894 private void emitMustNodes(final Set<MustDefinition> mustConstraints) {
1895 for (final MustDefinition must : mustConstraints) {
1900 private void emitKey(final List<QName> keyList) {
1901 if (keyList != null && !keyList.isEmpty()) {
1902 super.writer.startKeyNode(keyList);
1903 super.writer.endNode();
1907 private void emitUniqueConstraints(final Collection<UniqueConstraint> uniqueConstraints) {
1908 for (final UniqueConstraint uniqueConstraint : uniqueConstraints) {
1909 emitUnique(uniqueConstraint);
1913 private void emitUnique(final UniqueConstraint uniqueConstraint) {
1914 super.writer.startUniqueNode(uniqueConstraint);
1915 super.writer.endNode();
1918 private void emitChoice(final ChoiceSchemaNode choice) {
1919 super.writer.startChoiceNode(choice.getQName());
1920 emitWhen(choice.getConstraints().getWhenCondition());
1921 // FIXME: BUG-2444: *(ifFeatureNode )
1922 // FIXME: BUG-2444: defaultNode //Optional
1923 emitConfigNode(choice.isConfiguration());
1924 emitMandatoryNode(choice.getConstraints().isMandatory());
1925 emitDocumentedNode(choice);
1926 for (final ChoiceCaseNode caze : choice.getCases()) {
1927 // TODO: emit short case?
1930 emitUnknownStatementNodes(choice.getUnknownSchemaNodes());
1931 super.writer.endNode();
1934 private void emitCaseNode(final ChoiceCaseNode caze) {
1935 if (!super.emitInstantiated && caze.isAugmenting()) {
1938 super.writer.startCaseNode(caze.getQName());
1939 emitWhen(caze.getConstraints().getWhenCondition());
1940 // FIXME: BUG-2444: *(ifFeatureNode )
1941 emitDocumentedNode(caze);
1942 emitDataNodeContainer(caze);
1943 emitUnknownStatementNodes(caze.getUnknownSchemaNodes());
1944 super.writer.endNode();
1948 private void emitAnyxml(final AnyXmlSchemaNode anyxml) {
1949 super.writer.startAnyxmlNode(anyxml.getQName());
1950 emitBodyOfDataSchemaNode(anyxml);
1951 super.writer.endNode();
1954 private void emitAnydata(final AnyDataSchemaNode anydata) {
1955 super.writer.startAnydataNode(anydata.getQName());
1956 emitBodyOfDataSchemaNode(anydata);
1957 super.writer.endNode();
1960 private void emitBodyOfDataSchemaNode(final DataSchemaNode dataSchemaNode) {
1961 emitWhen(dataSchemaNode.getConstraints().getWhenCondition());
1962 // FIXME: BUG-2444: *(ifFeatureNode )
1963 emitMustNodes(dataSchemaNode.getConstraints().getMustConstraints());
1964 emitConfigNode(dataSchemaNode.isConfiguration());
1965 emitMandatoryNode(dataSchemaNode.getConstraints().isMandatory());
1966 emitDocumentedNode(dataSchemaNode);
1967 emitUnknownStatementNodes(dataSchemaNode.getUnknownSchemaNodes());
1970 private void emitUsesNode(final UsesNode usesNode) {
1971 if (super.emitUses && !usesNode.isAddedByUses() && !usesNode.isAugmenting()) {
1972 super.writer.startUsesNode(usesNode.getGroupingPath().getLastComponent());
1974 * FIXME: BUG-2444: whenNode / *(ifFeatureNode ) statusNode //
1975 * Optional F : descriptionNode // Optional referenceNode //
1978 for (final Entry<SchemaPath, SchemaNode> refine : usesNode.getRefines().entrySet()) {
1981 for (final AugmentationSchema aug : usesNode.getAugmentations()) {
1982 emitUsesAugmentNode(aug);
1984 super.writer.endNode();
1988 private void emitRefine(final Entry<SchemaPath, SchemaNode> refine) {
1989 final SchemaPath path = refine.getKey();
1990 final SchemaNode value = refine.getValue();
1991 super.writer.startRefineNode(path);
1993 if (value instanceof LeafSchemaNode) {
1994 emitRefineLeafNodes((LeafSchemaNode) value);
1995 } else if (value instanceof LeafListSchemaNode) {
1996 emitRefineLeafListNodes((LeafListSchemaNode) value);
1997 } else if (value instanceof ListSchemaNode) {
1998 emitRefineListNodes((ListSchemaNode) value);
1999 } else if (value instanceof ChoiceSchemaNode) {
2000 emitRefineChoiceNodes((ChoiceSchemaNode) value);
2001 } else if (value instanceof ChoiceCaseNode) {
2002 emitRefineCaseNodes((ChoiceCaseNode) value);
2003 } else if (value instanceof ContainerSchemaNode) {
2004 emitRefineContainerNodes((ContainerSchemaNode) value);
2005 } else if (value instanceof AnyXmlSchemaNode) {
2006 emitRefineAnyxmlNodes((AnyXmlSchemaNode) value);
2008 super.writer.endNode();
2012 private static <T extends SchemaNode> T getOriginalChecked(final T value) {
2013 final Optional<SchemaNode> original = SchemaNodeUtils.getOriginalIfPossible(value);
2014 Preconditions.checkArgument(original.isPresent(), "Original unmodified version of node is not present.");
2015 @SuppressWarnings("unchecked")
2016 final T ret = (T) original.get();
2020 private void emitDocumentedNodeRefine(final DocumentedNode original, final DocumentedNode value) {
2021 if (Objects.deepEquals(original.getDescription(), value.getDescription())) {
2022 emitDescriptionNode(value.getDescription());
2024 if (Objects.deepEquals(original.getReference(), value.getReference())) {
2025 emitReferenceNode(value.getReference());
2029 private void emitRefineContainerNodes(final ContainerSchemaNode value) {
2030 final ContainerSchemaNode original = getOriginalChecked(value);
2032 // emitMustNodes(child.getConstraints().getMustConstraints());
2033 if (Objects.deepEquals(original.isPresenceContainer(), value.isPresenceContainer())) {
2034 emitPresenceNode(value.isPresenceContainer());
2036 if (Objects.deepEquals(original.isConfiguration(), value.isConfiguration())) {
2037 emitConfigNode(value.isConfiguration());
2039 emitDocumentedNodeRefine(original, value);
2043 private void emitRefineLeafNodes(final LeafSchemaNode value) {
2044 final LeafSchemaNode original = getOriginalChecked(value);
2046 // emitMustNodes(child.getConstraints().getMustConstraints());
2047 if (Objects.deepEquals(original.getDefault(), value.getDefault())) {
2048 emitDefaultNode(value.getDefault());
2050 if (Objects.deepEquals(original.isConfiguration(), value.isConfiguration())) {
2051 emitConfigNode(value.isConfiguration());
2053 emitDocumentedNodeRefine(original, value);
2054 if (Objects.deepEquals(original.getConstraints().isMandatory(), value.getConstraints().isMandatory())) {
2055 emitMandatoryNode(value.getConstraints().isMandatory());
2060 private void emitRefineLeafListNodes(final LeafListSchemaNode value) {
2061 final LeafListSchemaNode original = getOriginalChecked(value);
2063 // emitMustNodes(child.getConstraints().getMustConstraints());
2064 if (Objects.deepEquals(original.isConfiguration(), value.isConfiguration())) {
2065 emitConfigNode(value.isConfiguration());
2067 if (Objects.deepEquals(original.getConstraints().getMinElements(),
2068 value.getConstraints().getMinElements())) {
2069 emitMinElementsNode(value.getConstraints().getMinElements());
2071 if (Objects.deepEquals(original.getConstraints().getMaxElements(),
2072 value.getConstraints().getMaxElements())) {
2073 emitMaxElementsNode(value.getConstraints().getMaxElements());
2075 emitDocumentedNodeRefine(original, value);
2079 private void emitRefineListNodes(final ListSchemaNode value) {
2080 final ListSchemaNode original = getOriginalChecked(value);
2082 // emitMustNodes(child.getConstraints().getMustConstraints());
2083 if (Objects.deepEquals(original.isConfiguration(), value.isConfiguration())) {
2084 emitConfigNode(value.isConfiguration());
2086 if (Objects.deepEquals(original.getConstraints().getMinElements(),
2087 value.getConstraints().getMinElements())) {
2088 emitMinElementsNode(value.getConstraints().getMinElements());
2090 if (Objects.deepEquals(original.getConstraints().getMaxElements(),
2091 value.getConstraints().getMaxElements())) {
2092 emitMaxElementsNode(value.getConstraints().getMaxElements());
2094 emitDocumentedNodeRefine(original, value);
2098 private void emitRefineChoiceNodes(final ChoiceSchemaNode value) {
2099 final ChoiceSchemaNode original = getOriginalChecked(value);
2101 // FIXME: BUG-2444: defaultNode //FIXME: BUG-2444: Optional
2102 if (Objects.deepEquals(original.isConfiguration(), value.isConfiguration())) {
2103 emitConfigNode(value.isConfiguration());
2105 if (Objects.deepEquals(original.getConstraints().isMandatory(), value.getConstraints().isMandatory())) {
2106 emitMandatoryNode(value.getConstraints().isMandatory());
2108 emitDocumentedNodeRefine(original, value);
2112 private void emitRefineCaseNodes(final ChoiceCaseNode value) {
2113 final ChoiceCaseNode original = getOriginalChecked(value);
2114 emitDocumentedNodeRefine(original, value);
2118 private void emitRefineAnyxmlNodes(final AnyXmlSchemaNode value) {
2119 final AnyXmlSchemaNode original = getOriginalChecked(value);
2122 // emitMustNodes(child.getConstraints().getMustConstraints());
2123 if (Objects.deepEquals(original.isConfiguration(), value.isConfiguration())) {
2124 emitConfigNode(value.isConfiguration());
2126 if (Objects.deepEquals(original.getConstraints().isMandatory(), value.getConstraints().isMandatory())) {
2127 emitMandatoryNode(value.getConstraints().isMandatory());
2129 emitDocumentedNodeRefine(original, value);
2133 private void emitUsesAugmentNode(final AugmentationSchema aug) {
2135 * differs only in location in schema, otherwise currently (as of
2136 * RFC6020) it is same, so we could freely reuse path.
2141 private void emitAugment(final AugmentationSchema augmentation) {
2142 super.writer.startAugmentNode(augmentation.getTargetPath());
2143 // FIXME: BUG-2444: whenNode //Optional
2144 // FIXME: BUG-2444: *(ifFeatureNode )
2146 emitStatusNode(augmentation.getStatus());
2147 emitDescriptionNode(augmentation.getDescription());
2148 emitReferenceNode(augmentation.getReference());
2149 for (final UsesNode uses : augmentation.getUses()) {
2153 for (final DataSchemaNode childNode : augmentation.getChildNodes()) {
2154 if (childNode instanceof ChoiceCaseNode) {
2155 emitCaseNode((ChoiceCaseNode) childNode);
2157 emitDataSchemaNode(childNode);
2160 emitUnknownStatementNodes(augmentation.getUnknownSchemaNodes());
2161 emitNotifications(augmentation.getNotifications());
2162 emitActions(augmentation.getActions());
2163 super.writer.endNode();
2166 private void emitUnknownStatementNodes(final List<UnknownSchemaNode> unknownNodes) {
2167 for (final UnknownSchemaNode unknonwnNode : unknownNodes) {
2168 if (!unknonwnNode.isAddedByAugmentation() && !unknonwnNode.isAddedByUses()) {
2169 emitUnknownStatementNode(unknonwnNode);
2174 private void emitUnknownStatementNode(final UnknownSchemaNode node) {
2175 final StatementDefinition def = getStatementChecked(node.getNodeType());
2176 if (def.getArgumentName() == null) {
2177 super.writer.startUnknownNode(def);
2179 super.writer.startUnknownNode(def, node.getNodeParameter());
2181 emitUnknownStatementNodes(node.getUnknownSchemaNodes());
2182 super.writer.endNode();
2185 private StatementDefinition getStatementChecked(final QName nodeType) {
2186 final StatementDefinition ret = super.extensions.get(nodeType);
2187 Preconditions.checkArgument(ret != null, "Unknown extension %s used during export.", nodeType);
2191 private void emitWhen(final RevisionAwareXPath revisionAwareXPath) {
2192 if (revisionAwareXPath != null) {
2193 super.writer.startWhenNode(revisionAwareXPath);
2194 super.writer.endNode();
2196 // FIXME: BUG-2444: descriptionNode //FIXME: BUG-2444: Optional
2197 // FIXME: BUG-2444: referenceNode //FIXME: BUG-2444: Optional
2198 // FIXME: BUG-2444: super.writer.endNode();)
2202 private void emitRpc(final RpcDefinition rpc) {
2203 super.writer.startRpcNode(rpc.getQName());
2204 emitOperationBody(rpc);
2205 super.writer.endNode();
2208 private void emitOperationBody(final OperationDefinition rpc) {
2209 // FIXME: BUG-2444: *(ifFeatureNode )
2210 emitStatusNode(rpc.getStatus());
2211 emitDescriptionNode(rpc.getDescription());
2212 emitReferenceNode(rpc.getReference());
2214 for (final TypeDefinition<?> typedef : rpc.getTypeDefinitions()) {
2215 emitTypedefNode(typedef);
2217 for (final GroupingDefinition grouping : rpc.getGroupings()) {
2218 emitGrouping(grouping);
2220 emitInput(rpc.getInput());
2221 emitOutput(rpc.getOutput());
2222 emitUnknownStatementNodes(rpc.getUnknownSchemaNodes());
2225 private void emitActions(final Set<ActionDefinition> actions) {
2226 for (final ActionDefinition actionDefinition : actions) {
2227 emitAction(actionDefinition);
2231 private void emitAction(final ActionDefinition action) {
2232 // :FIXME add addedByUses & addedByAugmentation in API and perform
2234 super.writer.startActionNode(action.getQName());
2235 emitOperationBody(action);
2236 super.writer.endNode();
2239 private void emitInput(@Nonnull final ContainerSchemaNode input) {
2240 if (isExplicitStatement(input)) {
2241 super.writer.startInputNode();
2242 emitConstraints(input.getConstraints());
2243 emitDataNodeContainer(input);
2244 emitUnknownStatementNodes(input.getUnknownSchemaNodes());
2245 super.writer.endNode();
2250 private void emitOutput(@Nonnull final ContainerSchemaNode output) {
2251 if (isExplicitStatement(output)) {
2252 super.writer.startOutputNode();
2253 emitConstraints(output.getConstraints());
2254 emitDataNodeContainer(output);
2255 emitUnknownStatementNodes(output.getUnknownSchemaNodes());
2256 super.writer.endNode();
2260 private static boolean isExplicitStatement(final ContainerSchemaNode node) {
2261 return node instanceof EffectiveStatement && ((EffectiveStatement<?, ?>) node).getDeclared()
2262 .getStatementSource() == StatementSource.DECLARATION;
2265 private void emitNotifications(final Set<NotificationDefinition> notifications) {
2266 for (final NotificationDefinition notification : notifications) {
2267 emitNotificationNode(notification);
2271 private void emitNotificationNode(final NotificationDefinition notification) {
2272 // :FIXME add addedByUses & addedByAugmentation in API and perform
2275 super.writer.startNotificationNode(notification.getQName());
2276 // FIXME: BUG-2444: *(ifFeatureNode )
2277 emitConstraints(notification.getConstraints());
2278 emitDocumentedNode(notification);
2279 emitDataNodeContainer(notification);
2280 emitUnknownStatementNodes(notification.getUnknownSchemaNodes());
2281 super.writer.endNode();
2285 private void emitDeviation(final Deviation deviation) {
2287 * FIXME: BUG-2444: Deviation is not modeled properly and we are
2288 * loosing lot of information in order to export it properly
2290 * super.writer.startDeviationNode(deviation.getTargetPath());
2292 * :descriptionNode //:Optional
2295 * emitReferenceNode(deviation.getReference());
2296 * :(deviateNotSupportedNode :1*(deviateAddNode :deviateReplaceNode
2297 * :deviateDeleteNode)) :super.writer.endNode();