opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/util/ParserUtils.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.controller.yang.model.parser.util;
   9
  10 import java.util.ArrayList;
  11 import java.util.List;
  12
  13 import org.opendaylight.controller.yang.common.QName;
  14 import org.opendaylight.controller.yang.model.api.MustDefinition;
  15 import org.opendaylight.controller.yang.model.api.SchemaPath;
  16 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  17 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationSchemaBuilder;
  18 import org.opendaylight.controller.yang.model.parser.builder.api.DataSchemaNodeBuilder;
  19 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;
  20 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;
  21 import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
  22 import org.opendaylight.controller.yang.model.parser.builder.impl.AnyXmlBuilder;
  23 import org.opendaylight.controller.yang.model.parser.builder.impl.ChoiceBuilder;
  24 import org.opendaylight.controller.yang.model.parser.builder.impl.ChoiceCaseBuilder;
  25 import org.opendaylight.controller.yang.model.parser.builder.impl.ConstraintsBuilder;
  26 import org.opendaylight.controller.yang.model.parser.builder.impl.ContainerSchemaNodeBuilder;
  27 import org.opendaylight.controller.yang.model.parser.builder.impl.LeafListSchemaNodeBuilder;
  28 import org.opendaylight.controller.yang.model.parser.builder.impl.LeafSchemaNodeBuilder;
  29 import org.opendaylight.controller.yang.model.parser.builder.impl.ListSchemaNodeBuilder;
  30 import org.opendaylight.controller.yang.model.parser.builder.impl.UnknownSchemaNodeBuilder;
  31
  32 public final class ParserUtils {
  33
  34     private ParserUtils() {
  35     }
  36
  37     public static SchemaPath parseUsesPath(final String usesPath) {
  38         final boolean absolute = usesPath.startsWith("/");
  39         final String[] splittedPath = usesPath.split("/");
  40         final List<QName> path = new ArrayList<QName>();
  41         QName name;
  42         for (String pathElement : splittedPath) {
  43             if (pathElement.length() > 0) {
  44                 final String[] splittedElement = pathElement.split(":");
  45                 if (splittedElement.length == 1) {
  46                     name = new QName(null, null, null, splittedElement[0]);
  47                 } else {
  48                     name = new QName(null, null, splittedElement[0],
  49                             splittedElement[1]);
  50                 }
  51                 path.add(name);
  52             }
  53         }
  54         return new SchemaPath(path, absolute);
  55     }
  56
  57     public static LeafSchemaNodeBuilder copyLeafBuilder(
  58             final LeafSchemaNodeBuilder old) {
  59         final LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(
  60                 old.getQName());
  61         final TypeDefinition<?> type = old.getType();
  62
  63         if (type == null) {
  64             copy.setType(old.getTypedef());
  65         } else {
  66             copy.setType(type);
  67         }
  68         copy.setPath(old.getPath());
  69         copyConstraints(old, copy);
  70         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
  71             copy.addUnknownSchemaNode(unknown);
  72         }
  73         copy.setDescription(old.getDescription());
  74         copy.setReference(old.getReference());
  75         copy.setStatus(old.getStatus());
  76         copy.setAugmenting(old.isAugmenting());
  77         copy.setConfiguration(old.isConfiguration());
  78         copy.setDefaultStr(old.getDefaultStr());
  79         copy.setUnits(old.getUnits());
  80         return copy;
  81     }
  82
  83     public static ContainerSchemaNodeBuilder copyContainerBuilder(
  84             final ContainerSchemaNodeBuilder old) {
  85         final ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(
  86                 old.getQName());
  87         copy.setPath(old.getPath());
  88         copyConstraints(old, copy);
  89         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
  90             copy.addUnknownSchemaNode(unknown);
  91         }
  92         for (DataSchemaNodeBuilder child : old.getChildNodes()) {
  93             copy.addChildNode(child);
  94         }
  95         for (GroupingBuilder grouping : old.getGroupings()) {
  96             copy.addGrouping(grouping);
  97         }
  98         for (TypeDefinitionBuilder typedef : old.getTypedefs()) {
  99             copy.addTypedef(typedef);
 100         }
 101         for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
 102             copy.addAugmentation(augment);
 103         }
 104         for (UsesNodeBuilder use : old.getUsesNodes()) {
 105             copy.addUsesNode(use);
 106         }
 107         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
 108             copy.addUnknownSchemaNode(unknown);
 109         }
 110         copy.setDescription(old.getDescription());
 111         copy.setReference(old.getReference());
 112         copy.setStatus(old.getStatus());
 113         copy.setAugmenting(old.isAugmenting());
 114         copy.setConfiguration(old.isConfiguration());
 115         copy.setPresence(old.isPresence());
 116         return copy;
 117     }
 118
 119     public static ListSchemaNodeBuilder copyListBuilder(
 120             final ListSchemaNodeBuilder old) {
 121         final ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(
 122                 old.getQName());
 123         copy.setPath(old.getPath());
 124         copyConstraints(old, copy);
 125         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
 126             copy.addUnknownSchemaNode(unknown);
 127         }
 128         for (DataSchemaNodeBuilder child : old.getChildNodes()) {
 129             copy.addChildNode(child);
 130         }
 131         for (GroupingBuilder grouping : old.getGroupings()) {
 132             copy.addGrouping(grouping);
 133         }
 134         for (TypeDefinitionBuilder typedef : old.getTypedefs()) {
 135             copy.addTypedef(typedef);
 136         }
 137         for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
 138             copy.addAugmentation(augment);
 139         }
 140         for (UsesNodeBuilder use : old.getUsesNodes()) {
 141             copy.addUsesNode(use);
 142         }
 143         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
 144             copy.addUnknownSchemaNode(unknown);
 145         }
 146         copy.setDescription(old.getDescription());
 147         copy.setReference(old.getReference());
 148         copy.setStatus(old.getStatus());
 149         copy.setAugmenting(old.isAugmenting());
 150         copy.setConfiguration(old.isConfiguration());
 151         copy.setUserOrdered(old.isUserOrdered());
 152         return copy;
 153     }
 154
 155     public static LeafListSchemaNodeBuilder copyLeafListBuilder(
 156             final LeafListSchemaNodeBuilder old) {
 157         final LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(
 158                 old.getQName());
 159         copy.setPath(old.getPath());
 160         copyConstraints(old, copy);
 161         final TypeDefinition<?> type = old.getType();
 162         if (type == null) {
 163             copy.setType(old.getTypedef());
 164         } else {
 165             copy.setType(type);
 166         }
 167         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
 168             copy.addUnknownSchemaNode(unknown);
 169         }
 170         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
 171             copy.addUnknownSchemaNode(unknown);
 172         }
 173         copy.setDescription(old.getDescription());
 174         copy.setReference(old.getReference());
 175         copy.setStatus(old.getStatus());
 176         copy.setAugmenting(old.isAugmenting());
 177         copy.setConfiguration(old.isConfiguration());
 178         copy.setUserOrdered(old.isUserOrdered());
 179         return copy;
 180     }
 181
 182     public static ChoiceBuilder copyChoiceBuilder(final ChoiceBuilder old) {
 183         final ChoiceBuilder copy = new ChoiceBuilder(old.getQName());
 184         copy.setPath(old.getPath());
 185         copyConstraints(old, copy);
 186         for (ChoiceCaseBuilder caseBuilder : old.getCases()) {
 187             copy.addChildNode(caseBuilder);
 188         }
 189         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
 190             copy.addUnknownSchemaNode(unknown);
 191         }
 192         for (TypeDefinitionBuilder typedef : old.getTypedefs()) {
 193             copy.addTypedef(typedef);
 194         }
 195         for (UsesNodeBuilder use : old.getUsesNodes()) {
 196             copy.addUsesNode(use);
 197         }
 198         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
 199             copy.addUnknownSchemaNode(unknown);
 200         }
 201         copy.setDefaultCase(old.getDefaultCase());
 202         copy.setDescription(old.getDescription());
 203         copy.setReference(old.getReference());
 204         copy.setStatus(old.getStatus());
 205         copy.setAugmenting(old.isAugmenting());
 206         copy.setConfiguration(old.isConfiguration());
 207         return copy;
 208     }
 209
 210     public static AnyXmlBuilder copyAnyXmlBuilder(final AnyXmlBuilder old) {
 211         final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName());
 212         copy.setPath(old.getPath());
 213         copyConstraints(old, copy);
 214         for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
 215             copy.addUnknownSchemaNode(unknown);
 216         }
 217         copy.setDescription(old.getDescription());
 218         copy.setReference(old.getReference());
 219         copy.setStatus(old.getStatus());
 220         copy.setConfiguration(old.isConfiguration());
 221         return copy;
 222     }
 223
 224     private static void copyConstraints(final DataSchemaNodeBuilder oldBuilder,
 225             final DataSchemaNodeBuilder newBuilder) {
 226         final ConstraintsBuilder oldConstraints = oldBuilder.getConstraints();
 227         final ConstraintsBuilder newConstraints = newBuilder.getConstraints();
 228         newConstraints.addWhenCondition(oldConstraints.getWhenCondition());
 229         for (MustDefinition must : oldConstraints.getMustDefinitions()) {
 230             newConstraints.addMustDefinition(must);
 231         }
 232         newConstraints.setMandatory(oldConstraints.isMandatory());
 233         newConstraints.setMinElements(oldConstraints.getMinElements());
 234         newConstraints.setMaxElements(oldConstraints.getMaxElements());
 235     }
 236
 237 }