Populating a list of YANG data nodes using templates

 +--(...)                     // out of scope
 +--rw data-nodes-pattern     // container for functional instances
    +--rw instance* [name]    // the list of functional instances
       +--rw name             string-ascii64
       +--rw description?     string-ascii128
       +--rw data
          +--rw list-a [name] //e.g. a list of interfaces
          |  +--rw name
          |  +--rw parm-x
          |  +--rw parm-y
          +--rw list-b [name] //e.g. a list of hardware components
             +--rw name
             +--rw parm-t
             +--rw parm-u

 +--(...)                     // out of scope
 +--rw data-nodes-pattern     // container for functional instances
    +--rw template* [name]    // the list of templates
    |  +--rw name             string-ascii64
    |  +--rw description?     string-ascii128
    |  +--rw data
    |     +--rw list-a [name] //e.g. a list of interfaces
    |     |  +--rw name
    |     |  +--rw parm-x
    |     |  +--rw parm-y
    |     +--rw list-b [name] //e.g. a list of hardware components
    |        +--rw name
    |        +--rw parm-t
    |        +--rw parm-u
    +--rw instance* [name]    // the list of functional instances
       +--rw name             string-ascii64
       +--rw description?     string-ascii128
       +--rw template?        -> /data-nodes-pattern/template/name
       +--rw data
       +--rw list-a [name] //e.g. a list of interfaces
       |  +--rw name
       |  +--rw parm-x  //overrule if present,or take it from template
       |  +--rw parm-y  //overrule if present,or take it from template
       +--rw list-b [name] //e.g. a list of hardware components
          +--rw name
          +--rw parm-t  //overrule if present,or take it from template
          +--rw parm-u  //overrule if present,or take it from template

module xxx-interfaces-common {
  yang-version 1.1;
  namespace "urn:xxx-interfaces-common";
  prefix xxx-ifc;

  import ietf-yang-types {
    prefix yang;
  }
   // Grouping few nodes of ietf-interfaces.yang
  grouping interface-attributes {
    container interfaces {
      description
         "Interface parameters.";
      list interface {
        key "name";
        description
         "The list of interfaces on the device.
          The status of an interface is available in this list in the
          operational state.  If the configuration of a
          system-controlled interface cannot be used by the system
          (e.g., the interface hardware present does not match the
          interface type), then the configuration is not applied to
          the system-controlled interface shown in the operational
          state.  If the configuration of a user-controlled interface
          cannot be used by the system, the configured interface is
          not instantiated in the operational state.

          System-controlled interfaces created by the system are
          always present in this list in the operational state,
          whether or not they are configured.";
        leaf name {
          type string;
           description
             "The name of the interface.

              A device MAY restrict the allowed values for this leaf,
              possibly depending on the type of the interface.
              For system-controlled interfaces, this leaf is the
              device-specific name of the interface.

              If a client tries to create configuration for a
              system-controlled interface that is not present in the
              operational state, the server MAY reject the request if
              the implementation does not support pre-provisioning of
              interfaces or if the name refers to an interface that can
              never exist in the system.  A Network Configuration
              Protocol (NETCONF) server MUST reply with an rpc-error
              with the error-tag 'invalid-value' in this case.

              If the device supports pre-provisioning of interface
              configuration, the 'pre-provisioning' feature is
              advertised.

              If the device allows arbitrarily named user-controlled
              interfaces, the 'arbitrary-names' feature is advertised.
              When a configured user-controlled interface is created by
            the system, it is instantiated with the same name in the
            operational state.

            A server implementation MAY map this leaf to the ifName
            MIB object.  Such an implementation needs to use some
            mechanism to handle the differences in size and characters
            allowed between this leaf and ifName.  The definition of
            such a mechanism is outside the scope of this document.";
         reference
           "RFC 2863: The Interfaces Group MIB - ifName";
       }

        leaf description {
          type string;
          description
           "A textual description of the interface.

            A server implementation MAY map this leaf to the ifAlias
            MIB object.  Such an implementation needs to use some
            mechanism to handle the differences in size and characters
            allowed between this leaf and ifAlias.  The definition of
            such a mechanism is outside the scope of this document.

            Since ifAlias is defined to be stored in non-volatile
            storage, the MIB implementation MUST map ifAlias to the
            value of 'description' in the persistently stored
            configuration.";
         reference
           "RFC 2863: The Interfaces Group MIB - ifAlias";
           }

        leaf type {
          type identityref {
            base interface-type;
          }
          /*mandatory true;could be refined when grouping is used*/
          description
           "The type of the interface.
            When an interface entry is created, a server MAY
            initialize the type leaf with a valid value, e.g., if it
            is possible to derive the type from the name of the
            interface.

            If a client tries to set the type of an interface to a
            value that can never be used by the system, e.g., if the
            type is not supported or if the type does not match the
            name of the interface, the server MUST reject the request.
            A NETCONF server MUST reply with an rpc-error with the
            error-tag 'invalid-value' in this case.";
         reference
           "RFC 2863: The Interfaces Group MIB - ifType";
         }

        leaf enabled {
          type boolean;
          /*default "true";could be refined when grouping is used*/
          description
           "This leaf contains the configured, desired state of the
            interface.

            Systems that implement the IF-MIB use the value of this
            leaf in the intended configuration to set
            IF-MIB.ifAdminStatus to 'up' or 'down' after an ifEntry
            has been initialized, as described in RFC 2863.

            Changes in this leaf in the intended configuration are
            reflected in ifAdminStatus.";
         reference
           "RFC 2863: The Interfaces Group MIB - ifAdminStatus";
           }

        leaf link-up-down-trap-enable {
          type enumeration {
            enum enabled {
              value 1;
              description
                "The device will generate linkUp/linkDown SNMP
                 notifications for this interface.";
               }
            enum disabled {
              value 2;
              description
                "The device will not generate linkUp/linkDown SNMP
                notifications for this interface.";
              }
            }
         description
         "Controls whether linkUp/linkDown SNMP notifications
          should be generated for this interface.
          If this node is not configured, the value 'enabled' is
          operationally used by the server for interfaces that do
          not operate on top of any other interface (i.e., there are
          no 'lower-layer-if' entries), and 'disabled' otherwise.";
          reference
           "RFC 2863: The Interfaces Group MIB -
                      ifLinkUpDownTrapEnable";
           }
       }//interface
     }  //interfaces
  }
}

module xxx-interfaces-template {
  yang-version 1.1;
  namespace "urn:xxx-interfaces-tmplt";
  prefix xxx-ifc-tmplt;

  import xxx-interfaces-common {
    prefix xxx-ifc;
  }
     container data-nodes-pattern {
       list template {
         key "name";
         leaf name {
           type string;
         }
         container data {
           uses xxx-ifc:interface-attributes;
         }
       }

       list instance {
         key "name";
         leaf name {
           type string;
         }
       leaf template {
         type leafref {
           path
              "/data-nodes-pattern/template/name";
          }
        }
        container data {
          uses xxx-ifc:interface-attributes;
        }
      }
    }
}