yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/RefineUtils.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.yangtools.yang.parser.builder.impl;
   9
  10 import java.util.List;
  11 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
  12 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
  13 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  14 import org.opendaylight.yangtools.yang.parser.builder.api.DocumentedNodeBuilder;
  15 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
  16 import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
  17 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  18 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
  19 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  20 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
  21 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  22
  23 /**
  24  * Utility class with helper methods to perform operations tied to refine
  25  * process.
  26  *
  27  * @deprecated Pre-Beryllium implementation, scheduled for removal.
  28  */
  29 @Deprecated
  30 public final class RefineUtils {
  31
  32     private RefineUtils() {
  33     }
  34
  35     private static void refineLeaf(final LeafSchemaNodeBuilder leaf, final RefineBuilder refine) {
  36         String defaultStr = refine.getDefaultStr();
  37         Boolean mandatory = refine.isMandatory();
  38         MustDefinition must = refine.getMust();
  39         List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
  40
  41         if (defaultStr != null && !defaultStr.isEmpty()) {
  42             leaf.setDefaultStr(defaultStr);
  43         }
  44         if (mandatory != null) {
  45             leaf.getConstraints().setMandatory(mandatory);
  46         }
  47         if (must != null) {
  48             leaf.getConstraints().addMustDefinition(must);
  49         }
  50         if (unknownNodes != null) {
  51             for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
  52                 unknown.setParent(leaf);
  53                 leaf.addUnknownNodeBuilder(unknown);
  54             }
  55         }
  56     }
  57
  58     private static void refineContainer(final ContainerSchemaNodeBuilder container, final RefineBuilder refine) {
  59         Boolean presence = refine.isPresence();
  60         MustDefinition must = refine.getMust();
  61         List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
  62
  63         if (presence != null) {
  64             container.setPresence(presence);
  65         }
  66         if (must != null) {
  67             container.getConstraints().addMustDefinition(must);
  68         }
  69         if (unknownNodes != null) {
  70             for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
  71                 unknown.setParent(container);
  72                 container.addUnknownNodeBuilder(unknown);
  73             }
  74         }
  75     }
  76
  77     private static void refineList(final ListSchemaNodeBuilder list, final RefineBuilder refine) {
  78         MustDefinition must = refine.getMust();
  79         Integer min = refine.getMinElements();
  80         Integer max = refine.getMaxElements();
  81         List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
  82
  83         if (must != null) {
  84             list.getConstraints().addMustDefinition(must);
  85         }
  86         if (min != null) {
  87             list.getConstraints().setMinElements(min);
  88         }
  89         if (max != null) {
  90             list.getConstraints().setMaxElements(max);
  91         }
  92         if (unknownNodes != null) {
  93             for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
  94                 unknown.setParent(list);
  95                 list.addUnknownNodeBuilder(unknown);
  96             }
  97         }
  98     }
  99
 100     public static void refineLeafList(final LeafListSchemaNodeBuilder leafList, final RefineBuilder refine) {
 101         MustDefinition must = refine.getMust();
 102         Integer min = refine.getMinElements();
 103         Integer max = refine.getMaxElements();
 104         List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
 105
 106         if (must != null) {
 107             leafList.getConstraints().addMustDefinition(must);
 108         }
 109         if (min != null) {
 110             leafList.getConstraints().setMinElements(min);
 111         }
 112         if (max != null) {
 113             leafList.getConstraints().setMaxElements(max);
 114         }
 115         if (unknownNodes != null) {
 116             for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
 117                 unknown.setParent(leafList);
 118                 leafList.addUnknownNodeBuilder(unknown);
 119             }
 120         }
 121     }
 122
 123     public static void refineChoice(final ChoiceBuilder choice, final RefineBuilder refine) {
 124         String defaultStr = refine.getDefaultStr();
 125         Boolean mandatory = refine.isMandatory();
 126         List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
 127
 128         if (defaultStr != null) {
 129             choice.setDefaultCase(defaultStr);
 130         }
 131         if (mandatory != null) {
 132             choice.getConstraints().setMandatory(mandatory);
 133         }
 134         if (unknownNodes != null) {
 135             for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
 136                 unknown.setParent(choice);
 137                 choice.addUnknownNodeBuilder(unknown);
 138             }
 139         }
 140     }
 141
 142     public static void refineAnyxml(final AnyXmlBuilder anyXml, final RefineBuilder refine) {
 143         Boolean mandatory = refine.isMandatory();
 144         MustDefinition must = refine.getMust();
 145         List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
 146
 147         if (mandatory != null) {
 148             anyXml.getConstraints().setMandatory(mandatory);
 149         }
 150         if (must != null) {
 151             anyXml.getConstraints().addMustDefinition(must);
 152         }
 153         if (unknownNodes != null) {
 154             for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
 155                 unknown.setParent(anyXml);
 156                 anyXml.addUnknownNodeBuilder(unknown);
 157             }
 158         }
 159     }
 160
 161     /**
 162      * Check if refine can be performed on given node.
 163      *
 164      * @param node
 165      *            node to refine
 166      * @param refine
 167      *            refine object containing information about refine process
 168      */
 169     private static void checkRefine(final SchemaNodeBuilder node, final RefineBuilder refine) {
 170         String moduleName = refine.getModuleName();
 171         int line = refine.getLine();
 172         String name = node.getQName().getLocalName();
 173
 174         String defaultStr = refine.getDefaultStr();
 175         Boolean mandatory = refine.isMandatory();
 176         Boolean presence = refine.isPresence();
 177         MustDefinition must = refine.getMust();
 178         Integer min = refine.getMinElements();
 179         Integer max = refine.getMaxElements();
 180
 181         if (node instanceof AnyXmlBuilder) {
 182             checkRefineDefault(node, defaultStr, moduleName, line);
 183             checkRefinePresence(node, presence, moduleName, line);
 184             checkRefineMinMax(name, min, max, moduleName, line);
 185         } else if (node instanceof ChoiceBuilder) {
 186             checkRefinePresence(node, presence, moduleName, line);
 187             checkRefineMust(node, must, moduleName, line);
 188             checkRefineMinMax(name, min, max, moduleName, line);
 189         } else if (node instanceof ContainerSchemaNodeBuilder) {
 190             checkRefineDefault(node, defaultStr, moduleName, line);
 191             checkRefineMandatory(node, mandatory, moduleName, line);
 192             checkRefineMinMax(name, min, max, moduleName, line);
 193         } else if (node instanceof LeafSchemaNodeBuilder) {
 194             checkRefinePresence(node, presence, moduleName, line);
 195             checkRefineMinMax(name, min, max, moduleName, line);
 196         } else if (node instanceof LeafListSchemaNodeBuilder || node instanceof ListSchemaNodeBuilder) {
 197             checkRefineDefault(node, defaultStr, moduleName, line);
 198             checkRefinePresence(node, presence, moduleName, line);
 199             checkRefineMandatory(node, mandatory, moduleName, line);
 200         } else if (node instanceof GroupingBuilder || node instanceof TypeDefinitionBuilder
 201                 || node instanceof UsesNodeBuilder) {
 202             checkRefineDefault(node, defaultStr, moduleName, line);
 203             checkRefinePresence(node, presence, moduleName, line);
 204             checkRefineMandatory(node, mandatory, moduleName, line);
 205             checkRefineMust(node, must, moduleName, line);
 206             checkRefineMinMax(name, min, max, moduleName, line);
 207         }
 208     }
 209
 210     private static void checkRefineDefault(final SchemaNodeBuilder node, final String defaultStr, final String moduleName, final int line) {
 211         if (defaultStr != null) {
 212             throw new YangParseException(moduleName, line, "Can not refine 'default' for '"
 213                     + node.getQName().getLocalName() + "'.");
 214         }
 215     }
 216
 217     private static void checkRefineMandatory(final SchemaNodeBuilder node, final Boolean mandatory, final String moduleName, final int line) {
 218         if (mandatory != null) {
 219             throw new YangParseException(moduleName, line, "Can not refine 'mandatory' for '"
 220                     + node.getQName().getLocalName() + "'.");
 221         }
 222     }
 223
 224     private static void checkRefinePresence(final SchemaNodeBuilder node, final Boolean presence, final String moduleName, final int line) {
 225         if (presence != null) {
 226             throw new YangParseException(moduleName, line, "Can not refine 'presence' for '"
 227                     + node.getQName().getLocalName() + "'.");
 228         }
 229     }
 230
 231     private static void checkRefineMust(final SchemaNodeBuilder node, final MustDefinition must, final String moduleName, final int line) {
 232         if (must != null) {
 233             throw new YangParseException(moduleName, line, "Can not refine 'must' for '"
 234                     + node.getQName().getLocalName() + "'.");
 235         }
 236     }
 237
 238     private static void checkRefineMinMax(final String refineTargetName, final Integer min, final Integer max, final String moduleName, final int line) {
 239         if (min != null || max != null) {
 240             throw new YangParseException(moduleName, line, "Can not refine 'min-elements' or 'max-elements' for '"
 241                     + refineTargetName + "'.");
 242         }
 243     }
 244
 245     /**
 246      * Perform refine operation of following parameters:
 247      * <ul>
 248      * <li>description</li>
 249      * <li>reference</li>
 250      * <li>config</li>
 251      * </ul>
 252      *
 253      * These parameters may be refined for any node.
 254      *
 255      * @param node
 256      *            node to refine
 257      * @param refine
 258      *            refine object containing information about refine process
 259      */
 260     private static void refineDefault(final Builder node, final RefineBuilder refine) {
 261         final String moduleName = refine.getModuleName();
 262         final int line = refine.getLine();
 263
 264
 265         final DocumentedNodeBuilder documentedNode;
 266         if(node instanceof DocumentedNodeBuilder) {
 267             documentedNode = ((DocumentedNodeBuilder) node);
 268         } else {
 269             documentedNode = null;
 270         }
 271
 272         String description = refine.getDescription();
 273
 274
 275         if (description != null) {
 276             if(documentedNode != null) {
 277                 documentedNode.setDescription(description);
 278             } else {
 279                 throw new YangParseException(moduleName, line, String.format("Cannot refine description in of target %s",refine.getTargetPathString()));
 280             }
 281
 282         }
 283
 284         String reference = refine.getReference();
 285         if (reference != null) {
 286             if(documentedNode != null) {
 287                 documentedNode.setReference(reference);
 288             } else {
 289                 throw new YangParseException(moduleName, line, String.format("Cannot refine reference in of target %s",refine.getTargetPathString()));
 290             }
 291         }
 292
 293         Boolean config = refine.isConfiguration();
 294         if (config != null) {
 295             if(node instanceof DataSchemaNodeBuilder) {
 296                 ((DataSchemaNodeBuilder) node).setConfiguration(config);
 297             } else {
 298                 throw new YangParseException(moduleName, line, String.format("Cannot refine config of target %s ",refine.getTargetPathString()));
 299             }
 300         }
 301     }
 302
 303     /**
 304      * Perform refine operation on given node.
 305      *
 306      * @param nodeToRefine
 307      *            builder of node to refine
 308      * @param refine
 309      *            refine object containing information about refine process
 310      */
 311     static void performRefine(final SchemaNodeBuilder nodeToRefine, final RefineBuilder refine) {
 312         checkRefine(nodeToRefine, refine);
 313         refineDefault(nodeToRefine, refine);
 314         if (nodeToRefine instanceof LeafSchemaNodeBuilder) {
 315             refineLeaf((LeafSchemaNodeBuilder) nodeToRefine, refine);
 316         } else if (nodeToRefine instanceof ContainerSchemaNodeBuilder) {
 317             refineContainer((ContainerSchemaNodeBuilder) nodeToRefine, refine);
 318         } else if (nodeToRefine instanceof ListSchemaNodeBuilder) {
 319             refineList((ListSchemaNodeBuilder) nodeToRefine, refine);
 320         } else if (nodeToRefine instanceof LeafListSchemaNodeBuilder) {
 321             refineLeafList((LeafListSchemaNodeBuilder) nodeToRefine, refine);
 322         } else if (nodeToRefine instanceof ChoiceBuilder) {
 323             refineChoice((ChoiceBuilder) nodeToRefine, refine);
 324         } else if (nodeToRefine instanceof AnyXmlBuilder) {
 325             refineAnyxml((AnyXmlBuilder) nodeToRefine, refine);
 326         }
 327     }
 328
 329 }