mcs/class/Mono.PEToolkit/metadata/Tables.cs

   1 // Auto-generated file - DO NOT EDIT!\r
   2 // Please edit md-schema.xml or tabs.xsl if you want to make changes.\r
   3 \r
   4 using System;\r
   5 \r
   6 namespace Mono.PEToolkit.Metadata {\r
   7 \r
   8 \r
   9         public class ModuleTable : MDTableBase {\r
  10 \r
  11                 public ModuleTable(MDHeap heap)\r
  12                 : base(heap)\r
  13                 {\r
  14                 }\r
  15 \r
  16 \r
  17                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
  18                         for (int i = numRows; --i >= 0;) {\r
  19                                 Row row = new ModuleRow(this);\r
  20                                 row.FromRawData(buff, offs);\r
  21                                 Add(row);\r
  22                                 offs += ModuleRow.LogicalSize;\r
  23                         }\r
  24                 }\r
  25 \r
  26 \r
  27                 public override string Name {\r
  28                         get {\r
  29                                 return "Module";\r
  30                         }\r
  31                 }\r
  32 \r
  33                 public override TableId Id {\r
  34                         get {\r
  35                                 return TableId.Module;\r
  36                         }\r
  37                 }\r
  38         }\r
  39 \r
  40         public class TypeRefTable : MDTableBase {\r
  41 \r
  42                 public TypeRefTable(MDHeap heap)\r
  43                 : base(heap)\r
  44                 {\r
  45                 }\r
  46 \r
  47 \r
  48                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
  49                         for (int i = numRows; --i >= 0;) {\r
  50                                 Row row = new TypeRefRow(this);\r
  51                                 row.FromRawData(buff, offs);\r
  52                                 Add(row);\r
  53                                 offs += TypeRefRow.LogicalSize;\r
  54                         }\r
  55                 }\r
  56 \r
  57 \r
  58                 public override string Name {\r
  59                         get {\r
  60                                 return "TypeRef";\r
  61                         }\r
  62                 }\r
  63 \r
  64                 public override TableId Id {\r
  65                         get {\r
  66                                 return TableId.TypeRef;\r
  67                         }\r
  68                 }\r
  69         }\r
  70 \r
  71         public class TypeDefTable : MDTableBase {\r
  72 \r
  73                 public TypeDefTable(MDHeap heap)\r
  74                 : base(heap)\r
  75                 {\r
  76                 }\r
  77 \r
  78 \r
  79                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
  80                         for (int i = numRows; --i >= 0;) {\r
  81                                 Row row = new TypeDefRow(this);\r
  82                                 row.FromRawData(buff, offs);\r
  83                                 Add(row);\r
  84                                 offs += TypeDefRow.LogicalSize;\r
  85                         }\r
  86                 }\r
  87 \r
  88 \r
  89                 public override string Name {\r
  90                         get {\r
  91                                 return "TypeDef";\r
  92                         }\r
  93                 }\r
  94 \r
  95                 public override TableId Id {\r
  96                         get {\r
  97                                 return TableId.TypeDef;\r
  98                         }\r
  99                 }\r
 100         }\r
 101 \r
 102         public class FieldPtrTable : MDTableBase {\r
 103 \r
 104                 public FieldPtrTable(MDHeap heap)\r
 105                 : base(heap)\r
 106                 {\r
 107                 }\r
 108 \r
 109 \r
 110                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 111                         for (int i = numRows; --i >= 0;) {\r
 112                                 Row row = new FieldPtrRow(this);\r
 113                                 row.FromRawData(buff, offs);\r
 114                                 Add(row);\r
 115                                 offs += FieldPtrRow.LogicalSize;\r
 116                         }\r
 117                 }\r
 118 \r
 119 \r
 120                 public override string Name {\r
 121                         get {\r
 122                                 return "FieldPtr";\r
 123                         }\r
 124                 }\r
 125 \r
 126                 public override TableId Id {\r
 127                         get {\r
 128                                 return TableId.FieldPtr;\r
 129                         }\r
 130                 }\r
 131         }\r
 132 \r
 133         public class FieldTable : MDTableBase {\r
 134 \r
 135                 public FieldTable(MDHeap heap)\r
 136                 : base(heap)\r
 137                 {\r
 138                 }\r
 139 \r
 140 \r
 141                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 142                         for (int i = numRows; --i >= 0;) {\r
 143                                 Row row = new FieldRow(this);\r
 144                                 row.FromRawData(buff, offs);\r
 145                                 Add(row);\r
 146                                 offs += FieldRow.LogicalSize;\r
 147                         }\r
 148                 }\r
 149 \r
 150 \r
 151                 public override string Name {\r
 152                         get {\r
 153                                 return "Field";\r
 154                         }\r
 155                 }\r
 156 \r
 157                 public override TableId Id {\r
 158                         get {\r
 159                                 return TableId.Field;\r
 160                         }\r
 161                 }\r
 162         }\r
 163 \r
 164         public class MethodPtrTable : MDTableBase {\r
 165 \r
 166                 public MethodPtrTable(MDHeap heap)\r
 167                 : base(heap)\r
 168                 {\r
 169                 }\r
 170 \r
 171 \r
 172                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 173                         for (int i = numRows; --i >= 0;) {\r
 174                                 Row row = new MethodPtrRow(this);\r
 175                                 row.FromRawData(buff, offs);\r
 176                                 Add(row);\r
 177                                 offs += MethodPtrRow.LogicalSize;\r
 178                         }\r
 179                 }\r
 180 \r
 181 \r
 182                 public override string Name {\r
 183                         get {\r
 184                                 return "MethodPtr";\r
 185                         }\r
 186                 }\r
 187 \r
 188                 public override TableId Id {\r
 189                         get {\r
 190                                 return TableId.MethodPtr;\r
 191                         }\r
 192                 }\r
 193         }\r
 194 \r
 195         public class MethodTable : MDTableBase {\r
 196 \r
 197                 public MethodTable(MDHeap heap)\r
 198                 : base(heap)\r
 199                 {\r
 200                 }\r
 201 \r
 202 \r
 203                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 204                         for (int i = numRows; --i >= 0;) {\r
 205                                 Row row = new MethodRow(this);\r
 206                                 row.FromRawData(buff, offs);\r
 207                                 Add(row);\r
 208                                 offs += MethodRow.LogicalSize;\r
 209                         }\r
 210                 }\r
 211 \r
 212 \r
 213                 public override string Name {\r
 214                         get {\r
 215                                 return "Method";\r
 216                         }\r
 217                 }\r
 218 \r
 219                 public override TableId Id {\r
 220                         get {\r
 221                                 return TableId.Method;\r
 222                         }\r
 223                 }\r
 224         }\r
 225 \r
 226         public class ParamPtrTable : MDTableBase {\r
 227 \r
 228                 public ParamPtrTable(MDHeap heap)\r
 229                 : base(heap)\r
 230                 {\r
 231                 }\r
 232 \r
 233 \r
 234                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 235                         for (int i = numRows; --i >= 0;) {\r
 236                                 Row row = new ParamPtrRow(this);\r
 237                                 row.FromRawData(buff, offs);\r
 238                                 Add(row);\r
 239                                 offs += ParamPtrRow.LogicalSize;\r
 240                         }\r
 241                 }\r
 242 \r
 243 \r
 244                 public override string Name {\r
 245                         get {\r
 246                                 return "ParamPtr";\r
 247                         }\r
 248                 }\r
 249 \r
 250                 public override TableId Id {\r
 251                         get {\r
 252                                 return TableId.ParamPtr;\r
 253                         }\r
 254                 }\r
 255         }\r
 256 \r
 257         public class ParamTable : MDTableBase {\r
 258 \r
 259                 public ParamTable(MDHeap heap)\r
 260                 : base(heap)\r
 261                 {\r
 262                 }\r
 263 \r
 264 \r
 265                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 266                         for (int i = numRows; --i >= 0;) {\r
 267                                 Row row = new ParamRow(this);\r
 268                                 row.FromRawData(buff, offs);\r
 269                                 Add(row);\r
 270                                 offs += ParamRow.LogicalSize;\r
 271                         }\r
 272                 }\r
 273 \r
 274 \r
 275                 public override string Name {\r
 276                         get {\r
 277                                 return "Param";\r
 278                         }\r
 279                 }\r
 280 \r
 281                 public override TableId Id {\r
 282                         get {\r
 283                                 return TableId.Param;\r
 284                         }\r
 285                 }\r
 286         }\r
 287 \r
 288         public class InterfaceImplTable : MDTableBase {\r
 289 \r
 290                 public InterfaceImplTable(MDHeap heap)\r
 291                 : base(heap)\r
 292                 {\r
 293                 }\r
 294 \r
 295 \r
 296                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 297                         for (int i = numRows; --i >= 0;) {\r
 298                                 Row row = new InterfaceImplRow(this);\r
 299                                 row.FromRawData(buff, offs);\r
 300                                 Add(row);\r
 301                                 offs += InterfaceImplRow.LogicalSize;\r
 302                         }\r
 303                 }\r
 304 \r
 305 \r
 306                 public override string Name {\r
 307                         get {\r
 308                                 return "InterfaceImpl";\r
 309                         }\r
 310                 }\r
 311 \r
 312                 public override TableId Id {\r
 313                         get {\r
 314                                 return TableId.InterfaceImpl;\r
 315                         }\r
 316                 }\r
 317         }\r
 318 \r
 319         public class MemberRefTable : MDTableBase {\r
 320 \r
 321                 public MemberRefTable(MDHeap heap)\r
 322                 : base(heap)\r
 323                 {\r
 324                 }\r
 325 \r
 326 \r
 327                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 328                         for (int i = numRows; --i >= 0;) {\r
 329                                 Row row = new MemberRefRow(this);\r
 330                                 row.FromRawData(buff, offs);\r
 331                                 Add(row);\r
 332                                 offs += MemberRefRow.LogicalSize;\r
 333                         }\r
 334                 }\r
 335 \r
 336 \r
 337                 public override string Name {\r
 338                         get {\r
 339                                 return "MemberRef";\r
 340                         }\r
 341                 }\r
 342 \r
 343                 public override TableId Id {\r
 344                         get {\r
 345                                 return TableId.MemberRef;\r
 346                         }\r
 347                 }\r
 348         }\r
 349 \r
 350         public class ConstantTable : MDTableBase {\r
 351 \r
 352                 public ConstantTable(MDHeap heap)\r
 353                 : base(heap)\r
 354                 {\r
 355                 }\r
 356 \r
 357 \r
 358                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 359                         for (int i = numRows; --i >= 0;) {\r
 360                                 Row row = new ConstantRow(this);\r
 361                                 row.FromRawData(buff, offs);\r
 362                                 Add(row);\r
 363                                 offs += ConstantRow.LogicalSize;\r
 364                         }\r
 365                 }\r
 366 \r
 367 \r
 368                 public override string Name {\r
 369                         get {\r
 370                                 return "Constant";\r
 371                         }\r
 372                 }\r
 373 \r
 374                 public override TableId Id {\r
 375                         get {\r
 376                                 return TableId.Constant;\r
 377                         }\r
 378                 }\r
 379         }\r
 380 \r
 381         public class CustomAttributeTable : MDTableBase {\r
 382 \r
 383                 public CustomAttributeTable(MDHeap heap)\r
 384                 : base(heap)\r
 385                 {\r
 386                 }\r
 387 \r
 388 \r
 389                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 390                         for (int i = numRows; --i >= 0;) {\r
 391                                 Row row = new CustomAttributeRow(this);\r
 392                                 row.FromRawData(buff, offs);\r
 393                                 Add(row);\r
 394                                 offs += CustomAttributeRow.LogicalSize;\r
 395                         }\r
 396                 }\r
 397 \r
 398 \r
 399                 public override string Name {\r
 400                         get {\r
 401                                 return "CustomAttribute";\r
 402                         }\r
 403                 }\r
 404 \r
 405                 public override TableId Id {\r
 406                         get {\r
 407                                 return TableId.CustomAttribute;\r
 408                         }\r
 409                 }\r
 410         }\r
 411 \r
 412         public class FieldMarshalTable : MDTableBase {\r
 413 \r
 414                 public FieldMarshalTable(MDHeap heap)\r
 415                 : base(heap)\r
 416                 {\r
 417                 }\r
 418 \r
 419 \r
 420                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 421                         for (int i = numRows; --i >= 0;) {\r
 422                                 Row row = new FieldMarshalRow(this);\r
 423                                 row.FromRawData(buff, offs);\r
 424                                 Add(row);\r
 425                                 offs += FieldMarshalRow.LogicalSize;\r
 426                         }\r
 427                 }\r
 428 \r
 429 \r
 430                 public override string Name {\r
 431                         get {\r
 432                                 return "FieldMarshal";\r
 433                         }\r
 434                 }\r
 435 \r
 436                 public override TableId Id {\r
 437                         get {\r
 438                                 return TableId.FieldMarshal;\r
 439                         }\r
 440                 }\r
 441         }\r
 442 \r
 443         public class DeclSecurityTable : MDTableBase {\r
 444 \r
 445                 public DeclSecurityTable(MDHeap heap)\r
 446                 : base(heap)\r
 447                 {\r
 448                 }\r
 449 \r
 450 \r
 451                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 452                         for (int i = numRows; --i >= 0;) {\r
 453                                 Row row = new DeclSecurityRow(this);\r
 454                                 row.FromRawData(buff, offs);\r
 455                                 Add(row);\r
 456                                 offs += DeclSecurityRow.LogicalSize;\r
 457                         }\r
 458                 }\r
 459 \r
 460 \r
 461                 public override string Name {\r
 462                         get {\r
 463                                 return "DeclSecurity";\r
 464                         }\r
 465                 }\r
 466 \r
 467                 public override TableId Id {\r
 468                         get {\r
 469                                 return TableId.DeclSecurity;\r
 470                         }\r
 471                 }\r
 472         }\r
 473 \r
 474         public class ClassLayoutTable : MDTableBase {\r
 475 \r
 476                 public ClassLayoutTable(MDHeap heap)\r
 477                 : base(heap)\r
 478                 {\r
 479                 }\r
 480 \r
 481 \r
 482                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 483                         for (int i = numRows; --i >= 0;) {\r
 484                                 Row row = new ClassLayoutRow(this);\r
 485                                 row.FromRawData(buff, offs);\r
 486                                 Add(row);\r
 487                                 offs += ClassLayoutRow.LogicalSize;\r
 488                         }\r
 489                 }\r
 490 \r
 491 \r
 492                 public override string Name {\r
 493                         get {\r
 494                                 return "ClassLayout";\r
 495                         }\r
 496                 }\r
 497 \r
 498                 public override TableId Id {\r
 499                         get {\r
 500                                 return TableId.ClassLayout;\r
 501                         }\r
 502                 }\r
 503         }\r
 504 \r
 505         public class FieldLayoutTable : MDTableBase {\r
 506 \r
 507                 public FieldLayoutTable(MDHeap heap)\r
 508                 : base(heap)\r
 509                 {\r
 510                 }\r
 511 \r
 512 \r
 513                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 514                         for (int i = numRows; --i >= 0;) {\r
 515                                 Row row = new FieldLayoutRow(this);\r
 516                                 row.FromRawData(buff, offs);\r
 517                                 Add(row);\r
 518                                 offs += FieldLayoutRow.LogicalSize;\r
 519                         }\r
 520                 }\r
 521 \r
 522 \r
 523                 public override string Name {\r
 524                         get {\r
 525                                 return "FieldLayout";\r
 526                         }\r
 527                 }\r
 528 \r
 529                 public override TableId Id {\r
 530                         get {\r
 531                                 return TableId.FieldLayout;\r
 532                         }\r
 533                 }\r
 534         }\r
 535 \r
 536         public class StandAloneSigTable : MDTableBase {\r
 537 \r
 538                 public StandAloneSigTable(MDHeap heap)\r
 539                 : base(heap)\r
 540                 {\r
 541                 }\r
 542 \r
 543 \r
 544                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 545                         for (int i = numRows; --i >= 0;) {\r
 546                                 Row row = new StandAloneSigRow(this);\r
 547                                 row.FromRawData(buff, offs);\r
 548                                 Add(row);\r
 549                                 offs += StandAloneSigRow.LogicalSize;\r
 550                         }\r
 551                 }\r
 552 \r
 553 \r
 554                 public override string Name {\r
 555                         get {\r
 556                                 return "StandAloneSig";\r
 557                         }\r
 558                 }\r
 559 \r
 560                 public override TableId Id {\r
 561                         get {\r
 562                                 return TableId.StandAloneSig;\r
 563                         }\r
 564                 }\r
 565         }\r
 566 \r
 567         public class EventMapTable : MDTableBase {\r
 568 \r
 569                 public EventMapTable(MDHeap heap)\r
 570                 : base(heap)\r
 571                 {\r
 572                 }\r
 573 \r
 574 \r
 575                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 576                         for (int i = numRows; --i >= 0;) {\r
 577                                 Row row = new EventMapRow(this);\r
 578                                 row.FromRawData(buff, offs);\r
 579                                 Add(row);\r
 580                                 offs += EventMapRow.LogicalSize;\r
 581                         }\r
 582                 }\r
 583 \r
 584 \r
 585                 public override string Name {\r
 586                         get {\r
 587                                 return "EventMap";\r
 588                         }\r
 589                 }\r
 590 \r
 591                 public override TableId Id {\r
 592                         get {\r
 593                                 return TableId.EventMap;\r
 594                         }\r
 595                 }\r
 596         }\r
 597 \r
 598         public class EventPtrTable : MDTableBase {\r
 599 \r
 600                 public EventPtrTable(MDHeap heap)\r
 601                 : base(heap)\r
 602                 {\r
 603                 }\r
 604 \r
 605 \r
 606                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 607                         for (int i = numRows; --i >= 0;) {\r
 608                                 Row row = new EventPtrRow(this);\r
 609                                 row.FromRawData(buff, offs);\r
 610                                 Add(row);\r
 611                                 offs += EventPtrRow.LogicalSize;\r
 612                         }\r
 613                 }\r
 614 \r
 615 \r
 616                 public override string Name {\r
 617                         get {\r
 618                                 return "EventPtr";\r
 619                         }\r
 620                 }\r
 621 \r
 622                 public override TableId Id {\r
 623                         get {\r
 624                                 return TableId.EventPtr;\r
 625                         }\r
 626                 }\r
 627         }\r
 628 \r
 629         public class EventTable : MDTableBase {\r
 630 \r
 631                 public EventTable(MDHeap heap)\r
 632                 : base(heap)\r
 633                 {\r
 634                 }\r
 635 \r
 636 \r
 637                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 638                         for (int i = numRows; --i >= 0;) {\r
 639                                 Row row = new EventRow(this);\r
 640                                 row.FromRawData(buff, offs);\r
 641                                 Add(row);\r
 642                                 offs += EventRow.LogicalSize;\r
 643                         }\r
 644                 }\r
 645 \r
 646 \r
 647                 public override string Name {\r
 648                         get {\r
 649                                 return "Event";\r
 650                         }\r
 651                 }\r
 652 \r
 653                 public override TableId Id {\r
 654                         get {\r
 655                                 return TableId.Event;\r
 656                         }\r
 657                 }\r
 658         }\r
 659 \r
 660         public class PropertyMapTable : MDTableBase {\r
 661 \r
 662                 public PropertyMapTable(MDHeap heap)\r
 663                 : base(heap)\r
 664                 {\r
 665                 }\r
 666 \r
 667 \r
 668                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 669                         for (int i = numRows; --i >= 0;) {\r
 670                                 Row row = new PropertyMapRow(this);\r
 671                                 row.FromRawData(buff, offs);\r
 672                                 Add(row);\r
 673                                 offs += PropertyMapRow.LogicalSize;\r
 674                         }\r
 675                 }\r
 676 \r
 677 \r
 678                 public override string Name {\r
 679                         get {\r
 680                                 return "PropertyMap";\r
 681                         }\r
 682                 }\r
 683 \r
 684                 public override TableId Id {\r
 685                         get {\r
 686                                 return TableId.PropertyMap;\r
 687                         }\r
 688                 }\r
 689         }\r
 690 \r
 691         public class PropertyPtrTable : MDTableBase {\r
 692 \r
 693                 public PropertyPtrTable(MDHeap heap)\r
 694                 : base(heap)\r
 695                 {\r
 696                 }\r
 697 \r
 698 \r
 699                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 700                         for (int i = numRows; --i >= 0;) {\r
 701                                 Row row = new PropertyPtrRow(this);\r
 702                                 row.FromRawData(buff, offs);\r
 703                                 Add(row);\r
 704                                 offs += PropertyPtrRow.LogicalSize;\r
 705                         }\r
 706                 }\r
 707 \r
 708 \r
 709                 public override string Name {\r
 710                         get {\r
 711                                 return "PropertyPtr";\r
 712                         }\r
 713                 }\r
 714 \r
 715                 public override TableId Id {\r
 716                         get {\r
 717                                 return TableId.PropertyPtr;\r
 718                         }\r
 719                 }\r
 720         }\r
 721 \r
 722         public class PropertyTable : MDTableBase {\r
 723 \r
 724                 public PropertyTable(MDHeap heap)\r
 725                 : base(heap)\r
 726                 {\r
 727                 }\r
 728 \r
 729 \r
 730                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 731                         for (int i = numRows; --i >= 0;) {\r
 732                                 Row row = new PropertyRow(this);\r
 733                                 row.FromRawData(buff, offs);\r
 734                                 Add(row);\r
 735                                 offs += PropertyRow.LogicalSize;\r
 736                         }\r
 737                 }\r
 738 \r
 739 \r
 740                 public override string Name {\r
 741                         get {\r
 742                                 return "Property";\r
 743                         }\r
 744                 }\r
 745 \r
 746                 public override TableId Id {\r
 747                         get {\r
 748                                 return TableId.Property;\r
 749                         }\r
 750                 }\r
 751         }\r
 752 \r
 753         public class MethodSemanticsTable : MDTableBase {\r
 754 \r
 755                 public MethodSemanticsTable(MDHeap heap)\r
 756                 : base(heap)\r
 757                 {\r
 758                 }\r
 759 \r
 760 \r
 761                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 762                         for (int i = numRows; --i >= 0;) {\r
 763                                 Row row = new MethodSemanticsRow(this);\r
 764                                 row.FromRawData(buff, offs);\r
 765                                 Add(row);\r
 766                                 offs += MethodSemanticsRow.LogicalSize;\r
 767                         }\r
 768                 }\r
 769 \r
 770 \r
 771                 public override string Name {\r
 772                         get {\r
 773                                 return "MethodSemantics";\r
 774                         }\r
 775                 }\r
 776 \r
 777                 public override TableId Id {\r
 778                         get {\r
 779                                 return TableId.MethodSemantics;\r
 780                         }\r
 781                 }\r
 782         }\r
 783 \r
 784         public class MethodImplTable : MDTableBase {\r
 785 \r
 786                 public MethodImplTable(MDHeap heap)\r
 787                 : base(heap)\r
 788                 {\r
 789                 }\r
 790 \r
 791 \r
 792                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 793                         for (int i = numRows; --i >= 0;) {\r
 794                                 Row row = new MethodImplRow(this);\r
 795                                 row.FromRawData(buff, offs);\r
 796                                 Add(row);\r
 797                                 offs += MethodImplRow.LogicalSize;\r
 798                         }\r
 799                 }\r
 800 \r
 801 \r
 802                 public override string Name {\r
 803                         get {\r
 804                                 return "MethodImpl";\r
 805                         }\r
 806                 }\r
 807 \r
 808                 public override TableId Id {\r
 809                         get {\r
 810                                 return TableId.MethodImpl;\r
 811                         }\r
 812                 }\r
 813         }\r
 814 \r
 815         public class ModuleRefTable : MDTableBase {\r
 816 \r
 817                 public ModuleRefTable(MDHeap heap)\r
 818                 : base(heap)\r
 819                 {\r
 820                 }\r
 821 \r
 822 \r
 823                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 824                         for (int i = numRows; --i >= 0;) {\r
 825                                 Row row = new ModuleRefRow(this);\r
 826                                 row.FromRawData(buff, offs);\r
 827                                 Add(row);\r
 828                                 offs += ModuleRefRow.LogicalSize;\r
 829                         }\r
 830                 }\r
 831 \r
 832 \r
 833                 public override string Name {\r
 834                         get {\r
 835                                 return "ModuleRef";\r
 836                         }\r
 837                 }\r
 838 \r
 839                 public override TableId Id {\r
 840                         get {\r
 841                                 return TableId.ModuleRef;\r
 842                         }\r
 843                 }\r
 844         }\r
 845 \r
 846         public class TypeSpecTable : MDTableBase {\r
 847 \r
 848                 public TypeSpecTable(MDHeap heap)\r
 849                 : base(heap)\r
 850                 {\r
 851                 }\r
 852 \r
 853 \r
 854                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 855                         for (int i = numRows; --i >= 0;) {\r
 856                                 Row row = new TypeSpecRow(this);\r
 857                                 row.FromRawData(buff, offs);\r
 858                                 Add(row);\r
 859                                 offs += TypeSpecRow.LogicalSize;\r
 860                         }\r
 861                 }\r
 862 \r
 863 \r
 864                 public override string Name {\r
 865                         get {\r
 866                                 return "TypeSpec";\r
 867                         }\r
 868                 }\r
 869 \r
 870                 public override TableId Id {\r
 871                         get {\r
 872                                 return TableId.TypeSpec;\r
 873                         }\r
 874                 }\r
 875         }\r
 876 \r
 877         public class ImplMapTable : MDTableBase {\r
 878 \r
 879                 public ImplMapTable(MDHeap heap)\r
 880                 : base(heap)\r
 881                 {\r
 882                 }\r
 883 \r
 884 \r
 885                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 886                         for (int i = numRows; --i >= 0;) {\r
 887                                 Row row = new ImplMapRow(this);\r
 888                                 row.FromRawData(buff, offs);\r
 889                                 Add(row);\r
 890                                 offs += ImplMapRow.LogicalSize;\r
 891                         }\r
 892                 }\r
 893 \r
 894 \r
 895                 public override string Name {\r
 896                         get {\r
 897                                 return "ImplMap";\r
 898                         }\r
 899                 }\r
 900 \r
 901                 public override TableId Id {\r
 902                         get {\r
 903                                 return TableId.ImplMap;\r
 904                         }\r
 905                 }\r
 906         }\r
 907 \r
 908         public class FieldRVATable : MDTableBase {\r
 909 \r
 910                 public FieldRVATable(MDHeap heap)\r
 911                 : base(heap)\r
 912                 {\r
 913                 }\r
 914 \r
 915 \r
 916                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 917                         for (int i = numRows; --i >= 0;) {\r
 918                                 Row row = new FieldRVARow(this);\r
 919                                 row.FromRawData(buff, offs);\r
 920                                 Add(row);\r
 921                                 offs += FieldRVARow.LogicalSize;\r
 922                         }\r
 923                 }\r
 924 \r
 925 \r
 926                 public override string Name {\r
 927                         get {\r
 928                                 return "FieldRVA";\r
 929                         }\r
 930                 }\r
 931 \r
 932                 public override TableId Id {\r
 933                         get {\r
 934                                 return TableId.FieldRVA;\r
 935                         }\r
 936                 }\r
 937         }\r
 938 \r
 939         public class ENCLogTable : MDTableBase {\r
 940 \r
 941                 public ENCLogTable(MDHeap heap)\r
 942                 : base(heap)\r
 943                 {\r
 944                 }\r
 945 \r
 946 \r
 947                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 948                         for (int i = numRows; --i >= 0;) {\r
 949                                 Row row = new ENCLogRow(this);\r
 950                                 row.FromRawData(buff, offs);\r
 951                                 Add(row);\r
 952                                 offs += ENCLogRow.LogicalSize;\r
 953                         }\r
 954                 }\r
 955 \r
 956 \r
 957                 public override string Name {\r
 958                         get {\r
 959                                 return "ENCLog";\r
 960                         }\r
 961                 }\r
 962 \r
 963                 public override TableId Id {\r
 964                         get {\r
 965                                 return TableId.ENCLog;\r
 966                         }\r
 967                 }\r
 968         }\r
 969 \r
 970         public class ENCMapTable : MDTableBase {\r
 971 \r
 972                 public ENCMapTable(MDHeap heap)\r
 973                 : base(heap)\r
 974                 {\r
 975                 }\r
 976 \r
 977 \r
 978                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
 979                         for (int i = numRows; --i >= 0;) {\r
 980                                 Row row = new ENCMapRow(this);\r
 981                                 row.FromRawData(buff, offs);\r
 982                                 Add(row);\r
 983                                 offs += ENCMapRow.LogicalSize;\r
 984                         }\r
 985                 }\r
 986 \r
 987 \r
 988                 public override string Name {\r
 989                         get {\r
 990                                 return "ENCMap";\r
 991                         }\r
 992                 }\r
 993 \r
 994                 public override TableId Id {\r
 995                         get {\r
 996                                 return TableId.ENCMap;\r
 997                         }\r
 998                 }\r
 999         }\r
