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;
                }
            }
        }
    }
}