X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fyang-model-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fyang%2Fparser%2Futil%2FParserUtils.java;fp=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fyang-model-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fyang%2Fparser%2Futil%2FParserUtils.java;h=757c02c8a03280788964f118a6238a8086d17b0a;hp=0000000000000000000000000000000000000000;hb=8992ae54ecd2c79e0d93d0904962c5f32f3bb33a;hpb=e8c736d30bc80ba229a1b6d35802e05c2ffe3a78 diff --git a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/util/ParserUtils.java b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/util/ParserUtils.java new file mode 100644 index 0000000000..757c02c8a0 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/util/ParserUtils.java @@ -0,0 +1,301 @@ +/* + * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.yang.parser.util; + +import java.util.ArrayList; +import java.util.List; + +import org.opendaylight.controller.yang.common.QName; +import org.opendaylight.controller.yang.model.api.ModuleImport; +import org.opendaylight.controller.yang.model.api.MustDefinition; +import org.opendaylight.controller.yang.model.api.SchemaPath; +import org.opendaylight.controller.yang.model.api.TypeDefinition; +import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder; +import org.opendaylight.controller.yang.parser.builder.api.ChildNodeBuilder; +import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder; +import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder; +import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder; +import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.ChoiceCaseBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.ConstraintsBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder; +import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder; + +public final class ParserUtils { + + private ParserUtils() { + } + + /** + * Get module import referenced by given prefix. + * + * @param builder + * module to search + * @param prefix + * prefix associated with import + * @return ModuleImport based on given prefix + */ + public static ModuleImport getModuleImport(final ModuleBuilder builder, + final String prefix) { + ModuleImport moduleImport = null; + for (ModuleImport mi : builder.getModuleImports()) { + if (mi.getPrefix().equals(prefix)) { + moduleImport = mi; + break; + } + } + return moduleImport; + } + + /** + * Parse uses path. + * + * @param usesPath + * as String + * @return SchemaPath from given String + */ + public static SchemaPath parseUsesPath(final String usesPath) { + final boolean absolute = usesPath.startsWith("/"); + final String[] splittedPath = usesPath.split("/"); + final List path = new ArrayList(); + QName name; + for (String pathElement : splittedPath) { + if (pathElement.length() > 0) { + final String[] splittedElement = pathElement.split(":"); + if (splittedElement.length == 1) { + name = new QName(null, null, null, splittedElement[0]); + } else { + name = new QName(null, null, splittedElement[0], + splittedElement[1]); + } + path.add(name); + } + } + return new SchemaPath(path, absolute); + } + + /** + * Add all augment's child nodes to given target. + * + * @param augment + * @param target + */ + public static void fillAugmentTarget( + final AugmentationSchemaBuilder augment, + final ChildNodeBuilder target) { + for (DataSchemaNodeBuilder builder : augment.getChildNodes()) { + builder.setAugmenting(true); + correctPath(augment, target.getPath()); + target.addChildNode(builder); + } + } + + private static void correctPath(final ChildNodeBuilder node, + final SchemaPath parentSchemaPath) { + for(DataSchemaNodeBuilder builder : node.getChildNodes()) { + + // add correct path + SchemaPath targetNodeSchemaPath = parentSchemaPath; + List targetNodePath = new ArrayList(targetNodeSchemaPath.getPath()); + targetNodePath.add(builder.getQName()); + builder.setPath(new SchemaPath(targetNodePath, true)); + + if(builder instanceof ChildNodeBuilder) { + ChildNodeBuilder cnb = (ChildNodeBuilder)builder; + correctPath(cnb, builder.getPath()); + } + } + } + + public static LeafSchemaNodeBuilder copyLeafBuilder( + final LeafSchemaNodeBuilder old) { + final LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder( + old.getQName(), old.getLine()); + final TypeDefinition type = old.getType(); + + if (type == null) { + copy.setType(old.getTypedef()); + } else { + copy.setType(type); + } + copy.setPath(old.getPath()); + copyConstraints(old, copy); + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + copy.setDescription(old.getDescription()); + copy.setReference(old.getReference()); + copy.setStatus(old.getStatus()); + copy.setAugmenting(old.isAugmenting()); + copy.setConfiguration(old.isConfiguration()); + copy.setDefaultStr(old.getDefaultStr()); + copy.setUnits(old.getUnits()); + return copy; + } + + public static ContainerSchemaNodeBuilder copyContainerBuilder( + final ContainerSchemaNodeBuilder old) { + final ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder( + old.getQName(), old.getLine()); + copy.setPath(old.getPath()); + copyConstraints(old, copy); + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + for (DataSchemaNodeBuilder child : old.getChildNodes()) { + copy.addChildNode(child); + } + for (GroupingBuilder grouping : old.getGroupings()) { + copy.addGrouping(grouping); + } + for (TypeDefinitionBuilder typedef : old.getTypedefs()) { + copy.addTypedef(typedef); + } + for (AugmentationSchemaBuilder augment : old.getAugmentations()) { + copy.addAugmentation(augment); + } + for (UsesNodeBuilder use : old.getUsesNodes()) { + copy.addUsesNode(use); + } + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + copy.setDescription(old.getDescription()); + copy.setReference(old.getReference()); + copy.setStatus(old.getStatus()); + copy.setAugmenting(old.isAugmenting()); + copy.setConfiguration(old.isConfiguration()); + copy.setPresence(old.isPresence()); + return copy; + } + + public static ListSchemaNodeBuilder copyListBuilder( + final ListSchemaNodeBuilder old) { + final ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder( + old.getQName(), old.getLine()); + copy.setPath(old.getPath()); + copyConstraints(old, copy); + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + for (DataSchemaNodeBuilder child : old.getChildNodes()) { + copy.addChildNode(child); + } + for (GroupingBuilder grouping : old.getGroupings()) { + copy.addGrouping(grouping); + } + for (TypeDefinitionBuilder typedef : old.getTypedefs()) { + copy.addTypedef(typedef); + } + for (AugmentationSchemaBuilder augment : old.getAugmentations()) { + copy.addAugmentation(augment); + } + for (UsesNodeBuilder use : old.getUsesNodes()) { + copy.addUsesNode(use); + } + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + copy.setDescription(old.getDescription()); + copy.setReference(old.getReference()); + copy.setStatus(old.getStatus()); + copy.setAugmenting(old.isAugmenting()); + copy.setConfiguration(old.isConfiguration()); + copy.setUserOrdered(old.isUserOrdered()); + return copy; + } + + public static LeafListSchemaNodeBuilder copyLeafListBuilder( + final LeafListSchemaNodeBuilder old) { + final LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder( + old.getQName(), old.getLine()); + copy.setPath(old.getPath()); + copyConstraints(old, copy); + final TypeDefinition type = old.getType(); + if (type == null) { + copy.setType(old.getTypedef()); + } else { + copy.setType(type); + } + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + copy.setDescription(old.getDescription()); + copy.setReference(old.getReference()); + copy.setStatus(old.getStatus()); + copy.setAugmenting(old.isAugmenting()); + copy.setConfiguration(old.isConfiguration()); + copy.setUserOrdered(old.isUserOrdered()); + return copy; + } + + public static ChoiceBuilder copyChoiceBuilder(final ChoiceBuilder old) { + final ChoiceBuilder copy = new ChoiceBuilder(old.getQName(), old.getLine()); + copy.setPath(old.getPath()); + copyConstraints(old, copy); + for (ChoiceCaseBuilder caseBuilder : old.getCases()) { + copy.addChildNode(caseBuilder); + } + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + for (TypeDefinitionBuilder typedef : old.getTypedefs()) { + copy.addTypedef(typedef); + } + for (UsesNodeBuilder use : old.getUsesNodes()) { + copy.addUsesNode(use); + } + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + copy.setDefaultCase(old.getDefaultCase()); + copy.setDescription(old.getDescription()); + copy.setReference(old.getReference()); + copy.setStatus(old.getStatus()); + copy.setAugmenting(old.isAugmenting()); + copy.setConfiguration(old.isConfiguration()); + return copy; + } + + public static AnyXmlBuilder copyAnyXmlBuilder(final AnyXmlBuilder old) { + final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName(), old.getLine()); + copy.setPath(old.getPath()); + copyConstraints(old, copy); + for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) { + copy.addUnknownSchemaNode(unknown); + } + copy.setDescription(old.getDescription()); + copy.setReference(old.getReference()); + copy.setStatus(old.getStatus()); + copy.setConfiguration(old.isConfiguration()); + return copy; + } + + private static void copyConstraints(final DataSchemaNodeBuilder oldBuilder, + final DataSchemaNodeBuilder newBuilder) { + final ConstraintsBuilder oldConstraints = oldBuilder.getConstraints(); + final ConstraintsBuilder newConstraints = newBuilder.getConstraints(); + newConstraints.addWhenCondition(oldConstraints.getWhenCondition()); + for (MustDefinition must : oldConstraints.getMustDefinitions()) { + newConstraints.addMustDefinition(must); + } + newConstraints.setMandatory(oldConstraints.isMandatory()); + newConstraints.setMinElements(oldConstraints.getMinElements()); + newConstraints.setMaxElements(oldConstraints.getMaxElements()); + } + +}