module opendaylight-table-types {
    namespace "urn:opendaylight:table:types";
    prefix table;

    import ietf-inet-types {prefix inet; revision-date "2010-09-24";}
    import ietf-yang-types {prefix yang; revision-date "2010-09-24";}
    import opendaylight-flow-types {prefix flow;revision-date 2013-10-26";}
    import opendaylight-action-types {prefix action;}

    revision "2013-10-26" {
        description "Initial revision of table service";
    }

    typedef table-ref {
        type instance-identifier;
    }
    
    typedef table-config {
        type bits {
            bit DEPRECATED-MASK;
        }
    }  
      
    grouping table-feature-prop-type {
        choice table-feature-prop-type {
            case instructions { 
                container instructions {
                    uses flow:instruction-list;
                } 
            }
            
            case instructions-miss {   
                container instructions-miss {
                    uses flow:instruction-list;
                } 
            }

            case next-table {   
                container tables {
                    list table-id {
                        key "table";                        
                        
                        leaf table-id {
                            type table-ref;
                        } 
                    }
                } 
            }
            
            case next-table-miss {   
                container tables {
                    list table-id {
                        key "table-id";                        
                        
                        leaf table-id {
                            type table-ref;
                        } 
                    }
                } 
            }
            
            case write-actions {   
                container write-actions {
                    uses action:action-list;
                } 
            }
            
            case write-actions-miss {   
                container write-actions-miss {
                    uses action:action-list;
                } 
            }
            
            case apply-actions {   
                container apply-actions {
                    uses action:action-list;
                } 
            }
            
            case apply-actions-miss {   
                container apply-actions-miss {
                    uses action:action-list;
                } 
            }
            
            case match {   
                container matches {
                    leaf-list match {                                              
                        type uint32;
                    }
                } 
            }
            
            case wildcards {   
                container wildcards {
                    leaf-list wildcard {                                              
                        type uint32;
                    }
                } 
            }
            
            case write-setfield {   
                container write-setfield {
                    leaf-list setfield {                                              
                        type uint32;
                    }
                } 
            }
            
            case write-setfield-miss {   
                container write-setfield-miss {
                    leaf-list setfield {                                              
                        type uint32;
                    }
                } 
            }
            
            case apply-setfield {   
                container apply-setfield {
                    leaf-list setfield {                                              
                        type uint32;
                    }
                } 
            }
            
            case apply-setfield-miss {   
                container apply-setfield-miss {
                    leaf-list setfield {                                              
                        type uint32;
                    }
                } 
            }
        }
    } 
    
    grouping table-features {
        list table-features {
            key "table-id";
            
            leaf table-id {
                type table-ref;
            }      
            
            leaf name {
                description "Name of the table";
                type string;               
            }
            
            leaf metadata-match {
                description "Bits of metadata table can match";
                type uint64;                
            }
            
            leaf metadata-write {
                description "Bits of metadata table can write";
                type uint64;                
            }
            
            leaf max-entries {
                description "Max number of entries supported";
                type uint32;                
            }
            
            leaf config {
                description "Bitmap of OFPTC_ values";
                type table-config;
            }
            
            container table-properties {
                list instruction-id {
                    key "order";
                    leaf order {
                        type int32;
                    }
                    
                    uses table-feature-prop-type;
                }
            }
        }
    }    
}