opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/rest/impl/XmlMapper.java

   1 package org.opendaylight.controller.sal.rest.impl;
   2
   3 import java.util.Set;
   4
   5 import javax.activation.UnsupportedDataTypeException;
   6 import javax.xml.parsers.DocumentBuilder;
   7 import javax.xml.parsers.DocumentBuilderFactory;
   8 import javax.xml.parsers.ParserConfigurationException;
   9
  10 import org.opendaylight.yangtools.yang.common.QName;
  11 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  12 import org.opendaylight.yangtools.yang.data.api.Node;
  13 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
  14 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  15 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
  16 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  17 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  18 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  19 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  20 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  21 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  22 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.YangNode;
  24 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27 import org.w3c.dom.Document;
  28 import org.w3c.dom.Element;
  29
  30 import com.google.common.base.Preconditions;
  31
  32 public class XmlMapper {
  33
  34     private final Logger logger = LoggerFactory.getLogger(XmlMapper.class);
  35
  36     public Document write(CompositeNode data, DataNodeContainer schema) throws UnsupportedDataTypeException {
  37         Preconditions.checkNotNull(data);
  38         Preconditions.checkNotNull(schema);
  39
  40         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  41         Document doc = null;
  42         try {
  43             DocumentBuilder bob = dbf.newDocumentBuilder();
  44             doc = bob.newDocument();
  45         } catch (ParserConfigurationException e) {
  46             return null;
  47         }
  48
  49         if (schema instanceof ContainerSchemaNode || schema instanceof ListSchemaNode) {
  50             doc.appendChild(translateToXmlAndReturnRootElement(doc, data, schema));
  51             return doc;
  52         } else {
  53             throw new UnsupportedDataTypeException(
  54                     "Schema can be ContainerSchemaNode or ListSchemaNode. Other types are not supported yet.");
  55         }
  56     }
  57
  58     private Element translateToXmlAndReturnRootElement(Document doc, Node<?> data, YangNode schema)
  59             throws UnsupportedDataTypeException {
  60         QName dataType = data.getNodeType();
  61         Element itemEl = doc.createElementNS(dataType.getNamespace().toString(), dataType.getLocalName());
  62
  63         if (data instanceof SimpleNode<?>) {
  64             if (schema instanceof LeafListSchemaNode) {
  65                 writeValueOfNodeByType(itemEl, (SimpleNode<?>) data, ((LeafListSchemaNode) schema).getType());
  66             } else if (schema instanceof LeafSchemaNode) {
  67                 writeValueOfNodeByType(itemEl, (SimpleNode<?>) data, ((LeafSchemaNode) schema).getType());
  68             } else {
  69                 Object value = data.getValue();
  70                 if (value != null) {
  71                     itemEl.setTextContent(String.valueOf(value));
  72                 }
  73             }
  74         } else { // CompositeNode
  75             for (Node<?> child : ((CompositeNode) data).getChildren()) {
  76                 DataSchemaNode childSchema = findFirstSchemaForNode(child, ((DataNodeContainer) schema).getChildNodes());
  77                 if (logger.isDebugEnabled()) {
  78                     if (childSchema == null) {
  79                         logger.debug("Probably the data node \"" + ((child == null) ? "" : child.getNodeType().getLocalName())
  80                                 + "\" is not conform to schema");
  81                     }
  82                 }
  83                 itemEl.appendChild(translateToXmlAndReturnRootElement(doc, child, childSchema));
  84             }
  85         }
  86         return itemEl;
  87     }
  88
  89     private void writeValueOfNodeByType(Element element, SimpleNode<?> node, TypeDefinition<?> type) {
  90
  91         TypeDefinition<?> baseType = resolveBaseTypeFrom(type);
  92
  93         if (baseType instanceof IdentityrefTypeDefinition && node.getValue() instanceof QName) {
  94             QName value = (QName) node.getValue();
  95             element.setAttribute("xmlns:x", value.getNamespace().toString());
  96             element.setTextContent("x:" + value.getLocalName());
  97         } else {
  98             Object value = node.getValue();
  99             if (value != null) {
 100                 element.setTextContent(String.valueOf(value));
 101             }
 102         }
 103     }
 104
 105     private DataSchemaNode findFirstSchemaForNode(Node<?> node, Set<DataSchemaNode> dataSchemaNode) {
 106         if (dataSchemaNode != null && node != null) {
 107             for (DataSchemaNode dsn : dataSchemaNode) {
 108                 if (node.getNodeType().getLocalName().equals(dsn.getQName().getLocalName())) {
 109                     return dsn;
 110                 } else if (dsn instanceof ChoiceNode) {
 111                     for (ChoiceCaseNode choiceCase : ((ChoiceNode) dsn).getCases()) {
 112                         DataSchemaNode foundDsn = findFirstSchemaForNode(node, choiceCase.getChildNodes());
 113                         if (foundDsn != null) {
 114                             return foundDsn;
 115                         }
 116                     }
 117                 }
 118             }
 119         }
 120         return null;
 121     }
 122
 123     private TypeDefinition<?> resolveBaseTypeFrom(TypeDefinition<?> type) {
 124         return type.getBaseType() != null ? resolveBaseTypeFrom(type.getBaseType()) : type;
 125     }
 126
 127 }