opendaylight/md-sal/sal-rest-connector/src/test/resources/nn-to-json/list/list-types-module

   1 module simple-data-types {
   2   namespace "simple:data:types";
   3
   4   prefix "smpdtp";
   5   revision 2013-11-12 {
   6   }
   7
   8   identity iden {
   9   }
  10
  11   typedef tpdfempty {
  12         type empty;
  13   }
  14
  15   typedef tpdfbit {
  16         type bits {
  17                 bit b1;
  18                 bit b2;
  19                 bit b3;
  20         }
  21   }
  22
  23   typedef tpdfun4 {
  24         type boolean;
  25   }
  26
  27   typedef tpdfun3 {
  28         type union {
  29                 type tpdfbit;
  30                 type tpdfempty;
  31         }
  32   }
  33
  34   typedef tpdfun2 {
  35         type union {
  36                 type tpdfun3;
  37                 type tpdfun4;
  38         }
  39   }
  40
  41   typedef tpdfun1 {
  42         type union {
  43                 type uint8;
  44                 type decimal64 {
  45                         fraction-digits 2;
  46                 }
  47         }
  48   }
  49
  50   container cont {
  51           leaf lfnint8Min {
  52                 type int8;
  53           }
  54           leaf lfnint8Max {
  55                 type int8;
  56           }
  57           leaf lfnint16Min {
  58                 type int16;
  59           }
  60           leaf lfnint16Max {
  61                 type int16;
  62           }
  63           leaf lfnint32Min {
  64                 type int32;
  65           }
  66           leaf lfnint32Max {
  67                 type int32;
  68           }
  69           leaf lfnint64Min {
  70                 type int64;
  71           }
  72           leaf lfnint64Max {
  73                 type int64;
  74           }
  75
  76           leaf lfnuint8Max {
  77                 type uint8;
  78           }
  79           leaf lfnuint16Max {
  80                 type uint16;
  81           }
  82           leaf lfnuint32Max {
  83                 type uint32;
  84           }
  85           leaf lfuint64Max {
  86                 type uint64;
  87           }
  88           leaf lfstr {
  89                 type string;
  90           }
  91           leaf lfstr1 {
  92                 type string;
  93           }
  94           leaf lfbool1 {
  95                 type boolean;
  96           }
  97           leaf lfbool2 {
  98                 type boolean;
  99           }
 100           leaf lfbool3 {
 101                 type boolean;
 102           }
 103           leaf lfdecimal1 {
 104                 type decimal64 {
 105                         fraction-digits 2;
 106                 }
 107           }
 108           leaf lfdecimal2 {
 109                 type decimal64 {
 110                         fraction-digits 2;
 111                 }
 112           }
 113           leaf lfdecimal3 {
 114                 type decimal64 {
 115                         fraction-digits 2;
 116                 }
 117           }
 118
 119           leaf lfdecimal4 {
 120                 type decimal64 {
 121                         fraction-digits 2;
 122                 }
 123           }
 124
 125
 126           leaf lfdecimal6 {
 127                 type decimal64 {
 128                         fraction-digits 2;
 129                 }
 130           }
 131
 132     leaf lfenum {
 133       type enumeration {
 134         enum enum1;
 135         enum enum2;
 136         enum enum3;
 137         enum enum4;
 138       }
 139     }
 140
 141     leaf lfbits {
 142       type bits {
 143         bit bit1;
 144         bit bit2;
 145         bit bit3;
 146         bit bit4;
 147       }
 148     }
 149
 150     leaf lfbinary {
 151         type binary;
 152     }
 153
 154     leaf lfref1 {                  //reference to string type
 155         type leafref {
 156                 path "../lfstr";
 157         }
 158     }
 159
 160     leaf lfref2 {                  //reference to number type
 161         type leafref {
 162                 path "../lfnint8Max";
 163         }
 164     }
 165
 166     leaf lfempty {
 167         type empty;
 168     }
 169
 170     leaf lfunion1 {
 171         type union {
 172                 type uint16;
 173                 type string;
 174         }
 175     }
 176     leaf lfunion2 {
 177         type union {
 178                 type decimal64 {
 179                                 fraction-digits 2;
 180                 }
 181                 type string;
 182         }
 183     }
 184
 185     leaf lfunion3 {
 186         type union {
 187                 type empty;
 188                 type string;
 189         }
 190     }
 191
 192     leaf lfunion4 {
 193         type union {
 194                 type boolean;
 195                 type string;
 196         }
 197     }
 198
 199     leaf lfunion5 {
 200         type union {
 201                 type uint16;
 202                 type string;
 203         }
 204     }
 205
 206     leaf lfunion6 {
 207         type union {
 208                 type uint16;
 209                 type empty;
 210         }
 211     }
 212
 213     leaf lfunion7 {
 214                 type tpdfun3;
 215     }
 216
 217     leaf lfunion8 {
 218         type union {
 219                 type uint16;
 220                 type string;
 221         }
 222     }
 223
 224     leaf lfunion9 {
 225         type union {
 226                 type uint16;
 227                 type boolean;
 228         }
 229     }
 230
 231     leaf lfunion10 {
 232         type union {
 233                 type bits {
 234                         bit bt1;
 235                         bit bt2;
 236                 }
 237                 type boolean;
 238         }
 239     }
 240
 241     leaf lfunion11 {
 242                 type union {
 243                         type tpdfun1;
 244                         type tpdfun2;
 245                 }
 246     }
 247
 248     leaf lfunion12 {
 249                 type tpdfun2;
 250     }
 251
 252     leaf lfunion13 {
 253         type tpdfbit;
 254     }
 255
 256     leaf lfunion14 {
 257         type union {
 258             type enumeration {
 259                 enum zero;
 260                 enum one;
 261             }
 262             type uint16;
 263         }
 264     }
 265
 266     leaf identityref1 {
 267         type identityref {
 268             base iden;
 269         }
 270     }
 271
 272
 273   }
 274 }