import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.DerivedType;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
@Beta
}
private void emitTypeBodyNodes(final TypeDefinition<?> typeDef) {
- if (typeDef instanceof ExtendedType) {
- emitTypeBodyNodes(DerivedType.from((ExtendedType) typeDef));
- } else if (typeDef instanceof UnsignedIntegerTypeDefinition) {
+ if (typeDef instanceof UnsignedIntegerTypeDefinition) {
emitUnsignedIntegerSpecification((UnsignedIntegerTypeDefinition) typeDef);
} else if (typeDef instanceof IntegerTypeDefinition) {
emitIntegerSpefication((IntegerTypeDefinition) typeDef);
}
private void emitPatternNode(final PatternConstraint pattern) {
- writer.startPatternNode(pattern.getRegularExpression());
+ writer.startPatternNode(pattern.getRawRegularExpression());
emitErrorMessageNode(pattern.getErrorMessage()); // FIXME: BUG-2444: Optional
emitErrorAppTagNode(pattern.getErrorAppTag()); // FIXME: BUG-2444: Optional
emitDescriptionNode(pattern.getDescription());
}
private void emitIdentityrefSpecification(final IdentityrefTypeDefinition typeDefinition) {
- emitBase(typeDefinition.getQName());
+ emitBase(typeDefinition.getIdentity().getQName());
}
private void emitUnionSpecification(final UnionTypeDefinition typeDefinition) {
}
private void emitMust(@Nullable final MustDefinition mustCondition) {
- if(mustCondition != null && mustCondition.getXpath() != null) {
+ if (mustCondition != null && mustCondition.getXpath() != null) {
writer.startMustNode(mustCondition.getXpath());
emitErrorMessageNode(mustCondition.getErrorMessage());
emitErrorAppTagNode(mustCondition.getErrorAppTag());
}
}
- private void emitDocumentedNode(final DocumentedNode input) {
+ private void emitDocumentedNode(final DocumentedNode.WithStatus input) {
emitStatusNode(input.getStatus());
emitDescriptionNode(input.getDescription());
emitReferenceNode(input.getReference());
emitConstraints(child.getConstraints());
// FIXME: BUG-2444: whenNode //:Optional
// FIXME: BUG-2444: *(ifFeatureNode )
- emitMustNodes(child.getConstraints().getMustConstraints());
emitPresenceNode(child.isPresenceContainer());
emitConfigNode(child.isConfiguration());
emitDocumentedNode(child);
emitStatusNode(augmentation.getStatus());
emitDescriptionNode(augmentation.getDescription());
emitReferenceNode(augmentation.getReference());
- for(final UsesNode uses: augmentation.getUses()) {
+ for (final UsesNode uses: augmentation.getUses()) {
emitUsesNode(uses);
}
private void emitUnknownStatementNodes(final List<UnknownSchemaNode> unknownNodes) {
for (final UnknownSchemaNode unknonwnNode : unknownNodes) {
- emitUnknownStatementNode(unknonwnNode);
+ if (!unknonwnNode.isAddedByAugmentation() && !unknonwnNode.isAddedByUses()) {
+ emitUnknownStatementNode(unknonwnNode);
+ }
}
}
}
private void emitWhen(final RevisionAwareXPath revisionAwareXPath) {
- if(revisionAwareXPath != null) {
+ if (revisionAwareXPath != null) {
writer.startWhenNode(revisionAwareXPath);
writer.endNode();
}
emitDescriptionNode(rpc.getDescription());
emitReferenceNode(rpc.getReference());
- for(final TypeDefinition<?> typedef : rpc.getTypeDefinitions()) {
+ for (final TypeDefinition<?> typedef : rpc.getTypeDefinitions()) {
emitTypedefNode(typedef);
}
- for(final GroupingDefinition grouping : rpc.getGroupings()) {
+ for (final GroupingDefinition grouping : rpc.getGroupings()) {
emitGrouping(grouping);
}
emitInput(rpc.getInput());
}
- private void emitInput(@Nullable final ContainerSchemaNode input) {
- if (input != null) {
+ private void emitInput(@Nonnull final ContainerSchemaNode input) {
+ if (isExplicitStatement(input)) {
writer.startInputNode();
emitDataNodeContainer(input);
emitUnknownStatementNodes(input.getUnknownSchemaNodes());
}
- private void emitOutput(@Nullable final ContainerSchemaNode input) {
- if (input != null) {
+ private void emitOutput(@Nonnull final ContainerSchemaNode output) {
+ if (isExplicitStatement(output)) {
writer.startOutputNode();
- emitDataNodeContainer(input);
- emitUnknownStatementNodes(input.getUnknownSchemaNodes());
+ emitDataNodeContainer(output);
+ emitUnknownStatementNodes(output.getUnknownSchemaNodes());
writer.endNode();
}
}
+ private static boolean isExplicitStatement(final ContainerSchemaNode node) {
+ return node instanceof EffectiveStatement
+ && ((EffectiveStatement) node).getDeclared().getStatementSource() == StatementSource.DECLARATION;
+ }
+
private void emitNotificationNode(final NotificationDefinition notification) {
writer.startNotificationNode(notification.getQName());
// FIXME: BUG-2444: *(ifFeatureNode )
private static <T> boolean isPrefix(final Iterable<T> prefix, final Iterable<T> other) {
final Iterator<T> prefixIt = prefix.iterator();
final Iterator<T> otherIt = other.iterator();
- while(prefixIt.hasNext()) {
- if(!otherIt.hasNext()) {
+ while (prefixIt.hasNext()) {
+ if (!otherIt.hasNext()) {
return false;
}
- if(!Objects.deepEquals(prefixIt.next(), otherIt.next())) {
+ if (!Objects.deepEquals(prefixIt.next(), otherIt.next())) {
return false;
}
}