*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.Collections2;
-import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimap;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
import java.util.Map.Entry;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.SchemaAwareNormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode;
/**
* A node which is composed of multiple simpler nodes.
*/
class CompositeNodeDataWithSchema extends AbstractNodeDataWithSchema {
- private static final Function<DataSchemaNode, QName> QNAME_FUNCTION = new Function<DataSchemaNode, QName>() {
- @Override
- public QName apply(@Nonnull final DataSchemaNode input) {
- return input.getQName();
- }
- };
/**
* nodes which were added to schema via augmentation and are present in data input
super(schema);
}
- public AbstractNodeDataWithSchema addChild(final Deque<DataSchemaNode> schemas, final boolean rootListItem) {
+ public AbstractNodeDataWithSchema addChild(final Deque<DataSchemaNode> schemas) {
Preconditions.checkArgument(!schemas.isEmpty(), "Expecting at least one schema");
// Pop the first node...
final DataSchemaNode schema = schemas.pop();
if (schemas.isEmpty()) {
// Simple, direct node
- return addChild(schema,rootListItem);
+ return addChild(schema);
}
// The choice/case mess, reuse what we already popped
AugmentationSchema augSchema = null;
if (choiceCandidate.isAugmenting()) {
- augSchema = findCorrespondingAugment(getSchema(), choiceCandidate);
+ augSchema = SchemaUtils.findCorrespondingAugment(getSchema(), choiceCandidate);
}
// looking for existing choice
CompositeNodeDataWithSchema caseNodeDataWithSchema = findChoice(childNodes, choiceCandidate, caseCandidate);
if (caseNodeDataWithSchema == null) {
- final ChoiceNodeDataWithSchema choiceNodeDataWithSchema = new ChoiceNodeDataWithSchema(choiceNode);
- addChild(choiceNodeDataWithSchema);
- caseNodeDataWithSchema = choiceNodeDataWithSchema.addCompositeChild(caseNode,rootListItem);
+ ChoiceNodeDataWithSchema choiceNodeDataWithSchema = new ChoiceNodeDataWithSchema(choiceNode);
+ childNodes.add(choiceNodeDataWithSchema);
+ caseNodeDataWithSchema = choiceNodeDataWithSchema.addCompositeChild(caseNode);
}
- return caseNodeDataWithSchema.addChild(schemas, rootListItem);
+ return caseNodeDataWithSchema.addChild(schemas);
}
private AbstractNodeDataWithSchema addSimpleChild(final DataSchemaNode schema) {
if (schema instanceof LeafSchemaNode) {
newChild = new LeafNodeDataWithSchema(schema);
} else if (schema instanceof AnyXmlSchemaNode) {
+ // YangModeledAnyXmlSchemaNode is handled by addCompositeChild method.
+ if (schema instanceof YangModeledAnyXmlSchemaNode) {
+ return null;
+ }
newChild = new AnyXmlNodeDataWithSchema(schema);
} else {
return null;
AugmentationSchema augSchema = null;
if (schema.isAugmenting()) {
- augSchema = findCorrespondingAugment(getSchema(), schema);
+ augSchema = SchemaUtils.findCorrespondingAugment(getSchema(), schema);
}
if (augSchema != null) {
augmentationsToChild.put(augSchema, newChild);
return newChild;
}
- private CaseNodeDataWithSchema findChoice(final Collection<AbstractNodeDataWithSchema> childNodes, final DataSchemaNode choiceCandidate,
- final DataSchemaNode caseCandidate) {
+ private static CaseNodeDataWithSchema findChoice(final Collection<AbstractNodeDataWithSchema> childNodes,
+ final DataSchemaNode choiceCandidate, final DataSchemaNode caseCandidate) {
if (childNodes != null) {
- for (final AbstractNodeDataWithSchema nodeDataWithSchema : childNodes) {
+ for (AbstractNodeDataWithSchema nodeDataWithSchema : childNodes) {
if (nodeDataWithSchema instanceof ChoiceNodeDataWithSchema
&& nodeDataWithSchema.getSchema().getQName().equals(choiceCandidate.getQName())) {
- final CaseNodeDataWithSchema casePrevious = ((ChoiceNodeDataWithSchema) nodeDataWithSchema).getCase();
+ CaseNodeDataWithSchema casePrevious = ((ChoiceNodeDataWithSchema) nodeDataWithSchema).getCase();
Preconditions.checkArgument(casePrevious.getSchema().getQName().equals(caseCandidate.getQName()),
"Data from case %s are specified but other data from case %s were specified erlier. Data aren't from the same case.",
return null;
}
- AbstractNodeDataWithSchema addCompositeChild(final DataSchemaNode schema, final boolean rootListItem) {
- CompositeNodeDataWithSchema newChild;
+ AbstractNodeDataWithSchema addCompositeChild(final DataSchemaNode schema) {
+ final CompositeNodeDataWithSchema newChild;
+
if (schema instanceof ListSchemaNode) {
newChild = new ListNodeDataWithSchema(schema);
- /*
- * If we are reading root we may want to emit map also for object which represent one list
- * item.
- * */
- if(rootListItem) {
- addCompositeChild(newChild);
- final ListEntryNodeDataWithSchema entry = new ListEntryNodeDataWithSchema(schema);
- newChild.addChild(entry);
- return entry;
- }
} else if (schema instanceof LeafListSchemaNode) {
newChild = new LeafListNodeDataWithSchema(schema);
} else if (schema instanceof ContainerSchemaNode) {
newChild = new ContainerNodeDataWithSchema(schema);
+ } else if (schema instanceof YangModeledAnyXmlSchemaNode) {
+ newChild = new YangModeledAnyXmlNodeDataWithSchema((YangModeledAnyXmlSchemaNode)schema);
} else {
newChild = new CompositeNodeDataWithSchema(schema);
}
+
addCompositeChild(newChild);
return newChild;
}
void addCompositeChild(final CompositeNodeDataWithSchema newChild) {
- final AugmentationSchema augSchema = findCorrespondingAugment(getSchema(), newChild.getSchema());
+ AugmentationSchema augSchema = SchemaUtils.findCorrespondingAugment(getSchema(), newChild.getSchema());
if (augSchema != null) {
augmentationsToChild.put(augSchema, newChild);
} else {
}
}
- private AbstractNodeDataWithSchema addChild(final DataSchemaNode schema, final boolean rootListItem) {
- final AbstractNodeDataWithSchema newChild = addSimpleChild(schema);
- return newChild == null ? addCompositeChild(schema,rootListItem) : newChild;
+ private AbstractNodeDataWithSchema addChild(final DataSchemaNode schema) {
+ AbstractNodeDataWithSchema newChild = addSimpleChild(schema);
+ return newChild == null ? addCompositeChild(schema) : newChild;
}
public void addChild(final AbstractNodeDataWithSchema newChild) {
return children.size();
}
- /**
- * Tries to find in {@code parent} which is dealed as augmentation target node with QName as {@code child}. If such
- * node is found then it is returned, else null.
- */
- AugmentationSchema findCorrespondingAugment(final DataSchemaNode parent, final DataSchemaNode child) {
- if (parent instanceof AugmentationTarget && !((parent instanceof ChoiceCaseNode) || (parent instanceof ChoiceSchemaNode))) {
- for (final AugmentationSchema augmentation : ((AugmentationTarget) parent).getAvailableAugmentations()) {
- final DataSchemaNode childInAugmentation = augmentation.getDataChildByName(child.getQName());
- if (childInAugmentation != null) {
- return augmentation;
- }
- }
- }
- return null;
- }
-
@Override
- public void write(final NormalizedNodeStreamWriter writer) throws IOException {
- for (final AbstractNodeDataWithSchema child : children) {
+ public void write(final SchemaAwareNormalizedNodeStreamWriter writer) throws IOException {
+ for (AbstractNodeDataWithSchema child : children) {
child.write(writer);
}
- for (final Entry<AugmentationSchema, Collection<AbstractNodeDataWithSchema>> augmentationToChild : augmentationsToChild.asMap().entrySet()) {
+ for (Entry<AugmentationSchema, Collection<AbstractNodeDataWithSchema>> augmentationToChild : augmentationsToChild.asMap().entrySet()) {
final Collection<AbstractNodeDataWithSchema> childsFromAgumentation = augmentationToChild.getValue();
if (!childsFromAgumentation.isEmpty()) {
- writer.startAugmentationNode(toAugmentationIdentifier(augmentationToChild.getKey()));
+ // FIXME: can we get the augmentation schema?
+ writer.startAugmentationNode(SchemaUtils.getNodeIdentifierForAugmentation(augmentationToChild.getKey()));
- for (final AbstractNodeDataWithSchema nodeDataWithSchema : childsFromAgumentation) {
+ for (AbstractNodeDataWithSchema nodeDataWithSchema : childsFromAgumentation) {
nodeDataWithSchema.write(writer);
}
}
}
}
-
- private static AugmentationIdentifier toAugmentationIdentifier(final AugmentationSchema schema) {
- final Collection<QName> qnames = Collections2.transform(schema.getChildNodes(), QNAME_FUNCTION);
- return new AugmentationIdentifier(ImmutableSet.copyOf(qnames));
- }
}