From: Tony Tkacik Date: Tue, 17 Dec 2013 09:33:37 +0000 (+0000) Subject: Merge "Updated union builder template to throw an exception in getDefaultInstance... X-Git-Tag: yangtools-0.6.0~122 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=32f84d761384e639c22cdde386e1a8ef490fe23a;hp=54bde11bfd789d6b37c85986b38daddcf373cfd7;p=yangtools.git Merge "Updated union builder template to throw an exception in getDefaultInstance instead of returning null." --- diff --git a/code-generator/.gitignore b/code-generator/.gitignore index acda8836ce..e3b94d9175 100644 --- a/code-generator/.gitignore +++ b/code-generator/.gitignore @@ -1,2 +1,3 @@ /.settings /binding-java-api-generator/src/main/xtend-gen +/maven-sal-api-gen-plugin/src/main/xtend-gen diff --git a/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/yangtools/sal/java/api/generator/BaseTemplate.xtend b/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/yangtools/sal/java/api/generator/BaseTemplate.xtend index b9118ac0f5..99a1968714 100644 --- a/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/yangtools/sal/java/api/generator/BaseTemplate.xtend +++ b/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/yangtools/sal/java/api/generator/BaseTemplate.xtend @@ -279,15 +279,6 @@ abstract class BaseTemplate { return null; } - def GeneratedProperty getPropByName(Collection props, String name) { - for (GeneratedProperty prop : props) { - if (prop.name.equals(name)) { - return prop; - } - } - return null; - } - def getRestrictions(Type type) { var Restrictions restrictions = null if (type instanceof ConcreteType) { diff --git a/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/unified/doc/generator/GeneratorImpl.xtend b/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/unified/doc/generator/GeneratorImpl.xtend index 3bfc2f3d59..e7323720b2 100644 --- a/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/unified/doc/generator/GeneratorImpl.xtend +++ b/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/unified/doc/generator/GeneratorImpl.xtend @@ -208,6 +208,7 @@ class GeneratorImpl {
  • augment «augment.augmentationInfo(InstanceIdentifier.builder().toInstance())» + «augment.childNodes.printChildren(2,InstanceIdentifier.builder().toInstance())»
    • «ENDFOR» @@ -353,6 +354,7 @@ class GeneratorImpl { val leafNodes = nodes.filter(LeafSchemaNode) val leafListNodes = nodes.filter(LeafListSchemaNode) val choices = nodes.filter(ChoiceNode) + val cases = nodes.filter(ChoiceCaseNode) val containers = nodes.filter(ContainerSchemaNode) val lists = nodes.filter(ListSchemaNode) return ''' @@ -383,6 +385,12 @@ class GeneratorImpl { «FOR childNode : lists» «childNode.printInfo(level,path)» «ENDFOR» + «FOR childNode : choices» + «childNode.printInfo(level,path)» + «ENDFOR» + «FOR childNode : cases» + «childNode.printInfo(level,path)» + «ENDFOR» ''' } @@ -466,7 +474,16 @@ class GeneratorImpl { «node.childNodes.printChildren(level,newPath)» ''' - + + private def dispatch CharSequence printInfo(ChoiceNode node, int level, InstanceIdentifier path) ''' + «val Set choiceCases = new HashSet(node.cases)» + «choiceCases.printChildren(level,path)» + ''' + + private def dispatch CharSequence printInfo(ChoiceCaseNode node, int level, InstanceIdentifier path) ''' + «node.childNodes.printChildren(level,path)» + ''' + def CharSequence printShortInfo(ContainerSchemaNode node, int level, InstanceIdentifier path) { val newPath = path.append(node); return ''' @@ -492,7 +509,7 @@ class GeneratorImpl {
  • «strong((node.QName.localName))» (leaf-list)
    • ''' } - + def CharSequence localLink(InstanceIdentifier identifier, CharSequence text) ''' «text» ''' diff --git a/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/wadl/generator/WadlRestconfGenerator.xtend b/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/wadl/generator/WadlRestconfGenerator.xtend new file mode 100644 index 0000000000..18cd6d8562 --- /dev/null +++ b/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/wadl/generator/WadlRestconfGenerator.xtend @@ -0,0 +1,256 @@ +package org.opendaylight.yangtools.yang.wadl.generator + +import java.io.BufferedWriter +import java.io.File +import java.io.OutputStreamWriter +import java.util.ArrayList +import java.util.HashSet +import java.util.List +import java.util.Set +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode +import org.opendaylight.yangtools.yang.model.api.DataNodeContainer +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode +import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode +import org.opendaylight.yangtools.yang.model.api.ListSchemaNode +import org.opendaylight.yangtools.yang.model.api.Module +import org.opendaylight.yangtools.yang.model.api.SchemaContext +import org.sonatype.plexus.build.incremental.BuildContext +import org.sonatype.plexus.build.incremental.DefaultBuildContext + +class WadlRestconfGenerator { + + File path + static val BuildContext CTX = new DefaultBuildContext(); + var SchemaContext context; + var List configData; + var List operationalData; + var Module module; + var List pathListParams; + val PATH_DELIMETER = "/" + + new(File targetPath) { + if (!targetPath.exists) targetPath.mkdirs + path = targetPath + } + + def generate(SchemaContext context, Set modules) { + val result = new HashSet; + this.context = context + for (module : modules) { + val dataContainers = module.childNodes.filter[it|it instanceof ContainerSchemaNode || it instanceof ListSchemaNode] + if (!dataContainers.empty) { + configData = new ArrayList + operationalData = new ArrayList + + for (data : dataContainers) { + if (data.configuration) { + configData.add(data) + } else { + operationalData.add(data) + } + } + + this.module = module + val destination = new File(path, '''«module.name».wadl''') + val fw = new OutputStreamWriter(CTX.newFileOutputStream(destination)) + val bw = new BufferedWriter(fw) + bw.append(application); + bw.close(); + fw.close(); + result.add(destination) + } + } + return result + } + + private def application() ''' + + + + «grammars» + + «resources» + + ''' + + private def importsAsNamespaces(Module module) ''' + «FOR imprt : module.imports» + xmlns:«imprt.prefix»="«context.findModuleByName(imprt.moduleName, imprt.revision).namespace»" + «ENDFOR» + ''' + + private def grammars() ''' + + + «FOR imprt : module.imports» + + «ENDFOR» + + ''' + + private def resources() ''' + + «resourceOperational» + «resourceConfig» + «resourceOperations» + + ''' + + private def resourceOperational() ''' + «IF !operationalData.nullOrEmpty» + + «FOR schemaNode : operationalData» + «schemaNode.firstResource(false)» + «ENDFOR» + + «ENDIF» + ''' + + private def resourceConfig() ''' + «IF !configData.nullOrEmpty» + + «FOR schemaNode : configData» + «schemaNode.firstResource(true)» + «ENDFOR» + + «ENDIF» + ''' + + private def resourceOperations() ''' + «IF !module.rpcs.nullOrEmpty» + + «FOR rpc : module.rpcs» + + «methodPostRpc(rpc.input != null, rpc.output !== null)» + + «ENDFOR» + + «ENDIF» + ''' + + private def String firstResource(DataSchemaNode schemaNode, boolean config) ''' + + «IF !pathListParams.nullOrEmpty» + «resourceParams» + «ENDIF» + «schemaNode.methodGet» + «IF config» + «schemaNode.mehodPut» + «schemaNode.mehodPost» + «ENDIF» + + «IF schemaNode instanceof DataNodeContainer» + «val children = (schemaNode as DataNodeContainer).childNodes.filter[it|it instanceof ContainerSchemaNode || it instanceof ListSchemaNode]» + «IF !children.empty» + «FOR child : children» + «child.resource(config)» + «ENDFOR» + «ENDIF» + «ENDIF» + + ''' + + private def String resource(DataSchemaNode schemaNode, boolean config) ''' + + «IF !pathListParams.nullOrEmpty» + «resourceParams» + «ENDIF» + «schemaNode.methodGet» + «IF config» + «schemaNode.mehodPut» + «schemaNode.mehodPost» + «ENDIF» + + «IF schemaNode instanceof DataNodeContainer» + «val children = (schemaNode as DataNodeContainer).childNodes.filter[it|it instanceof ContainerSchemaNode || it instanceof ListSchemaNode]» + «IF !children.empty» + «FOR child : children» + «child.resource(config)» + «ENDFOR» + «ENDIF» + «ENDIF» + + ''' + + private def String createPath(DataSchemaNode schemaNode) { + pathListParams = new ArrayList + var StringBuilder path = new StringBuilder + path.append(schemaNode.QName.localName) + if (schemaNode instanceof ListSchemaNode) { + val listKeys = (schemaNode as ListSchemaNode).keyDefinition + for (listKey : listKeys) { + pathListParams.add((schemaNode as DataNodeContainer).getDataChildByName(listKey) as LeafSchemaNode) + path.append(PATH_DELIMETER + "{" + listKey.localName + "}") + } + } + return path.toString + } + + private def resourceParams() ''' + «FOR pathParam : pathListParams» + «val prefix = pathParam.type.QName.prefix» + «val type = if (prefix.nullOrEmpty) pathParam.type.QName.localName else prefix + ":" + pathParam.type.QName.localName» + + «ENDFOR» + ''' + + private def methodGet(DataSchemaNode schemaNode) ''' + + + + + + + + + + ''' + + private def mehodPut(DataSchemaNode schemaNode) ''' + + + + + + + + + + ''' + + private def mehodPost(DataSchemaNode schemaNode) ''' + + + + + + + + + + ''' + + private def methodPostRpc(boolean input, boolean output) ''' + + «IF input» + + + + + + + + «ENDIF» + «IF output» + + + + + + + + «ENDIF» + + ''' + +} diff --git a/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/wadl/generator/maven/WadlGenerator.java b/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/wadl/generator/maven/WadlGenerator.java new file mode 100644 index 0000000000..a10c50964b --- /dev/null +++ b/code-generator/maven-sal-api-gen-plugin/src/main/java/org/opendaylight/yangtools/yang/wadl/generator/maven/WadlGenerator.java @@ -0,0 +1,58 @@ +package org.opendaylight.yangtools.yang.wadl.generator.maven; + +import java.io.File; +import java.io.IOException; +import java.util.Collection; +import java.util.Map; +import java.util.Set; + +import org.apache.maven.plugin.logging.Log; +import org.apache.maven.project.MavenProject; +import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.wadl.generator.WadlRestconfGenerator; +import org.opendaylight.yangtools.yang2sources.spi.CodeGenerator; + +public class WadlGenerator implements CodeGenerator { + + @Override + public Collection generateSources(SchemaContext context, File outputDir, Set currentModules) + throws IOException { + + final File outputBaseDir; + if (outputDir == null) { + outputBaseDir = new File("target" + File.separator + "generated-sources" + File.separator + + "maven-sal-api-gen" + File.separator + "wadl"); + } else { + outputBaseDir = outputDir; + } + + final WadlRestconfGenerator generator = new WadlRestconfGenerator(outputBaseDir); + return generator.generate(context, currentModules); + } + + @Override + public void setLog(Log log) { + // TODO Auto-generated method stub + + } + + @Override + public void setAdditionalConfig(Map additionalConfiguration) { + // TODO Auto-generated method stub + + } + + @Override + public void setResourceBaseDir(File resourceBaseDir) { + // TODO Auto-generated method stub + + } + + @Override + public void setMavenProject(MavenProject project) { + // TODO Auto-generated method stub + + } + +} diff --git a/code-generator/maven-sal-api-gen-plugin/src/test/java/org/opendaylight/yangtools/yang/wadl/generator/maven/WadlGenTest.java b/code-generator/maven-sal-api-gen-plugin/src/test/java/org/opendaylight/yangtools/yang/wadl/generator/maven/WadlGenTest.java new file mode 100644 index 0000000000..11c5ad7060 --- /dev/null +++ b/code-generator/maven-sal-api-gen-plugin/src/test/java/org/opendaylight/yangtools/yang/wadl/generator/maven/WadlGenTest.java @@ -0,0 +1,81 @@ +package org.opendaylight.yangtools.yang.wadl.generator.maven; + +import static org.junit.Assert.assertTrue; + +import java.io.File; +import java.io.FileNotFoundException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Set; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl; +import org.opendaylight.yangtools.yang2sources.spi.CodeGenerator; + +public class WadlGenTest { + public static final String FS = File.separator; + private static final String TEST_PATH = "target" + FS + "test" + FS + "site"; + private static final File GENERATOR_OUTPUT_DIR = new File(TEST_PATH); + private YangParserImpl parser; + + @Before + public void init() { + if (GENERATOR_OUTPUT_DIR.exists()) { + deleteTestDir(GENERATOR_OUTPUT_DIR); + } + assertTrue(GENERATOR_OUTPUT_DIR.mkdirs()); + parser = new YangParserImpl(); + } + + @After + public void cleanUp() { + if (GENERATOR_OUTPUT_DIR.exists()) { + deleteTestDir(GENERATOR_OUTPUT_DIR); + } + } + + @Test + public void testListGeneration() throws Exception { + final List sourceFiles = getSourceFiles("/wadl-gen"); + final Set modulesToBuild = parser.parseYangModels(sourceFiles); + final SchemaContext context = parser.resolveSchemaContext(modulesToBuild); + final CodeGenerator generator = new WadlGenerator(); + generator.generateSources(context, GENERATOR_OUTPUT_DIR, modulesToBuild); + } + + private static List getSourceFiles(String path) throws FileNotFoundException { + final String resPath = WadlGenTest.class.getResource(path).getPath(); + final File sourcesDir = new File(resPath); + if (sourcesDir.exists()) { + final List sourceFiles = new ArrayList<>(); + final File[] fileArray = sourcesDir.listFiles(); + if (fileArray == null) { + throw new IllegalArgumentException("Unable to locate files in " + sourcesDir); + } + sourceFiles.addAll(Arrays.asList(fileArray)); + return sourceFiles; + } else { + throw new FileNotFoundException("Testing files were not found(" + sourcesDir.getName() + ")"); + } + } + + private static void deleteTestDir(File file) { + if (file.isDirectory()) { + File[] filesToDelete = file.listFiles(); + if (filesToDelete != null) { + for (File f : filesToDelete) { + deleteTestDir(f); + } + } + } + if (!file.delete()) { + throw new RuntimeException("Failed to clean up after test"); + } + } + +} diff --git a/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/controller-network.yang b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/controller-network.yang new file mode 100644 index 0000000000..a8693bbce1 --- /dev/null +++ b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/controller-network.yang @@ -0,0 +1,193 @@ +module controller-network { + yang-version 1; + namespace "urn:opendaylight:controller:network"; + prefix "topos"; + + import ietf-inet-types { prefix "inet"; } + + revision 2013-05-20 { + description "Initial demo"; + } + + + + + typedef topology-id { + type string; + } + + typedef node-id { + type string; + } + + typedef link-id { + type string; + } + + typedef tp-id { + type string; + description "identifier for termination points on a port"; + } + + typedef tp-ref { + type leafref { + path "/network/topologies/topology/nodes/node/termination-points/termination-point/tp-id"; + } + } + typedef topology-ref { + type leafref { + path "/network/topologies/topology/topology-id"; + } + description "This type is used for leafs that reference topology identifier instance."; + // currently not used + } + + typedef node-ref { + type leafref { + path "/network/topologies/topology/nodes/node/node-id"; + } + description "This type is used for leafs that reference a node instance."; + } + + typedef link-ref { + type leafref { + path "/network/topologies/topology/links/link/link-id"; + } + description "This type is used for leafs that reference a link instance."; + // currently not used + } + + typedef network-element-ref { + type leafref { + path "/network/network-elements/network-element/element-id"; + } + } + + + typedef element-id { + type string; + } + + container network { + container topologies { + list topology { + description " + This is the model of abstract topology which contains only Network + Nodes and Network Links. Each topology MUST be identified by + unique topology-id for reason that the store could contain many + topologies. + "; + key "topology-id"; + leaf topology-id { + type topology-id; + description " + It is presumed that datastore will contain many topologies. To + distinguish between topologies it is vital to have UNIQUE + topology identifier. + "; + } + + container types { + description " + The container for definition of topology types. + The augmenting modules should add empty optional leaf + to this container to signalize topology type. + "; + } + + container nodes { + list node { + description "The list of network nodes defined for topology."; + + key "node-id"; + leaf node-id { + type node-id; + description "The Topology identifier of network-node."; + } + + leaf supporting-ne { + type network-element-ref; + } + + container termination-points { + list termination-point { + key "tp-id"; + leaf tp-id { + type tp-id; + } + } + } + } + } + + container links { + list link { + description " + The Network Link which is defined by Local (Source) and + Remote (Destination) Network Nodes. Every link MUST be + defined either by identifier and his local and remote + Network Nodes (in real applications it is common that many + links are originated from one node and end up in same + remote node). To ensure that we would always know to + distinguish between links, every link SHOULD have + identifier. + "; + key "link-id"; + + leaf link-id { + type link-id; + } + container source { + leaf source-node { + type node-ref; + description "Source node identifier."; + } + leaf source-tp { + type tp-ref; + } + } + container destination { + leaf dest-node { + type node-ref; + description "Destination node identifier."; + } + leaf dest-tp { + type tp-ref; + } + } + } + } + } + } + container network-elements { + config true; + list network-element { + key "element-id"; + leaf element-id { + type element-id; + } + } + } + } + + rpc activate-software-image { + input { + leaf image-name { + type string; + } + } + output { + leaf status { + type string; + } + } + } + + rpc rock-the-house { + input { + leaf zip-code { + type string; + } + } + } +} diff --git a/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/controller-openflow.yang b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/controller-openflow.yang new file mode 100644 index 0000000000..62e937e92b --- /dev/null +++ b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/controller-openflow.yang @@ -0,0 +1,79 @@ +module controller-openflow { + + namespace "urn:opendaylight:controller:openflow"; + prefix "of"; + import controller-network {prefix cn;} + + + revision 2013-05-20 { + description "Initial demo"; + } + + + + + + typedef datapath-id { + type string { + length 16; + } + } + + + augment "/cn:network/cn:topologies/cn:topology/cn:types" { + leaf openflow {type string;} + } + + augment "/cn:network/cn:topologies/cn:topology/cn:links/cn:link/cn:source" { + when "../../../cn:types/of:openflow"; + + leaf logical-port { + type int32; + } + } + + augment "/cn:network/cn:topologies/cn:topology/cn:links/cn:link/cn:destination" { + when "../../../cn:types/of:openflow"; + + leaf logical-port { + type int32; + } + } + + augment "/cn:network/cn:topologies/cn:topology/cn:nodes/cn:node/" { + when "../../../cn:types/of:openflow"; + leaf datapath-id { + type datapath-id; + } + } + + augment "/cn:network/cn:network-elements/cn:network-element" { + leaf datapath-id { + type datapath-id; + } + + container ports { + list port { + key "logical-port-id"; + + leaf logical-port-id { + type int32; + } + + // Should be replaced with ref to interface + leaf physical-name { + type string; + } + } + } + container flow-tables { + list flow-table { + key "flow-table-id"; + leaf flow-table-id { + type string; + } + + } + } + } +} \ No newline at end of file diff --git a/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/demo-topology.yang b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/demo-topology.yang new file mode 100644 index 0000000000..4fef1cddd2 --- /dev/null +++ b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/demo-topology.yang @@ -0,0 +1,121 @@ +module demo-topology { + yang-version 1; + namespace "urn:model.1demo-275topology.4.5.my"; + prefix "tp"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + description " + This module contains the definitions of elements that creates network + topology i.e. definition of network nodes and links. This module is + not designed to be used solely for network representation. This module + SHOULD be used as base module in defining the network topology. + "; + + revision "2013-02-08"{ + reference " WILL BE DEFINED LATER"; + } + + container topology { + description " + This is the model of abstract topology which contains only Network + Nodes and Network Links. Each topology MUST be identified by + unique topology-id for reason that the store could contain many + topologies. + "; + + leaf topology-id { + type string; + description " + It is presumed that datastore will contain many topologies. To + distinguish between topologies it is vital to have UNIQUE + topology identifier. + "; + } + + container network-nodes { + list network-node { + description "The list of network nodes defined for topology."; + + key "node-id"; + + leaf node-id { + type string; + description "The Topology identifier of network-node."; + } + + list network-interface { + key "interface-id"; + + leaf interface-id { + type uint8; + } + + leaf interface-address { + type string; + } + } + + container node-attributes { + description " + Additional attributes that can Network Node contains. + "; + + leaf geo-latitude { + type decimal64 { + fraction-digits 2; + } + config true; + } + + leaf geo-longitude { + type decimal64 { + fraction-digits 2; + } + config true; + } + } + } + } + + container network-links { + list network-link { + description " + The Network Link which is defined by Local (Source) and + Remote (Destination) Network Nodes. Every link MUST be + defined either by identifier and his local and remote + Network Nodes (in real applications it is common that many + links are originated from one node and end up in same + remote node). To ensure that we would always know to + distinguish between links, every link SHOULD have + identifier. + "; + key "link-id"; + + leaf link-id { + type string; + description ""; + } + + container source { + leaf node-id { + type string; + description "Source node identifier."; + } + } + + container destination { + leaf node-id { + type string; + description "Destination node identifier."; + } + } + + container link-attributes { + description "Aditional attributes that can Network Link contains."; + } + } + } + } +} \ No newline at end of file diff --git a/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/ietf-inet-types@2010-09-24.yang b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/ietf-inet-types@2010-09-24.yang new file mode 100644 index 0000000000..de20febbb7 --- /dev/null +++ b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/ietf-inet-types@2010-09-24.yang @@ -0,0 +1,418 @@ + module ietf-inet-types { + + namespace "urn:ietf:params:xml:ns:yang:ietf-inet-types"; + prefix "inet"; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Partain + + + WG Chair: David Kessens + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types for Internet addresses and related things. + + Copyright (c) 2010 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, is permitted pursuant to, and subject to the license + terms contained in, the Simplified BSD License set forth in Section + 4.c of the IETF Trust's Legal Provisions Relating to IETF Documents + (http://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 6021; see + the RFC itself for full legal notices."; + + revision 2010-09-24 { + description + "Initial revision."; + reference + "RFC 6021: Common YANG Data Types"; + } + + /*** collection of protocol field related types ***/ + + typedef ip-version { + type enumeration { + enum unknown { + value "0"; + description + "An unknown or unspecified version of the Internet protocol."; + } + enum ipv4 { + value "1"; + description + "The IPv4 protocol as defined in RFC 791."; + } + enum ipv6 { + value "2"; + description + "The IPv6 protocol as defined in RFC 2460."; + } + } + description + "This value represents the version of the IP protocol. + + In the value set and its semantics, this type is equivalent + to the InetVersion textual convention of the SMIv2."; + reference + "RFC 791: Internet Protocol + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + typedef dscp { + type uint8 { + range "0..63"; + } + description + "The dscp type represents a Differentiated Services Code-Point + that may be used for marking packets in a traffic stream. + + In the value set and its semantics, this type is equivalent + to the Dscp textual convention of the SMIv2."; + reference + "RFC 3289: Management Information Base for the Differentiated + Services Architecture + RFC 2474: Definition of the Differentiated Services Field + (DS Field) in the IPv4 and IPv6 Headers + RFC 2780: IANA Allocation Guidelines For Values In + the Internet Protocol and Related Headers"; + } + + typedef ipv6-flow-label { + type uint32 { + range "0..1048575"; + } + description + "The flow-label type represents flow identifier or Flow Label + in an IPv6 packet header that may be used to discriminate + traffic flows. + + In the value set and its semantics, this type is equivalent + to the IPv6FlowLabel textual convention of the SMIv2."; + reference + "RFC 3595: Textual Conventions for IPv6 Flow Label + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification"; + } + + typedef port-number { + type uint16 { + range "0..65535"; + } + description + "The port-number type represents a 16-bit port number of an + Internet transport layer protocol such as UDP, TCP, DCCP, or + SCTP. Port numbers are assigned by IANA. A current list of + all assignments is available from . + + Note that the port number value zero is reserved by IANA. In + situations where the value zero does not make sense, it can + be excluded by subtyping the port-number type. + + In the value set and its semantics, this type is equivalent + to the InetPortNumber textual convention of the SMIv2."; + reference + "RFC 768: User Datagram Protocol + RFC 793: Transmission Control Protocol + RFC 4960: Stream Control Transmission Protocol + RFC 4340: Datagram Congestion Control Protocol (DCCP) + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + /*** collection of autonomous system related types ***/ + + typedef as-number { + type uint32; + description + "The as-number type represents autonomous system numbers + which identify an Autonomous System (AS). An AS is a set + of routers under a single technical administration, using + an interior gateway protocol and common metrics to route + packets within the AS, and using an exterior gateway + protocol to route packets to other ASs'. IANA maintains + the AS number space and has delegated large parts to the + regional registries. + + Autonomous system numbers were originally limited to 16 + bits. BGP extensions have enlarged the autonomous system + number space to 32 bits. This type therefore uses an uint32 + base type without a range restriction in order to support + a larger autonomous system number space. + + In the value set and its semantics, this type is equivalent + to the InetAutonomousSystemNumber textual convention of + the SMIv2."; + reference + "RFC 1930: Guidelines for creation, selection, and registration + of an Autonomous System (AS) + RFC 4271: A Border Gateway Protocol 4 (BGP-4) + RFC 4893: BGP Support for Four-octet AS Number Space + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + /*** collection of IP address and hostname related types ***/ + + typedef ip-address { + type union { + type inet:ipv4-address; + type inet:ipv6-address; + } + description + "The ip-address type represents an IP address and is IP + version neutral. The format of the textual representations + implies the IP version."; + } + + typedef ipv4-address { + type string { + pattern + '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}' + + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])' + + '(%[\p{N}\p{L}]+)?'; + } + description + "The ipv4-address type represents an IPv4 address in + dotted-quad notation. The IPv4 address may include a zone + index, separated by a % sign. + + The zone index is used to disambiguate identical address + values. For link-local addresses, the zone index will + typically be the interface index number or the name of an + interface. If the zone index is not present, the default + zone of the device will be used. + + The canonical format for the zone index is the numerical + format"; + } + + typedef ipv6-address { + type string { + pattern '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}' + + '((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|' + + '(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}' + + '(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))' + + '(%[\p{N}\p{L}]+)?'; + pattern '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|' + + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)' + + '(%.+)?'; + } + description + "The ipv6-address type represents an IPv6 address in full, + mixed, shortened, and shortened-mixed notation. The IPv6 + address may include a zone index, separated by a % sign. + + The zone index is used to disambiguate identical address + values. For link-local addresses, the zone index will + typically be the interface index number or the name of an + interface. If the zone index is not present, the default + zone of the device will be used. + + The canonical format of IPv6 addresses uses the compressed + format described in RFC 4291, Section 2.2, item 2 with the + following additional rules: the :: substitution must be + applied to the longest sequence of all-zero 16-bit chunks + in an IPv6 address. If there is a tie, the first sequence + of all-zero 16-bit chunks is replaced by ::. Single + all-zero 16-bit chunks are not compressed. The canonical + format uses lowercase characters and leading zeros are + not allowed. The canonical format for the zone index is + the numerical format as described in RFC 4007, Section + 11.2."; + reference + "RFC 4291: IP Version 6 Addressing Architecture + RFC 4007: IPv6 Scoped Address Architecture + RFC 5952: A Recommendation for IPv6 Address Text Representation"; + } + + typedef ip-prefix { + type union { + type inet:ipv4-prefix; + type inet:ipv6-prefix; + } + description + "The ip-prefix type represents an IP prefix and is IP + version neutral. The format of the textual representations + implies the IP version."; + } + + typedef ipv4-prefix { + type string { + pattern + '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}' + + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])' + + '/(([0-9])|([1-2][0-9])|(3[0-2]))'; + } + description + "The ipv4-prefix type represents an IPv4 address prefix. + The prefix length is given by the number following the + slash character and must be less than or equal to 32. + + A prefix length value of n corresponds to an IP address + mask that has n contiguous 1-bits from the most + significant bit (MSB) and all other bits set to 0. + + The canonical format of an IPv4 prefix has all bits of + the IPv4 address set to zero that are not part of the + IPv4 prefix."; + } + + typedef ipv6-prefix { + type string { + pattern '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}' + + '((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|' + + '(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}' + + '(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))' + + '(/(([0-9])|([0-9]{2})|(1[0-1][0-9])|(12[0-8])))'; + pattern '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|' + + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)' + + '(/.+)'; + } + description + "The ipv6-prefix type represents an IPv6 address prefix. + The prefix length is given by the number following the + slash character and must be less than or equal 128. + + A prefix length value of n corresponds to an IP address + mask that has n contiguous 1-bits from the most + significant bit (MSB) and all other bits set to 0. + + The IPv6 address should have all bits that do not belong + to the prefix set to zero. + + The canonical format of an IPv6 prefix has all bits of + the IPv6 address set to zero that are not part of the + IPv6 prefix. Furthermore, IPv6 address is represented + in the compressed format described in RFC 4291, Section + 2.2, item 2 with the following additional rules: the :: + substitution must be applied to the longest sequence of + all-zero 16-bit chunks in an IPv6 address. If there is + a tie, the first sequence of all-zero 16-bit chunks is + replaced by ::. Single all-zero 16-bit chunks are not + compressed. The canonical format uses lowercase + characters and leading zeros are not allowed."; + reference + "RFC 4291: IP Version 6 Addressing Architecture"; + } + + /*** collection of domain name and URI types ***/ + + typedef domain-name { + type string { + pattern '((([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.)*' + + '([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.?)' + + '|\.'; + length "1..253"; + } + description + "The domain-name type represents a DNS domain name. The + name SHOULD be fully qualified whenever possible. + + Internet domain names are only loosely specified. Section + 3.5 of RFC 1034 recommends a syntax (modified in Section + 2.1 of RFC 1123). The pattern above is intended to allow + for current practice in domain name use, and some possible + future expansion. It is designed to hold various types of + domain names, including names used for A or AAAA records + (host names) and other records, such as SRV records. Note + that Internet host names have a stricter syntax (described + in RFC 952) than the DNS recommendations in RFCs 1034 and + 1123, and that systems that want to store host names in + schema nodes using the domain-name type are recommended to + adhere to this stricter standard to ensure interoperability. + + The encoding of DNS names in the DNS protocol is limited + to 255 characters. Since the encoding consists of labels + prefixed by a length bytes and there is a trailing NULL + byte, only 253 characters can appear in the textual dotted + notation. + + The description clause of schema nodes using the domain-name + type MUST describe when and how these names are resolved to + IP addresses. Note that the resolution of a domain-name value + may require to query multiple DNS records (e.g., A for IPv4 + and AAAA for IPv6). The order of the resolution process and + which DNS record takes precedence can either be defined + explicitely or it may depend on the configuration of the + resolver. + + Domain-name values use the US-ASCII encoding. Their canonical + format uses lowercase US-ASCII characters. Internationalized + domain names MUST be encoded in punycode as described in RFC + 3492"; + reference + "RFC 952: DoD Internet Host Table Specification + RFC 1034: Domain Names - Concepts and Facilities + RFC 1123: Requirements for Internet Hosts -- Application + and Support + RFC 2782: A DNS RR for specifying the location of services + (DNS SRV) + RFC 3492: Punycode: A Bootstring encoding of Unicode for + Internationalized Domain Names in Applications + (IDNA) + RFC 5891: Internationalizing Domain Names in Applications + (IDNA): Protocol"; + } + + typedef host { + type union { + type inet:ip-address; + type inet:domain-name; + } + description + "The host type represents either an IP address or a DNS + domain name."; + } + + typedef uri { + type string; + description + "The uri type represents a Uniform Resource Identifier + (URI) as defined by STD 66. + + Objects using the uri type MUST be in US-ASCII encoding, + and MUST be normalized as described by RFC 3986 Sections + 6.2.1, 6.2.2.1, and 6.2.2.2. All unnecessary + percent-encoding is removed, and all case-insensitive + characters are set to lowercase except for hexadecimal + digits, which are normalized to uppercase as described in + Section 6.2.2.1. + + The purpose of this normalization is to help provide + unique URIs. Note that this normalization is not + sufficient to provide uniqueness. Two URIs that are + textually distinct after this normalization may still be + equivalent. + + Objects using the uri type may restrict the schemes that + they permit. For example, 'data:' and 'urn:' schemes + might not be appropriate. + + A zero-length URI is not a valid URI. This can be used to + express 'URI absent' where required. + + In the value set and its semantics, this type is equivalent + to the Uri SMIv2 textual convention defined in RFC 5017."; + reference + "RFC 3986: Uniform Resource Identifier (URI): Generic Syntax + RFC 3305: Report from the Joint W3C/IETF URI Planning Interest + Group: Uniform Resource Identifiers (URIs), URLs, + and Uniform Resource Names (URNs): Clarifications + and Recommendations + RFC 5017: MIB Textual Conventions for Uniform Resource + Identifiers (URIs)"; + } + + } diff --git a/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/ietf-yang-types@2010-09-24.yang b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/ietf-yang-types@2010-09-24.yang new file mode 100644 index 0000000000..51d9f8b887 --- /dev/null +++ b/code-generator/maven-sal-api-gen-plugin/src/test/resources/wadl-gen/ietf-yang-types@2010-09-24.yang @@ -0,0 +1,396 @@ + module ietf-yang-types { + + namespace "urn:ietf:params:xml:ns:yang:ietf-yang-types"; + prefix "yang"; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Partain + + + WG Chair: David Kessens + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types. + + Copyright (c) 2010 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, is permitted pursuant to, and subject to the license + terms contained in, the Simplified BSD License set forth in Section + 4.c of the IETF Trust's Legal Provisions Relating to IETF Documents + (http://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 6021; see + the RFC itself for full legal notices."; + + revision 2010-09-24 { + description + "Initial revision."; + reference + "RFC 6021: Common YANG Data Types"; + } + + /*** collection of counter and gauge types ***/ + + typedef counter32 { + type uint32; + description + "The counter32 type represents a non-negative integer + that monotonically increases until it reaches a + maximum value of 2^32-1 (4294967295 decimal), when it + wraps around and starts increasing again from zero. + + Counters have no defined 'initial' value, and thus, a + single value of a counter has (in general) no information + content. Discontinuities in the monotonically increasing + value normally occur at re-initialization of the + management system, and at other times as specified in the + description of a schema node using this type. If such + other times can occur, for example, the creation of + a schema node of type counter32 at times other than + re-initialization, then a corresponding schema node + should be defined, with an appropriate type, to indicate + the last discontinuity. + + The counter32 type should not be used for configuration + schema nodes. A default statement SHOULD NOT be used in + combination with the type counter32. + + In the value set and its semantics, this type is equivalent + to the Counter32 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + typedef zero-based-counter32 { + type yang:counter32; + default "0"; + description + "The zero-based-counter32 type represents a counter32 + that has the defined 'initial' value zero. + + A schema node of this type will be set to zero (0) on creation + and will thereafter increase monotonically until it reaches + a maximum value of 2^32-1 (4294967295 decimal), when it + wraps around and starts increasing again from zero. + + Provided that an application discovers a new schema node + of this type within the minimum time to wrap, it can use the + 'initial' value as a delta. It is important for a management + station to be aware of this minimum time and the actual time + between polls, and to discard data if the actual time is too + long or there is no defined minimum time. + + In the value set and its semantics, this type is equivalent + to the ZeroBasedCounter32 textual convention of the SMIv2."; + reference + "RFC 4502: Remote Network Monitoring Management Information + Base Version 2"; + } + + typedef counter64 { + type uint64; + description + "The counter64 type represents a non-negative integer + that monotonically increases until it reaches a + maximum value of 2^64-1 (18446744073709551615 decimal), + when it wraps around and starts increasing again from zero. + + Counters have no defined 'initial' value, and thus, a + single value of a counter has (in general) no information + content. Discontinuities in the monotonically increasing + value normally occur at re-initialization of the + management system, and at other times as specified in the + description of a schema node using this type. If such + other times can occur, for example, the creation of + a schema node of type counter64 at times other than + re-initialization, then a corresponding schema node + should be defined, with an appropriate type, to indicate + the last discontinuity. + + The counter64 type should not be used for configuration + schema nodes. A default statement SHOULD NOT be used in + combination with the type counter64. + + In the value set and its semantics, this type is equivalent + to the Counter64 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + typedef zero-based-counter64 { + type yang:counter64; + default "0"; + description + "The zero-based-counter64 type represents a counter64 that + has the defined 'initial' value zero. + + A schema node of this type will be set to zero (0) on creation + and will thereafter increase monotonically until it reaches + a maximum value of 2^64-1 (18446744073709551615 decimal), + when it wraps around and starts increasing again from zero. + + Provided that an application discovers a new schema node + of this type within the minimum time to wrap, it can use the + 'initial' value as a delta. It is important for a management + station to be aware of this minimum time and the actual time + between polls, and to discard data if the actual time is too + long or there is no defined minimum time. + + In the value set and its semantics, this type is equivalent + to the ZeroBasedCounter64 textual convention of the SMIv2."; + reference + "RFC 2856: Textual Conventions for Additional High Capacity + Data Types"; + } + + typedef gauge32 { + type uint32; + description + "The gauge32 type represents a non-negative integer, which + may increase or decrease, but shall never exceed a maximum + value, nor fall below a minimum value. The maximum value + cannot be greater than 2^32-1 (4294967295 decimal), and + the minimum value cannot be smaller than 0. The value of + a gauge32 has its maximum value whenever the information + being modeled is greater than or equal to its maximum + value, and has its minimum value whenever the information + being modeled is smaller than or equal to its minimum value. + If the information being modeled subsequently decreases + below (increases above) the maximum (minimum) value, the + gauge32 also decreases (increases). + + In the value set and its semantics, this type is equivalent + to the Gauge32 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + typedef gauge64 { + type uint64; + description + "The gauge64 type represents a non-negative integer, which + may increase or decrease, but shall never exceed a maximum + value, nor fall below a minimum value. The maximum value + cannot be greater than 2^64-1 (18446744073709551615), and + the minimum value cannot be smaller than 0. The value of + a gauge64 has its maximum value whenever the information + being modeled is greater than or equal to its maximum + value, and has its minimum value whenever the information + being modeled is smaller than or equal to its minimum value. + If the information being modeled subsequently decreases + below (increases above) the maximum (minimum) value, the + gauge64 also decreases (increases). + + In the value set and its semantics, this type is equivalent + to the CounterBasedGauge64 SMIv2 textual convention defined + in RFC 2856"; + reference + "RFC 2856: Textual Conventions for Additional High Capacity + Data Types"; + } + + /*** collection of identifier related types ***/ + + typedef object-identifier { + type string { + pattern '(([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))' + + '(\.(0|([1-9]\d*)))*'; + } + description + "The object-identifier type represents administratively + assigned names in a registration-hierarchical-name tree. + + Values of this type are denoted as a sequence of numerical + non-negative sub-identifier values. Each sub-identifier + value MUST NOT exceed 2^32-1 (4294967295). Sub-identifiers + are separated by single dots and without any intermediate + whitespace. + + The ASN.1 standard restricts the value space of the first + sub-identifier to 0, 1, or 2. Furthermore, the value space + of the second sub-identifier is restricted to the range + 0 to 39 if the first sub-identifier is 0 or 1. Finally, + the ASN.1 standard requires that an object identifier + has always at least two sub-identifier. The pattern + captures these restrictions. + + Although the number of sub-identifiers is not limited, + module designers should realize that there may be + implementations that stick with the SMIv2 limit of 128 + sub-identifiers. + + This type is a superset of the SMIv2 OBJECT IDENTIFIER type + since it is not restricted to 128 sub-identifiers. Hence, + this type SHOULD NOT be used to represent the SMIv2 OBJECT + IDENTIFIER type, the object-identifier-128 type SHOULD be + used instead."; + reference + "ISO9834-1: Information technology -- Open Systems + Interconnection -- Procedures for the operation of OSI + Registration Authorities: General procedures and top + arcs of the ASN.1 Object Identifier tree"; + } + + + + + typedef object-identifier-128 { + type object-identifier { + pattern '\d*(\.\d*){1,127}'; + } + description + "This type represents object-identifiers restricted to 128 + sub-identifiers. + + In the value set and its semantics, this type is equivalent + to the OBJECT IDENTIFIER type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + /*** collection of date and time related types ***/ + + typedef date-and-time { + type string { + pattern '\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?' + + '(Z|[\+\-]\d{2}:\d{2})'; + } + description + "The date-and-time type is a profile of the ISO 8601 + standard for representation of dates and times using the + Gregorian calendar. The profile is defined by the + date-time production in Section 5.6 of RFC 3339. + + The date-and-time type is compatible with the dateTime XML + schema type with the following notable exceptions: + + (a) The date-and-time type does not allow negative years. + + (b) The date-and-time time-offset -00:00 indicates an unknown + time zone (see RFC 3339) while -00:00 and +00:00 and Z all + represent the same time zone in dateTime. + + (c) The canonical format (see below) of data-and-time values + differs from the canonical format used by the dateTime XML + schema type, which requires all times to be in UTC using the + time-offset 'Z'. + + This type is not equivalent to the DateAndTime textual + convention of the SMIv2 since RFC 3339 uses a different + separator between full-date and full-time and provides + higher resolution of time-secfrac. + + The canonical format for date-and-time values with a known time + zone uses a numeric time zone offset that is calculated using + the device's configured known offset to UTC time. A change of + the device's offset to UTC time will cause date-and-time values + to change accordingly. Such changes might happen periodically + in case a server follows automatically daylight saving time + (DST) time zone offset changes. The canonical format for + date-and-time values with an unknown time zone (usually referring + to the notion of local time) uses the time-offset -00:00."; + reference + "RFC 3339: Date and Time on the Internet: Timestamps + RFC 2579: Textual Conventions for SMIv2 + XSD-TYPES: XML Schema Part 2: Datatypes Second Edition"; + } + + typedef timeticks { + type uint32; + description + "The timeticks type represents a non-negative integer that + represents the time, modulo 2^32 (4294967296 decimal), in + hundredths of a second between two epochs. When a schema + node is defined that uses this type, the description of + the schema node identifies both of the reference epochs. + + In the value set and its semantics, this type is equivalent + to the TimeTicks type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + typedef timestamp { + type yang:timeticks; + description + "The timestamp type represents the value of an associated + timeticks schema node at which a specific occurrence happened. + The specific occurrence must be defined in the description + of any schema node defined using this type. When the specific + occurrence occurred prior to the last time the associated + timeticks attribute was zero, then the timestamp value is + zero. Note that this requires all timestamp values to be + reset to zero when the value of the associated timeticks + attribute reaches 497+ days and wraps around to zero. + + The associated timeticks schema node must be specified + in the description of any schema node using this type. + + In the value set and its semantics, this type is equivalent + to the TimeStamp textual convention of the SMIv2."; + reference + "RFC 2579: Textual Conventions for SMIv2"; + } + + /*** collection of generic address types ***/ + + typedef phys-address { + type string { + pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'; + } + description + "Represents media- or physical-level addresses represented + as a sequence octets, each octet represented by two hexadecimal + numbers. Octets are separated by colons. The canonical + representation uses lowercase characters. + + In the value set and its semantics, this type is equivalent + to the PhysAddress textual convention of the SMIv2."; + reference + "RFC 2579: Textual Conventions for SMIv2"; + } + + typedef mac-address { + type string { + pattern '[0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}'; + } + description + "The mac-address type represents an IEEE 802 MAC address. + The canonical representation uses lowercase characters. + + In the value set and its semantics, this type is equivalent + to the MacAddress textual convention of the SMIv2."; + reference + "IEEE 802: IEEE Standard for Local and Metropolitan Area + Networks: Overview and Architecture + RFC 2579: Textual Conventions for SMIv2"; + } + + /*** collection of XML specific types ***/ + + typedef xpath1.0 { + type string; + description + "This type represents an XPATH 1.0 expression. + + When a schema node is defined that uses this type, the + description of the schema node MUST specify the XPath + context in which the XPath expression is evaluated."; + reference + "XPATH: XML Path Language (XPath) Version 1.0"; + } + + } diff --git a/model/yang-ext/pom.xml b/model/yang-ext/pom.xml index db78ba71dd..24ce16c819 100644 --- a/model/yang-ext/pom.xml +++ b/model/yang-ext/pom.xml @@ -15,14 +15,7 @@ - org.apache.maven.plugins maven-jar-plugin - ${maven.jar.version} - - - ${project.build.outputDirectory}/META-INF/MANIFEST.MF - - org.apache.felix @@ -34,110 +27,7 @@ - - org.opendaylight.yangtools - yang-maven-plugin - 0.5.9-SNAPSHOT - - - - generate-sources - - - src/main/yang - - - - org.opendaylight.yangtools.maven.sal.api.gen.plugin.CodeGeneratorImpl - - - target/generated-sources/sal - - - - true - - - - - - org.opendaylight.yangtools - maven-sal-api-gen-plugin - 0.5.8-SNAPSHOT - jar - - - - - org.codehaus.mojo - build-helper-maven-plugin - 1.7 - - - generate-sources - - add-source - - - - target/generated-sources/sal - - - - - - - - - - org.eclipse.m2e - lifecycle-mapping - 1.0.0 - - - - - - - org.opendaylight.yangtools - - - yang-maven-plugin - - - [0.5,) - - - - generate-sources - - - - - - - - - - - - - - - - org.opendaylight.yangtools - yang-binding - 0.5.9-SNAPSHOT - - - org.opendaylight.yangtools - yang-common - 0.5.9-SNAPSHOT - - - diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/api/UsesNodeBuilder.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/api/UsesNodeBuilder.java index 6b827841af..a3c786d5de 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/api/UsesNodeBuilder.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/api/UsesNodeBuilder.java @@ -14,7 +14,6 @@ import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.UsesNode; import org.opendaylight.yangtools.yang.model.api.YangNode; -import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder; import org.opendaylight.yangtools.yang.parser.util.RefineHolder; /** @@ -88,25 +87,6 @@ public interface UsesNodeBuilder extends GroupingMember, Builder { */ void setAugmenting(boolean augmenting); - /** - * Get augment under which was this uses node was defined. - *

    - * Note: This method may return different object than {@link #getParent()} - * if this node is a copy of other uses node. If the uses node is copied, - * its parent has changed, but parent augment is always same. - *

    - * - * @return AugmentationSchemaBuilder under which was this node defined - */ - AugmentationSchemaBuilder getParentAugment(); - - /** - * Set augment under which was this uses node was defined. - * - * @param augment - */ - void setParentAugment(AugmentationSchemaBuilder augment); - /** * Get augmentations defined in this uses node. * @@ -157,55 +137,6 @@ public interface UsesNodeBuilder extends GroupingMember, Builder { */ UsesNode build(YangNode parent); - /** - * Get child nodes defined in target grouping. - * - * @return set of DataSchemaNodeBuilder objects - */ - Set getTargetChildren(); - - /** - * Get groupings defined in target grouping. - * - * @return set of GroupingBuilder objects - */ - Set getTargetGroupings(); - - /** - * Get type definitions defined in target grouping. - * - * @return set of typedefs defined in target grouping - */ - Set getTargetTypedefs(); - - /** - * Get unknown nodes defined in target grouping. - * - * @return list of unknown nodes defined in target grouping - */ - List getTargetUnknownNodes(); - - /** - * - * @return true, if this object was built based on another UsesNodeBuilder, - * false otherwise - */ - boolean isCopy(); - - /** - * - * @return true, if target grouping objects was loaded already, false - * otherwise - */ - boolean isDataCollected(); - - /** - * Set if target grouping objects was loaded already. - * - * @param dataCollected - */ - void setDataCollected(boolean dataCollected); - boolean isResolved(); void setResolved(boolean resolved); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ModuleBuilder.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ModuleBuilder.java index d14fed5779..c248f84bed 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ModuleBuilder.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ModuleBuilder.java @@ -199,15 +199,6 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder { return instance; } - public boolean isAllUsesDataCollected() { - for (UsesNodeBuilder usesNode : allUsesNodes) { - if (!usesNode.isDataCollected()) { - return false; - } - } - return true; - } - @Override public void setParent(Builder parent) { throw new YangParseException(name, 0, "Can not set parent to module"); @@ -491,7 +482,6 @@ public class ModuleBuilder extends AbstractDataNodeContainerBuilder { } if(parent instanceof AugmentationSchemaBuilder) { usesBuilder.setAugmenting(true); - usesBuilder.setParentAugment((AugmentationSchemaBuilder)parent); } allUsesNodes.add(usesBuilder); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/UsesNodeBuilderImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/UsesNodeBuilderImpl.java index 8d6190678f..7ab57c644f 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/UsesNodeBuilderImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/UsesNodeBuilderImpl.java @@ -29,7 +29,6 @@ import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuild import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder; -import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder; import org.opendaylight.yangtools.yang.parser.util.RefineHolder; import org.opendaylight.yangtools.yang.parser.util.YangParseException; @@ -38,67 +37,22 @@ public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNo private boolean isBuilt; private UsesNodeImpl instance; private DataNodeContainerBuilder parentBuilder; - private final String groupingName; + private final String groupingPathString; private SchemaPath groupingPath; private GroupingDefinition groupingDefinition; private GroupingBuilder groupingBuilder; private boolean addedByUses; private boolean augmenting; private boolean resolved; - private AugmentationSchemaBuilder parentAugment; private final Set augments = new HashSet<>(); private final Set addedAugments = new HashSet<>(); private final List refineBuilders = new ArrayList<>(); private final List refines = new ArrayList<>(); - /** - * Copies of target grouping child nodes. - */ - private final Set targetChildren = new HashSet<>(); - - /** - * Copies of target grouping groupings. - */ - private final Set targetGroupings = new HashSet<>(); - - /** - * Copies of target grouping typedefs. - */ - private final Set targetTypedefs = new HashSet<>(); - - /** - * Copies of target grouping unknown nodes. - */ - private final List targetUnknownNodes = new ArrayList<>(); - - private final boolean isCopy; - private boolean dataCollected; - - @Override - public boolean isCopy() { - return isCopy; - } - - @Override - public boolean isDataCollected() { - return dataCollected; - } - - @Override - public void setDataCollected(boolean dataCollected) { - this.dataCollected = dataCollected; - } public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName) { super(moduleName, line); - this.groupingName = groupingName; - isCopy = false; - } - - public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName, final boolean isCopy) { - super(moduleName, line); - this.groupingName = groupingName; - this.isCopy = isCopy; + this.groupingPathString = groupingName; } @Override @@ -181,7 +135,7 @@ public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNo @Override public String getGroupingPathAsString() { - return groupingName; + return groupingPathString; } @Override @@ -223,16 +177,6 @@ public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNo this.resolved = resolved; } - @Override - public AugmentationSchemaBuilder getParentAugment() { - return parentAugment; - } - - @Override - public void setParentAugment(AugmentationSchemaBuilder augment) { - this.parentAugment = augment; - } - @Override public List getRefineNodes() { return refineBuilders; @@ -253,31 +197,11 @@ public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNo refines.add(refine); } - @Override - public Set getTargetChildren() { - return targetChildren; - } - - @Override - public Set getTargetGroupings() { - return targetGroupings; - } - - @Override - public Set getTargetTypedefs() { - return targetTypedefs; - } - - @Override - public List getTargetUnknownNodes() { - return targetUnknownNodes; - } - @Override public int hashCode() { final int prime = 31; int result = 1; - result = prime * result + ((groupingName == null) ? 0 : groupingName.hashCode()); + result = prime * result + ((groupingPathString == null) ? 0 : groupingPathString.hashCode()); result = prime * result + ((parentBuilder == null) ? 0 : parentBuilder.hashCode()); return result; } @@ -294,11 +218,11 @@ public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNo return false; } UsesNodeBuilderImpl other = (UsesNodeBuilderImpl) obj; - if (groupingName == null) { - if (other.groupingName != null) { + if (groupingPathString == null) { + if (other.groupingPathString != null) { return false; } - } else if (!groupingName.equals(other.groupingName)) { + } else if (!groupingPathString.equals(other.groupingPathString)) { return false; } if (parentBuilder == null) { @@ -313,7 +237,7 @@ public final class UsesNodeBuilderImpl extends AbstractBuilder implements UsesNo @Override public String toString() { - return "uses '" + groupingName + "'"; + return "uses '" + groupingPathString + "'"; } public final class UsesNodeImpl implements UsesNode { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserImpl.java index f6d4d67cbb..6c22971d7e 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserImpl.java @@ -696,7 +696,7 @@ public final class YangParserImpl implements YangModelParser { "Failed to parse augment: Unresolved parent of augment: " + augmentParent); } - return processAugmentation(augment, firstNodeParent, path); + return processAugmentation(augment, firstNodeParent); } /** @@ -781,7 +781,7 @@ public final class YangParserImpl implements YangModelParser { if (currentParent == null) { return processAugmentationOnContext(augment, path, module, prefix, context); } else { - return processAugmentation(augment, currentParent, path); + return processAugmentation(augment, currentParent); } } @@ -948,7 +948,6 @@ public final class YangParserImpl implements YangModelParser { for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) { processAugmentationOnContext(augment, augment.getTargetPath().getPath(), module, prefix, context); } - GroupingUtils.performRefine(usesNode); } else { parent.getChildNodeBuilders().addAll(target.instantiateChildNodes(parent)); parent.getTypeDefinitionBuilders().addAll(target.instantiateTypedefs(parent)); @@ -957,10 +956,10 @@ public final class YangParserImpl implements YangModelParser { usesNode.setResolved(true); for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) { - processAugmentation(augment, parent, augment.getTargetPath().getPath()); + processAugmentation(augment, parent); } - GroupingUtils.performRefine(usesNode); } + GroupingUtils.performRefine(usesNode); } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/CopyUtils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/CopyUtils.java index a0101a556d..9e97fa39f3 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/CopyUtils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/CopyUtils.java @@ -415,9 +415,9 @@ public final class CopyUtils { return newConstraints; } - static UsesNodeBuilder copyUses(UsesNodeBuilder old, Builder newParent) { + private static UsesNodeBuilder copyUses(UsesNodeBuilder old, Builder newParent) { UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(), - old.getGroupingPathAsString(), true); + old.getGroupingPathAsString()); copy.setParent(newParent); copy.setGroupingDefinition(old.getGroupingDefinition()); copy.setGrouping(old.getGroupingBuilder()); @@ -426,7 +426,6 @@ public final class CopyUtils { copy.getRefineNodes().addAll(old.getRefineNodes()); copy.getRefines().addAll(old.getRefines()); copy.setAugmenting(old.isAugmenting()); - copy.setParentAugment(old.getParentAugment()); return copy; } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ParserListenerUtils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ParserListenerUtils.java index b2e9381b1f..a25b627951 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ParserListenerUtils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ParserListenerUtils.java @@ -743,7 +743,7 @@ public final class ParserListenerUtils { reference = stringFromNode(child); } } - String pattern = patternStringFromNode(ctx); + String pattern = parsePatternString(ctx); return BaseConstraints.patternConstraint(pattern, description, reference); } @@ -754,7 +754,7 @@ public final class ParserListenerUtils { * context to parse * @return pattern value as String */ - public static String patternStringFromNode(final Pattern_stmtContext ctx) { + private static String parsePatternString(final Pattern_stmtContext ctx) { StringBuilder result = new StringBuilder(); for (int i = 0; i < ctx.getChildCount(); ++i) { ParseTree child = ctx.getChild(i); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ParserUtils.xtend b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ParserUtils.xtend index e3d3a4898a..9f03e79850 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ParserUtils.xtend +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ParserUtils.xtend @@ -43,7 +43,6 @@ import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder.NotificationDefinitionImpl; import org.opendaylight.yangtools.yang.model.api.AugmentationTarget import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder -import java.net.URI import org.opendaylight.yangtools.yang.parser.builder.api.GroupingMember public final class ParserUtils { @@ -64,14 +63,6 @@ public final class ParserUtils { return new SchemaPath(path, schemaPath.isAbsolute()); } - public static def SchemaPath correctSchemaPath(SchemaPath old, URI ns, Date revision, String prefix) { - val List newPath = new ArrayList(); - for (name : old.path) { - newPath.add(new QName(ns, revision, prefix, name.localName)) - } - return new SchemaPath(newPath, old.absolute) - } - /** * Get module import referenced by given prefix. * @@ -297,7 +288,6 @@ public final class ParserUtils { * schema path of node parent */ static def void correctNodePath(SchemaNodeBuilder node, SchemaPath parentSchemaPath) { - // set correct path val targetNodePath = new ArrayList(parentSchemaPath.getPath()); targetNodePath.add(node.getQName()); @@ -321,7 +311,6 @@ public final class ParserUtils { } - private static def Builder findNode(Builder firstNodeParent, List path, String moduleName, int line) { var currentName = ""; var currentParent = firstNodeParent; @@ -343,16 +332,10 @@ public final class ParserUtils { if (nodeFound == null && currentParent instanceof ModuleBuilder) { nodeFound = searchRpcs(currentParent as ModuleBuilder, currentName); } - // if not found, search in uses if (nodeFound == null) { - var found = searchUses(dataNodeContainerParent, currentName); - if(found == null) { - return null; - } else { - currentParent = found; - } + return null } else { - currentParent = nodeFound; + currentParent = nodeFound } } else if (currentParent instanceof ChoiceBuilder) { val choiceParent = currentParent as ChoiceBuilder; @@ -396,41 +379,6 @@ public final class ParserUtils { return null; } - private static def searchUses(DataNodeContainerBuilder dataNodeContainerParent, String name) { - var currentName = name; - for (unb : dataNodeContainerParent.usesNodes) { - var result = searchInUsesTarget(currentName, unb); - if (result != null) { - return result; - } - - result = findNodeInUses(currentName, unb); - if (result != null) { - var copy = CopyUtils.copy(result, unb.getParent(), true); - unb.getTargetChildren().add(copy); - return copy; - } - } - return null; - } - - public static def getRpc(ModuleBuilder module,String name) { - for(rpc : module.getRpcs()) { - if(name == rpc.QName.localName) { - return rpc; - } - } - return null; - } - - public static def getNotification(ModuleBuilder module,String name) { - for(notification : module.getNotifications()) { - if(name == notification.QName.localName) { - return notification; - } - } - } - private static def nextLevel(List path){ return path.subList(1,path.size) } @@ -445,64 +393,30 @@ public final class ParserUtils { * path to augment target * @return true if augmentation process succeed, false otherwise */ - public static def boolean processAugmentation(AugmentationSchemaBuilder augment, Builder firstNodeParent, - List path) { - - // traverse augment target path and try to reach target node - val targetNode = findNode(firstNodeParent,path,augment.moduleName,augment.line); - if (targetNode === null) return false; - - if ((targetNode instanceof DataNodeContainerBuilder)) { - val targetDataNodeContainer = targetNode as DataNodeContainerBuilder; - augment.setTargetNodeSchemaPath(targetDataNodeContainer.getPath()); - fillAugmentTarget(augment, targetDataNodeContainer); - } else if (targetNode instanceof ChoiceBuilder) { - val targetChoiceBuilder = targetNode as ChoiceBuilder; - augment.setTargetNodeSchemaPath(targetChoiceBuilder.getPath()); - fillAugmentTarget(augment, targetChoiceBuilder); - } else { - throw new YangParseException(augment.getModuleName(), augment.getLine(), - "Error in augment parsing: The target node MUST be either a container, list, choice, case, input, output, or notification node."); - } - (targetNode as AugmentationTargetBuilder).addAugmentation(augment); - augment.setResolved(true); - return true; - } - - private static def DataSchemaNodeBuilder searchInUsesTarget(String localName, UsesNodeBuilder uses) { - for(child : uses.targetChildren) { - if (child.getQName().getLocalName().equals(localName)) { - return child; - } - } - } - - /** - * Find node with given name in uses target. - * - * @param localName - * name of node to find - * @param uses - * uses node which target grouping should be searched - * @return node with given name if found, null otherwise - */ - private static def DataSchemaNodeBuilder findNodeInUses(String localName, UsesNodeBuilder uses) { - val target = uses.groupingBuilder; - for (child : target.childNodeBuilders) { - if (child.getQName().getLocalName().equals(localName)) { - return child; - } - } - for (usesNode : target.usesNodes) { - val result = findNodeInUses(localName, usesNode); - if (result != null) { - return result; - } + public static def boolean processAugmentation(AugmentationSchemaBuilder augment, Builder firstNodeParent) { + val path = augment.targetPath.path + // traverse augment target path and try to reach target node + val targetNode = findNode(firstNodeParent, path, augment.moduleName, augment.line); + if(targetNode === null) return false; + + if ((targetNode instanceof DataNodeContainerBuilder)) { + val targetDataNodeContainer = targetNode as DataNodeContainerBuilder; + augment.setTargetNodeSchemaPath(targetDataNodeContainer.getPath()); + fillAugmentTarget(augment, targetDataNodeContainer); + } else if (targetNode instanceof ChoiceBuilder) { + val targetChoiceBuilder = targetNode as ChoiceBuilder; + augment.setTargetNodeSchemaPath(targetChoiceBuilder.getPath()); + fillAugmentTarget(augment, targetChoiceBuilder); + } else { + throw new YangParseException(augment.getModuleName(), augment.getLine(), + "Error in augment parsing: The target node MUST be either a container, list, choice, case, input, output, or notification node."); } - return null; + (targetNode as AugmentationTargetBuilder).addAugmentation(augment); + augment.setResolved(true); + return true; } - /** + /** * Find augment target node in given context and perform augmentation. * * @param augment @@ -516,107 +430,107 @@ public final class ParserUtils { * SchemaContext containing already resolved modules * @return true if augment process succeed, false otherwise */ - public static def boolean processAugmentationOnContext(AugmentationSchemaBuilder augment, List path, - ModuleBuilder module, String prefix, SchemaContext context) { - val int line = augment.getLine(); - val Module dependentModule = findModuleFromContext(context, module, prefix, line); - if (dependentModule === null) { - throw new YangParseException(module.getName(), line, - "Error in augment parsing: failed to find module with prefix " + prefix + "."); - } - - var currentName = path.get(0).getLocalName(); - var SchemaNode currentParent = dependentModule.getDataChildByName(currentName); - if (currentParent === null) { - val notifications = dependentModule.getNotifications(); - for (NotificationDefinition ntf : notifications) { - if (ntf.getQName().getLocalName().equals(currentName)) { - currentParent = ntf; - } + public static def boolean processAugmentationOnContext(AugmentationSchemaBuilder augment, List path, + ModuleBuilder module, String prefix, SchemaContext context) { + val int line = augment.getLine(); + val Module dependentModule = findModuleFromContext(context, module, prefix, line); + if (dependentModule === null) { + throw new YangParseException(module.getName(), line, + "Error in augment parsing: failed to find module with prefix " + prefix + "."); + } + + var currentName = path.get(0).getLocalName(); + var SchemaNode currentParent = dependentModule.getDataChildByName(currentName); + if (currentParent === null) { + val notifications = dependentModule.getNotifications(); + for (NotificationDefinition ntf : notifications) { + if (ntf.getQName().getLocalName().equals(currentName)) { + currentParent = ntf; } } - if (currentParent === null) { - throw new YangParseException(module.getName(), line, - "Error in augment parsing: failed to find node " + currentName + "."); - } - - for (qname : path.nextLevel) { - currentName = qname.getLocalName(); - if (currentParent instanceof DataNodeContainer) { - currentParent = (currentParent as DataNodeContainer).getDataChildByName(currentName); - } else if (currentParent instanceof ChoiceNode) { - currentParent = (currentParent as ChoiceNode).getCaseNodeByName(currentName); - } else { - throw new YangParseException(augment.getModuleName(), line, - "Error in augment parsing: failed to find node " + currentName); - } + } + if (currentParent === null) { + throw new YangParseException(module.getName(), line, + "Error in augment parsing: failed to find node " + currentName + "."); + } - // if node in path not found, return false - if (currentParent === null) { - throw new YangParseException(module.getName(), line, - "Error in augment parsing: failed to find node " + currentName + "."); - } + for (qname : path.nextLevel) { + currentName = qname.getLocalName(); + if (currentParent instanceof DataNodeContainer) { + currentParent = (currentParent as DataNodeContainer).getDataChildByName(currentName); + } else if (currentParent instanceof ChoiceNode) { + currentParent = (currentParent as ChoiceNode).getCaseNodeByName(currentName); + } else { + throw new YangParseException(augment.getModuleName(), line, + "Error in augment parsing: failed to find node " + currentName); } - val oldPath = currentParent.path; - - if (!(currentParent instanceof AugmentationTarget)) { + // if node in path not found, return false + if (currentParent === null) { throw new YangParseException(module.getName(), line, - "Target of type " + currentParent.class + " cannot be augmented."); - } - - switch (currentParent) { - case (currentParent instanceof ContainerSchemaNodeImpl): { - - // includes container, input and output statement - val c = currentParent as ContainerSchemaNodeImpl; - val cb = c.toBuilder(); - fillAugmentTarget(augment, cb); - (cb as AugmentationTargetBuilder ).addAugmentation(augment); - cb.rebuild(); - } - case (currentParent instanceof ListSchemaNodeImpl): { - val l = currentParent as ListSchemaNodeImpl; - val lb = l.toBuilder(); - fillAugmentTarget(augment, lb); - (lb as AugmentationTargetBuilder ).addAugmentation(augment); - lb.rebuild(); - augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); - augment.setResolved(true); - } - case (currentParent instanceof ChoiceNodeImpl): { - val ch = currentParent as ChoiceNodeImpl; - val chb = ch.toBuilder(); - fillAugmentTarget(augment, chb); - (chb as AugmentationTargetBuilder ).addAugmentation(augment); - chb.rebuild(); - augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); - augment.setResolved(true); - } - case (currentParent instanceof ChoiceCaseNodeImpl): { - val chc = currentParent as ChoiceCaseNodeImpl; - val chcb = chc.toBuilder(); - fillAugmentTarget(augment, chcb); - (chcb as AugmentationTargetBuilder ).addAugmentation(augment); - chcb.rebuild(); - augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); - augment.setResolved(true); - } - case (currentParent instanceof NotificationDefinitionImpl): { - val nd = currentParent as NotificationDefinitionImpl; - val nb = nd.toBuilder(); - fillAugmentTarget(augment, nb); - (nb as AugmentationTargetBuilder ).addAugmentation(augment); - nb.rebuild(); - augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); - augment.setResolved(true); - } + "Error in augment parsing: failed to find node " + currentName + "."); } - augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); - augment.setResolved(true); - return true; } + val oldPath = currentParent.path; + + if (!(currentParent instanceof AugmentationTarget)) { + throw new YangParseException(module.getName(), line, + "Target of type " + currentParent.class + " cannot be augmented."); + } + + switch (currentParent) { + case (currentParent instanceof ContainerSchemaNodeImpl): { + + // includes container, input and output statement + val c = currentParent as ContainerSchemaNodeImpl; + val cb = c.toBuilder(); + fillAugmentTarget(augment, cb); + (cb as AugmentationTargetBuilder ).addAugmentation(augment); + cb.rebuild(); + } + case (currentParent instanceof ListSchemaNodeImpl): { + val l = currentParent as ListSchemaNodeImpl; + val lb = l.toBuilder(); + fillAugmentTarget(augment, lb); + (lb as AugmentationTargetBuilder ).addAugmentation(augment); + lb.rebuild(); + augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); + augment.setResolved(true); + } + case (currentParent instanceof ChoiceNodeImpl): { + val ch = currentParent as ChoiceNodeImpl; + val chb = ch.toBuilder(); + fillAugmentTarget(augment, chb); + (chb as AugmentationTargetBuilder ).addAugmentation(augment); + chb.rebuild(); + augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); + augment.setResolved(true); + } + case (currentParent instanceof ChoiceCaseNodeImpl): { + val chc = currentParent as ChoiceCaseNodeImpl; + val chcb = chc.toBuilder(); + fillAugmentTarget(augment, chcb); + (chcb as AugmentationTargetBuilder ).addAugmentation(augment); + chcb.rebuild(); + augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); + augment.setResolved(true); + } + case (currentParent instanceof NotificationDefinitionImpl): { + val nd = currentParent as NotificationDefinitionImpl; + val nb = nd.toBuilder(); + fillAugmentTarget(augment, nb); + (nb as AugmentationTargetBuilder ).addAugmentation(augment); + nb.rebuild(); + augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); + augment.setResolved(true); + } + } + augment.setTargetNodeSchemaPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute())); + augment.setResolved(true); + return true; + } + public static def IdentitySchemaNodeBuilder findBaseIdentity(Map> modules, ModuleBuilder module, String baseString, int line) { var IdentitySchemaNodeBuilder result = null; @@ -675,22 +589,22 @@ public final class ParserUtils { return null; } - /** + /** * Get module in which this node is defined. * * @param node * @return builder of module where this node is defined */ - public static def ModuleBuilder getParentModule(Builder node) { - if (node instanceof ModuleBuilder) { - return node as ModuleBuilder; - } - var parent = node.getParent(); - while (!(parent instanceof ModuleBuilder)) { - parent = parent.getParent(); - } - return parent as ModuleBuilder; + public static def ModuleBuilder getParentModule(Builder node) { + if (node instanceof ModuleBuilder) { + return node as ModuleBuilder; } + var parent = node.getParent(); + while (!(parent instanceof ModuleBuilder)) { + parent = parent.getParent(); + } + return parent as ModuleBuilder; + } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/RefineUtils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/RefineUtils.java index f3f2def8fe..f5f5b46478 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/RefineUtils.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/RefineUtils.java @@ -167,7 +167,7 @@ public final class RefineUtils { * @param refine * refine object containing information about refine process */ - public static void checkRefine(SchemaNodeBuilder node, RefineHolder refine) { + private static void checkRefine(SchemaNodeBuilder node, RefineHolder refine) { String moduleName = refine.getModuleName(); int line = refine.getLine(); String name = node.getQName().getLocalName(); @@ -259,7 +259,7 @@ public final class RefineUtils { * @param refine * refine object containing information about refine process */ - public static void refineDefault(final Builder node, final RefineHolder refine) { + private static void refineDefault(final Builder node, final RefineHolder refine) { final String moduleName = refine.getModuleName(); final int line = refine.getLine(); Class cls = node.getClass(); @@ -303,7 +303,7 @@ public final class RefineUtils { * @param refine * refine object containing information about refine process */ - public static void performRefine(SchemaNodeBuilder nodeToRefine, RefineHolder refine) { + static void performRefine(SchemaNodeBuilder nodeToRefine, RefineHolder refine) { checkRefine(nodeToRefine, refine); refineDefault(nodeToRefine, refine); if (nodeToRefine instanceof LeafSchemaNodeBuilder) { diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/AugmentTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/AugmentTest.java index dfa7bc4830..c362a2179c 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/AugmentTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/AugmentTest.java @@ -37,8 +37,6 @@ import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.util.BaseTypes; public class AugmentTest { - private static final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); - private static final URI fooNS = URI.create("urn:opendaylight.foo"); private static final URI barNS = URI.create("urn:opendaylight.bar"); private static final URI bazNS = URI.create("urn:opendaylight.baz"); @@ -56,6 +54,7 @@ public class AugmentTest { @BeforeClass public static void init() throws FileNotFoundException, ParseException { + DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); fooRev = simpleDateFormat.parse("2013-10-13"); barRev = simpleDateFormat.parse("2013-10-14"); bazRev = simpleDateFormat.parse("2013-10-15"); @@ -342,7 +341,7 @@ public class AugmentTest { modules = TestUtils.loadModules(getClass().getResource("/augment-test/rpc").getPath()); final URI NS_BAR = URI.create("urn:opendaylight:bar"); final URI NS_FOO = URI.create("urn:opendaylight:foo"); - final Date revision = simpleDateFormat.parse("2013-10-11"); + final Date revision = new SimpleDateFormat("yyyy-MM-dd").parse("2013-10-11"); Module bar = TestUtils.findModule(modules, "bar"); Set rpcs = bar.getRpcs(); diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/GroupingTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/GroupingTest.java index 44cb0d635d..2adb544f5a 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/GroupingTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/GroupingTest.java @@ -13,6 +13,7 @@ import java.io.File; import java.io.FileNotFoundException; import java.net.URI; import java.text.ParseException; +import java.text.SimpleDateFormat; import java.util.Collections; import java.util.Date; import java.util.List; @@ -390,7 +391,7 @@ public class GroupingTest { assertNotNull(gzz); URI expectedNS = URI.create("urn:grouping:cascade-uses"); - Date expectedRev = TestUtils.simpleDateFormat.parse("2013-07-18"); + Date expectedRev = new SimpleDateFormat("yyyy-MM-dd").parse("2013-07-18"); String expectedPref = "cu"; SchemaPath expectedPath; diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/TestUtils.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/TestUtils.java index fe438c928d..4d77c2506c 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/TestUtils.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/TestUtils.java @@ -39,8 +39,6 @@ import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser; final class TestUtils { - static final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); - private TestUtils() { } @@ -151,7 +149,7 @@ final class TestUtils { /** * Test if node has augmenting flag set to expected value. In case this is * DataNodeContainer/ChoiceNode, check its child nodes/case nodes too. - * + * * @param node * node to check * @param expected @@ -173,7 +171,7 @@ final class TestUtils { /** * Check if node has addedByUses flag set to expected value. In case this is * DataNodeContainer/ChoiceNode, check its child nodes/case nodes too. - * + * * @param node * node to check * @param expected diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/UsesAugmentTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/UsesAugmentTest.java index 9b69af60e6..1d760b870c 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/UsesAugmentTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/UsesAugmentTest.java @@ -11,7 +11,9 @@ import static org.junit.Assert.*; import java.io.FileNotFoundException; import java.net.URI; +import java.text.DateFormat; import java.text.ParseException; +import java.text.SimpleDateFormat; import java.util.Date; import java.util.LinkedList; import java.util.List; @@ -50,8 +52,9 @@ public class UsesAugmentTest { @Before public void init() throws FileNotFoundException, ParseException { - UG_REV = TestUtils.simpleDateFormat.parse("2013-07-30"); - GD_REV = TestUtils.simpleDateFormat.parse("2013-09-04"); + DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); + UG_REV = simpleDateFormat.parse("2013-07-30"); + GD_REV = simpleDateFormat.parse("2013-09-04"); } /** diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserSimpleTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserSimpleTest.java index c3cdc27fb8..7eced3191b 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserSimpleTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserSimpleTest.java @@ -214,7 +214,7 @@ public class YangParserSimpleTest { private SchemaPath createPath(String... names) { try { - rev = TestUtils.simpleDateFormat.parse("2013-07-30"); + rev = new SimpleDateFormat("yyyy-MM-dd").parse("2013-07-30"); } catch (ParseException e) { e.printStackTrace(); } diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserTest.java index ad720994ab..3c55d4d9d6 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/YangParserTest.java @@ -12,7 +12,9 @@ import static org.junit.Assert.*; import java.io.File; import java.io.FileNotFoundException; import java.net.URI; +import java.text.DateFormat; import java.text.ParseException; +import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; @@ -67,9 +69,10 @@ public class YangParserTest { @Before public void init() throws FileNotFoundException, ParseException { - fooRev = TestUtils.simpleDateFormat.parse("2013-02-27"); - barRev = TestUtils.simpleDateFormat.parse("2013-07-03"); - bazRev = TestUtils.simpleDateFormat.parse("2013-02-27"); + DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); + fooRev = simpleDateFormat.parse("2013-02-27"); + barRev = simpleDateFormat.parse("2013-07-03"); + bazRev = simpleDateFormat.parse("2013-02-27"); modules = TestUtils.loadModules(getClass().getResource("/model").getPath()); assertEquals(3, modules.size());