1000 \r
1001         public class AssemblyTable : MDTableBase {\r
1002 \r
1003                 public AssemblyTable(MDHeap heap)\r
1004                 : base(heap)\r
1005                 {\r
1006                 }\r
1007 \r
1008 \r
1009                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1010                         for (int i = numRows; --i >= 0;) {\r
1011                                 Row row = new AssemblyRow(this);\r
1012                                 row.FromRawData(buff, offs);\r
1013                                 Add(row);\r
1014                                 offs += AssemblyRow.LogicalSize;\r
1015                         }\r
1016                 }\r
1017 \r
1018 \r
1019                 public override string Name {\r
1020                         get {\r
1021                                 return "Assembly";\r
1022                         }\r
1023                 }\r
1024 \r
1025                 public override TableId Id {\r
1026                         get {\r
1027                                 return TableId.Assembly;\r
1028                         }\r
1029                 }\r
1030         }\r
1031 \r
1032         public class AssemblyProcessorTable : MDTableBase {\r
1033 \r
1034                 public AssemblyProcessorTable(MDHeap heap)\r
1035                 : base(heap)\r
1036                 {\r
1037                 }\r
1038 \r
1039 \r
1040                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1041                         for (int i = numRows; --i >= 0;) {\r
1042                                 Row row = new AssemblyProcessorRow(this);\r
1043                                 row.FromRawData(buff, offs);\r
1044                                 Add(row);\r
1045                                 offs += AssemblyProcessorRow.LogicalSize;\r
1046                         }\r
1047                 }\r
1048 \r
1049 \r
1050                 public override string Name {\r
1051                         get {\r
1052                                 return "AssemblyProcessor";\r
1053                         }\r
1054                 }\r
1055 \r
1056                 public override TableId Id {\r
1057                         get {\r
1058                                 return TableId.AssemblyProcessor;\r
1059                         }\r
1060                 }\r
1061         }\r
1062 \r
1063         public class AssemblyOSTable : MDTableBase {\r
1064 \r
1065                 public AssemblyOSTable(MDHeap heap)\r
1066                 : base(heap)\r
1067                 {\r
1068                 }\r
1069 \r
1070 \r
1071                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1072                         for (int i = numRows; --i >= 0;) {\r
1073                                 Row row = new AssemblyOSRow(this);\r
1074                                 row.FromRawData(buff, offs);\r
1075                                 Add(row);\r
1076                                 offs += AssemblyOSRow.LogicalSize;\r
1077                         }\r
1078                 }\r
1079 \r
1080 \r
1081                 public override string Name {\r
1082                         get {\r
1083                                 return "AssemblyOS";\r
1084                         }\r
1085                 }\r
1086 \r
1087                 public override TableId Id {\r
1088                         get {\r
1089                                 return TableId.AssemblyOS;\r
1090                         }\r
1091                 }\r
1092         }\r
1093 \r
1094         public class AssemblyRefTable : MDTableBase {\r
1095 \r
1096                 public AssemblyRefTable(MDHeap heap)\r
1097                 : base(heap)\r
1098                 {\r
1099                 }\r
1100 \r
1101 \r
1102                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1103                         for (int i = numRows; --i >= 0;) {\r
1104                                 Row row = new AssemblyRefRow(this);\r
1105                                 row.FromRawData(buff, offs);\r
1106                                 Add(row);\r
1107                                 offs += AssemblyRefRow.LogicalSize;\r
1108                         }\r
1109                 }\r
1110 \r
1111 \r
1112                 public override string Name {\r
1113                         get {\r
1114                                 return "AssemblyRef";\r
1115                         }\r
1116                 }\r
1117 \r
1118                 public override TableId Id {\r
1119                         get {\r
1120                                 return TableId.AssemblyRef;\r
1121                         }\r
1122                 }\r
1123         }\r
1124 \r
1125         public class AssemblyRefProcessorTable : MDTableBase {\r
1126 \r
1127                 public AssemblyRefProcessorTable(MDHeap heap)\r
1128                 : base(heap)\r
1129                 {\r
1130                 }\r
1131 \r
1132 \r
1133                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1134                         for (int i = numRows; --i >= 0;) {\r
1135                                 Row row = new AssemblyRefProcessorRow(this);\r
1136                                 row.FromRawData(buff, offs);\r
1137                                 Add(row);\r
1138                                 offs += AssemblyRefProcessorRow.LogicalSize;\r
1139                         }\r
1140                 }\r
1141 \r
1142 \r
1143                 public override string Name {\r
1144                         get {\r
1145                                 return "AssemblyRefProcessor";\r
1146                         }\r
1147                 }\r
1148 \r
1149                 public override TableId Id {\r
1150                         get {\r
1151                                 return TableId.AssemblyRefProcessor;\r
1152                         }\r
1153                 }\r
1154         }\r
1155 \r
1156         public class AssemblyRefOSTable : MDTableBase {\r
1157 \r
1158                 public AssemblyRefOSTable(MDHeap heap)\r
1159                 : base(heap)\r
1160                 {\r
1161                 }\r
1162 \r
1163 \r
1164                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1165                         for (int i = numRows; --i >= 0;) {\r
1166                                 Row row = new AssemblyRefOSRow(this);\r
1167                                 row.FromRawData(buff, offs);\r
1168                                 Add(row);\r
1169                                 offs += AssemblyRefOSRow.LogicalSize;\r
1170                         }\r
1171                 }\r
1172 \r
1173 \r
1174                 public override string Name {\r
1175                         get {\r
1176                                 return "AssemblyRefOS";\r
1177                         }\r
1178                 }\r
1179 \r
1180                 public override TableId Id {\r
1181                         get {\r
1182                                 return TableId.AssemblyRefOS;\r
1183                         }\r
1184                 }\r
1185         }\r
1186 \r
1187         public class FileTable : MDTableBase {\r
1188 \r
1189                 public FileTable(MDHeap heap)\r
1190                 : base(heap)\r
1191                 {\r
1192                 }\r
1193 \r
1194 \r
1195                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1196                         for (int i = numRows; --i >= 0;) {\r
1197                                 Row row = new FileRow(this);\r
1198                                 row.FromRawData(buff, offs);\r
1199                                 Add(row);\r
1200                                 offs += FileRow.LogicalSize;\r
1201                         }\r
1202                 }\r
1203 \r
1204 \r
1205                 public override string Name {\r
1206                         get {\r
1207                                 return "File";\r
1208                         }\r
1209                 }\r
1210 \r
1211                 public override TableId Id {\r
1212                         get {\r
1213                                 return TableId.File;\r
1214                         }\r
1215                 }\r
1216         }\r
1217 \r
1218         public class ExportedTypeTable : MDTableBase {\r
1219 \r
1220                 public ExportedTypeTable(MDHeap heap)\r
1221                 : base(heap)\r
1222                 {\r
1223                 }\r
1224 \r
1225 \r
1226                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1227                         for (int i = numRows; --i >= 0;) {\r
1228                                 Row row = new ExportedTypeRow(this);\r
1229                                 row.FromRawData(buff, offs);\r
1230                                 Add(row);\r
1231                                 offs += ExportedTypeRow.LogicalSize;\r
1232                         }\r
1233                 }\r
1234 \r
1235 \r
1236                 public override string Name {\r
1237                         get {\r
1238                                 return "ExportedType";\r
1239                         }\r
1240                 }\r
1241 \r
1242                 public override TableId Id {\r
1243                         get {\r
1244                                 return TableId.ExportedType;\r
1245                         }\r
1246                 }\r
1247         }\r
1248 \r
1249         public class ManifestResourceTable : MDTableBase {\r
1250 \r
1251                 public ManifestResourceTable(MDHeap heap)\r
1252                 : base(heap)\r
1253                 {\r
1254                 }\r
1255 \r
1256 \r
1257                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1258                         for (int i = numRows; --i >= 0;) {\r
1259                                 Row row = new ManifestResourceRow(this);\r
1260                                 row.FromRawData(buff, offs);\r
1261                                 Add(row);\r
1262                                 offs += ManifestResourceRow.LogicalSize;\r
1263                         }\r
1264                 }\r
1265 \r
1266 \r
1267                 public override string Name {\r
1268                         get {\r
1269                                 return "ManifestResource";\r
1270                         }\r
1271                 }\r
1272 \r
1273                 public override TableId Id {\r
1274                         get {\r
1275                                 return TableId.ManifestResource;\r
1276                         }\r
1277                 }\r
1278         }\r
1279 \r
1280         public class NestedClassTable : MDTableBase {\r
1281 \r
1282                 public NestedClassTable(MDHeap heap)\r
1283                 : base(heap)\r
1284                 {\r
1285                 }\r
1286 \r
1287 \r
1288                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1289                         for (int i = numRows; --i >= 0;) {\r
1290                                 Row row = new NestedClassRow(this);\r
1291                                 row.FromRawData(buff, offs);\r
1292                                 Add(row);\r
1293                                 offs += NestedClassRow.LogicalSize;\r
1294                         }\r
1295                 }\r
1296 \r
1297 \r
1298                 public override string Name {\r
1299                         get {\r
1300                                 return "NestedClass";\r
1301                         }\r
1302                 }\r
1303 \r
1304                 public override TableId Id {\r
1305                         get {\r
1306                                 return TableId.NestedClass;\r
1307                         }\r
1308                 }\r
1309         }\r
1310 \r
1311         public class TypeTyParTable : MDTableBase {\r
1312 \r
1313                 public TypeTyParTable(MDHeap heap)\r
1314                 : base(heap)\r
1315                 {\r
1316                 }\r
1317 \r
1318 \r
1319                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1320                         for (int i = numRows; --i >= 0;) {\r
1321                                 Row row = new TypeTyParRow(this);\r
1322                                 row.FromRawData(buff, offs);\r
1323                                 Add(row);\r
1324                                 offs += TypeTyParRow.LogicalSize;\r
1325                         }\r
1326                 }\r
1327 \r
1328 \r
1329                 public override string Name {\r
1330                         get {\r
1331                                 return "TypeTyPar";\r
1332                         }\r
1333                 }\r
1334 \r
1335                 public override TableId Id {\r
1336                         get {\r
1337                                 return TableId.TypeTyPar;\r
1338                         }\r
1339                 }\r
1340         }\r
1341 \r
1342         public class MethodTyParTable : MDTableBase {\r
1343 \r
1344                 public MethodTyParTable(MDHeap heap)\r
1345                 : base(heap)\r
1346                 {\r
1347                 }\r
1348 \r
1349 \r
1350                 public override void FromRawData(byte [] buff, int offs, int numRows) {\r
1351                         for (int i = numRows; --i >= 0;) {\r
1352                                 Row row = new MethodTyParRow(this);\r
1353                                 row.FromRawData(buff, offs);\r
1354                                 Add(row);\r
1355                                 offs += MethodTyParRow.LogicalSize;\r
1356                         }\r
1357                 }\r
1358 \r
1359 \r
1360                 public override string Name {\r
1361                         get {\r
1362                                 return "MethodTyPar";\r
1363                         }\r
1364                 }\r
1365 \r
1366                 public override TableId Id {\r
1367                         get {\r
1368                                 return TableId.MethodTyPar;\r
1369                         }\r
1370                 }\r
1371         }\r
1372 \r
1373 \r
1374 }\r
1375 \r