Added support for resolving augmentations.

[controller.git] / opendaylight / sal / yang-prototype / code-generator / samples / maven-code-gen-sample / src / main / yang / controller-network.yang

diff --git a/opendaylight/sal/yang-prototype/code-generator/samples/maven-code-gen-sample/src/main/yang/controller-network.yang b/opendaylight/sal/yang-prototype/code-generator/samples/maven-code-gen-sample/src/main/yang/controller-network.yang
new file mode 100644 (file)
index 0000000..357e6ba
--- /dev/null
+++ b/opendaylight/sal/yang-prototype/code-generator/samples/maven-code-gen-sample/src/main/yang/controller-network.yang
@@ -0,0 +1,172 @@
+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;
+                               }
+                       }
+               }
+       }
+}