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

   1 // Auto-generated file - DO NOT EDIT!\r
   2 // Please edit md-schema.xml or tabs-base.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         /// <summary>\r
  10         /// </summary>\r
  11         /// <remarks>\r
  12         /// </remarks>\r
  13         public abstract class TablesHeapBase : MDHeap {\r
  14 \r
  15                 internal TablesHeapBase(MDStream stream) : base(stream)\r
  16                 {\r
  17                 }\r
  18 \r
  19                 /// <summary>\r
  20                 /// Gets or sets bitvector of valid tables (64-bit).\r
  21                 /// </summary>\r
  22                 public abstract long Valid {get; set;}\r
  23 \r
  24                 /// <summary>\r
  25                 /// Gets or sets bitvector of sorted tables (64-bit).\r
  26                 /// </summary>\r
  27                 public abstract long Sorted {get; set;}\r
  28 \r
  29 \r
  30                 //\r
  31                 // Accessors to decode Valid bitvector.\r
  32                 //\r
  33 \r
  34 \r
  35                 /// <summary>\r
  36                 /// True if heap has Module table.\r
  37                 /// </summary>\r
  38                 public bool HasModule {\r
  39                         get {\r
  40                                 return (Valid & (1L << 0x00)) != 0;\r
  41                         }\r
  42                         set {\r
  43                                 long mask = (1L << 0x00);\r
  44                                 if (value) {\r
  45                                         Valid |= mask;\r
  46                                 } else {\r
  47                                         Valid &= ~mask;\r
  48                                 }\r
  49                         }\r
  50                 }\r
  51 \r
  52                 /// <summary>\r
  53                 /// True if heap has TypeRef table.\r
  54                 /// </summary>\r
  55                 public bool HasTypeRef {\r
  56                         get {\r
  57                                 return (Valid & (1L << 0x01)) != 0;\r
  58                         }\r
  59                         set {\r
  60                                 long mask = (1L << 0x01);\r
  61                                 if (value) {\r
  62                                         Valid |= mask;\r
  63                                 } else {\r
  64                                         Valid &= ~mask;\r
  65                                 }\r
  66                         }\r
  67                 }\r
  68 \r
  69                 /// <summary>\r
  70                 /// True if heap has TypeDef table.\r
  71                 /// </summary>\r
  72                 public bool HasTypeDef {\r
  73                         get {\r
  74                                 return (Valid & (1L << 0x02)) != 0;\r
  75                         }\r
  76                         set {\r
  77                                 long mask = (1L << 0x02);\r
  78                                 if (value) {\r
  79                                         Valid |= mask;\r
  80                                 } else {\r
  81                                         Valid &= ~mask;\r
  82                                 }\r
  83                         }\r
  84                 }\r
  85 \r
  86                 /// <summary>\r
  87                 /// True if heap has FieldPtr table.\r
  88                 /// </summary>\r
  89                 public bool HasFieldPtr {\r
  90                         get {\r
  91                                 return (Valid & (1L << 0x03)) != 0;\r
  92                         }\r
  93                         set {\r
  94                                 long mask = (1L << 0x03);\r
  95                                 if (value) {\r
  96                                         Valid |= mask;\r
  97                                 } else {\r
  98                                         Valid &= ~mask;\r
  99                                 }\r
 100                         }\r
 101                 }\r
 102 \r
 103                 /// <summary>\r
 104                 /// True if heap has Field table.\r
 105                 /// </summary>\r
 106                 public bool HasField {\r
 107                         get {\r
 108                                 return (Valid & (1L << 0x04)) != 0;\r
 109                         }\r
 110                         set {\r
 111                                 long mask = (1L << 0x04);\r
 112                                 if (value) {\r
 113                                         Valid |= mask;\r
 114                                 } else {\r
 115                                         Valid &= ~mask;\r
 116                                 }\r
 117                         }\r
 118                 }\r
 119 \r
 120                 /// <summary>\r
 121                 /// True if heap has MethodPtr table.\r
 122                 /// </summary>\r
 123                 public bool HasMethodPtr {\r
 124                         get {\r
 125                                 return (Valid & (1L << 0x05)) != 0;\r
 126                         }\r
 127                         set {\r
 128                                 long mask = (1L << 0x05);\r
 129                                 if (value) {\r
 130                                         Valid |= mask;\r
 131                                 } else {\r
 132                                         Valid &= ~mask;\r
 133                                 }\r
 134                         }\r
 135                 }\r
 136 \r
 137                 /// <summary>\r
 138                 /// True if heap has Method table.\r
 139                 /// </summary>\r
 140                 public bool HasMethod {\r
 141                         get {\r
 142                                 return (Valid & (1L << 0x06)) != 0;\r
 143                         }\r
 144                         set {\r
 145                                 long mask = (1L << 0x06);\r
 146                                 if (value) {\r
 147                                         Valid |= mask;\r
 148                                 } else {\r
 149                                         Valid &= ~mask;\r
 150                                 }\r
 151                         }\r
 152                 }\r
 153 \r
 154                 /// <summary>\r
 155                 /// True if heap has ParamPtr table.\r
 156                 /// </summary>\r
 157                 public bool HasParamPtr {\r
 158                         get {\r
 159                                 return (Valid & (1L << 0x07)) != 0;\r
 160                         }\r
 161                         set {\r
 162                                 long mask = (1L << 0x07);\r
 163                                 if (value) {\r
 164                                         Valid |= mask;\r
 165                                 } else {\r
 166                                         Valid &= ~mask;\r
 167                                 }\r
 168                         }\r
 169                 }\r
 170 \r
 171                 /// <summary>\r
 172                 /// True if heap has Param table.\r
 173                 /// </summary>\r
 174                 public bool HasParam {\r
 175                         get {\r
 176                                 return (Valid & (1L << 0x08)) != 0;\r
 177                         }\r
 178                         set {\r
 179                                 long mask = (1L << 0x08);\r
 180                                 if (value) {\r
 181                                         Valid |= mask;\r
 182                                 } else {\r
 183                                         Valid &= ~mask;\r
 184                                 }\r
 185                         }\r
 186                 }\r
 187 \r
 188                 /// <summary>\r
 189                 /// True if heap has InterfaceImpl table.\r
 190                 /// </summary>\r
 191                 public bool HasInterfaceImpl {\r
 192                         get {\r
 193                                 return (Valid & (1L << 0x09)) != 0;\r
 194                         }\r
 195                         set {\r
 196                                 long mask = (1L << 0x09);\r
 197                                 if (value) {\r
 198                                         Valid |= mask;\r
 199                                 } else {\r
 200                                         Valid &= ~mask;\r
 201                                 }\r
 202                         }\r
 203                 }\r
 204 \r
 205                 /// <summary>\r
 206                 /// True if heap has MemberRef table.\r
 207                 /// </summary>\r
 208                 public bool HasMemberRef {\r
 209                         get {\r
 210                                 return (Valid & (1L << 0x0a)) != 0;\r
 211                         }\r
 212                         set {\r
 213                                 long mask = (1L << 0x0a);\r
 214                                 if (value) {\r
 215                                         Valid |= mask;\r
 216                                 } else {\r
 217                                         Valid &= ~mask;\r
 218                                 }\r
 219                         }\r
 220                 }\r
 221 \r
 222                 /// <summary>\r
 223                 /// True if heap has Constant table.\r
 224                 /// </summary>\r
 225                 public bool HasConstant {\r
 226                         get {\r
 227                                 return (Valid & (1L << 0x0b)) != 0;\r
 228                         }\r
 229                         set {\r
 230                                 long mask = (1L << 0x0b);\r
 231                                 if (value) {\r
 232                                         Valid |= mask;\r
 233                                 } else {\r
 234                                         Valid &= ~mask;\r
 235                                 }\r
 236                         }\r
 237                 }\r
 238 \r
 239                 /// <summary>\r
 240                 /// True if heap has CustomAttribute table.\r
 241                 /// </summary>\r
 242                 public bool HasCustomAttribute {\r
 243                         get {\r
 244                                 return (Valid & (1L << 0x0c)) != 0;\r
 245                         }\r
 246                         set {\r
 247                                 long mask = (1L << 0x0c);\r
 248                                 if (value) {\r
 249                                         Valid |= mask;\r
 250                                 } else {\r
 251                                         Valid &= ~mask;\r
 252                                 }\r
 253                         }\r
 254                 }\r
 255 \r
 256                 /// <summary>\r
 257                 /// True if heap has FieldMarshal table.\r
 258                 /// </summary>\r
 259                 public bool HasFieldMarshal {\r
 260                         get {\r
 261                                 return (Valid & (1L << 0x0d)) != 0;\r
 262                         }\r
 263                         set {\r
 264                                 long mask = (1L << 0x0d);\r
 265                                 if (value) {\r
 266                                         Valid |= mask;\r
 267                                 } else {\r
 268                                         Valid &= ~mask;\r
 269                                 }\r
 270                         }\r
 271                 }\r
 272 \r
 273                 /// <summary>\r
 274                 /// True if heap has DeclSecurity table.\r
 275                 /// </summary>\r
 276                 public bool HasDeclSecurity {\r
 277                         get {\r
 278                                 return (Valid & (1L << 0x0e)) != 0;\r
 279                         }\r
 280                         set {\r
 281                                 long mask = (1L << 0x0e);\r
 282                                 if (value) {\r
 283                                         Valid |= mask;\r
 284                                 } else {\r
 285                                         Valid &= ~mask;\r
 286                                 }\r
 287                         }\r
 288                 }\r
 289 \r
 290                 /// <summary>\r
 291                 /// True if heap has ClassLayout table.\r
 292                 /// </summary>\r
 293                 public bool HasClassLayout {\r
 294                         get {\r
 295                                 return (Valid & (1L << 0x0f)) != 0;\r
 296                         }\r
 297                         set {\r
 298                                 long mask = (1L << 0x0f);\r
 299                                 if (value) {\r
 300                                         Valid |= mask;\r
 301                                 } else {\r
 302                                         Valid &= ~mask;\r
 303                                 }\r
 304                         }\r
 305                 }\r
 306 \r
 307                 /// <summary>\r
 308                 /// True if heap has FieldLayout table.\r
 309                 /// </summary>\r
 310                 public bool HasFieldLayout {\r
 311                         get {\r
 312                                 return (Valid & (1L << 0x10)) != 0;\r
 313                         }\r
 314                         set {\r
 315                                 long mask = (1L << 0x10);\r
 316                                 if (value) {\r
 317                                         Valid |= mask;\r
 318                                 } else {\r
 319                                         Valid &= ~mask;\r
 320                                 }\r
 321                         }\r
 322                 }\r
 323 \r
 324                 /// <summary>\r
 325                 /// True if heap has StandAloneSig table.\r
 326                 /// </summary>\r
 327                 public bool HasStandAloneSig {\r
 328                         get {\r
 329                                 return (Valid & (1L << 0x11)) != 0;\r
 330                         }\r
 331                         set {\r
 332                                 long mask = (1L << 0x11);\r
 333                                 if (value) {\r
 334                                         Valid |= mask;\r
 335                                 } else {\r
 336                                         Valid &= ~mask;\r
 337                                 }\r
 338                         }\r
 339                 }\r
 340 \r
 341                 /// <summary>\r
 342                 /// True if heap has EventMap table.\r
 343                 /// </summary>\r
 344                 public bool HasEventMap {\r
 345                         get {\r
 346                                 return (Valid & (1L << 0x12)) != 0;\r
 347                         }\r
 348                         set {\r
 349                                 long mask = (1L << 0x12);\r
 350                                 if (value) {\r
 351                                         Valid |= mask;\r
 352                                 } else {\r
 353                                         Valid &= ~mask;\r
 354                                 }\r
 355                         }\r
 356                 }\r
 357 \r
 358                 /// <summary>\r
 359                 /// True if heap has EventPtr table.\r
 360                 /// </summary>\r
 361                 public bool HasEventPtr {\r
 362                         get {\r
 363                                 return (Valid & (1L << 0x13)) != 0;\r
 364                         }\r
 365                         set {\r
 366                                 long mask = (1L << 0x13);\r
 367                                 if (value) {\r
 368                                         Valid |= mask;\r
 369                                 } else {\r
 370                                         Valid &= ~mask;\r
 371                                 }\r
 372                         }\r
 373                 }\r
 374 \r
 375                 /// <summary>\r
 376                 /// True if heap has Event table.\r
 377                 /// </summary>\r
 378                 public bool HasEvent {\r
 379                         get {\r
 380                                 return (Valid & (1L << 0x14)) != 0;\r
 381                         }\r
 382                         set {\r
 383                                 long mask = (1L << 0x14);\r
 384                                 if (value) {\r
 385                                         Valid |= mask;\r
 386                                 } else {\r
 387                                         Valid &= ~mask;\r
 388                                 }\r
 389                         }\r
 390                 }\r
 391 \r
 392                 /// <summary>\r
 393                 /// True if heap has PropertyMap table.\r
 394                 /// </summary>\r
 395                 public bool HasPropertyMap {\r
 396                         get {\r
 397                                 return (Valid & (1L << 0x15)) != 0;\r
 398                         }\r
 399                         set {\r
 400                                 long mask = (1L << 0x15);\r
 401                                 if (value) {\r
 402                                         Valid |= mask;\r
 403                                 } else {\r
 404                                         Valid &= ~mask;\r
 405                                 }\r
 406                         }\r
 407                 }\r
 408 \r
 409                 /// <summary>\r
 410                 /// True if heap has PropertyPtr table.\r
 411                 /// </summary>\r
 412                 public bool HasPropertyPtr {\r
 413                         get {\r
 414                                 return (Valid & (1L << 0x16)) != 0;\r
 415                         }\r
 416                         set {\r
 417                                 long mask = (1L << 0x16);\r
 418                                 if (value) {\r
 419                                         Valid |= mask;\r
 420                                 } else {\r
 421                                         Valid &= ~mask;\r
 422                                 }\r
 423                         }\r
 424                 }\r
 425 \r
 426                 /// <summary>\r
 427                 /// True if heap has Property table.\r
 428                 /// </summary>\r
 429                 public bool HasProperty {\r
 430                         get {\r
 431                                 return (Valid & (1L << 0x17)) != 0;\r
 432                         }\r
 433                         set {\r
 434                                 long mask = (1L << 0x17);\r
 435                                 if (value) {\r
 436                                         Valid |= mask;\r
 437                                 } else {\r
 438                                         Valid &= ~mask;\r
 439                                 }\r
 440                         }\r
 441                 }\r
 442 \r
 443                 /// <summary>\r
 444                 /// True if heap has MethodSemantics table.\r
 445                 /// </summary>\r
 446                 public bool HasMethodSemantics {\r
 447                         get {\r
 448                                 return (Valid & (1L << 0x18)) != 0;\r
 449                         }\r
 450                         set {\r
 451                                 long mask = (1L << 0x18);\r
 452                                 if (value) {\r
 453                                         Valid |= mask;\r
 454                                 } else {\r
 455                                         Valid &= ~mask;\r
 456                                 }\r
 457                         }\r
 458                 }\r
 459 \r
 460                 /// <summary>\r
 461                 /// True if heap has MethodImpl table.\r
 462                 /// </summary>\r
 463                 public bool HasMethodImpl {\r
 464                         get {\r
 465                                 return (Valid & (1L << 0x19)) != 0;\r
 466                         }\r
 467                         set {\r
 468                                 long mask = (1L << 0x19);\r
 469                                 if (value) {\r
 470                                         Valid |= mask;\r
 471                                 } else {\r
 472                                         Valid &= ~mask;\r
 473                                 }\r
 474                         }\r
 475                 }\r
 476 \r
 477                 /// <summary>\r
 478                 /// True if heap has ModuleRef table.\r
 479                 /// </summary>\r
 480                 public bool HasModuleRef {\r
 481                         get {\r
 482                                 return (Valid & (1L << 0x1a)) != 0;\r
 483                         }\r
 484                         set {\r
 485                                 long mask = (1L << 0x1a);\r
 486                                 if (value) {\r
 487                                         Valid |= mask;\r
 488                                 } else {\r
 489                                         Valid &= ~mask;\r
 490                                 }\r
 491                         }\r
 492                 }\r
 493 \r
 494                 /// <summary>\r
 495                 /// True if heap has TypeSpec table.\r
 496                 /// </summary>\r
 497                 public bool HasTypeSpec {\r
 498                         get {\r
 499                                 return (Valid & (1L << 0x1b)) != 0;\r
 500                         }\r
 501                         set {\r
 502                                 long mask = (1L << 0x1b);\r
 503                                 if (value) {\r
 504                                         Valid |= mask;\r
 505                                 } else {\r
 506                                         Valid &= ~mask;\r
 507                                 }\r
 508                         }\r
 509                 }\r
 510 \r
 511                 /// <summary>\r
 512                 /// True if heap has ImplMap table.\r
 513                 /// </summary>\r
 514                 public bool HasImplMap {\r
 515                         get {\r
 516                                 return (Valid & (1L << 0x1c)) != 0;\r
 517                         }\r
 518                         set {\r
 519                                 long mask = (1L << 0x1c);\r
 520                                 if (value) {\r
 521                                         Valid |= mask;\r
 522                                 } else {\r
 523                                         Valid &= ~mask;\r
 524                                 }\r
 525                         }\r
 526                 }\r
 527 \r
 528                 /// <summary>\r
 529                 /// True if heap has FieldRVA table.\r
 530                 /// </summary>\r
 531                 public bool HasFieldRVA {\r
 532                         get {\r
 533                                 return (Valid & (1L << 0x1d)) != 0;\r
 534                         }\r
 535                         set {\r
 536                                 long mask = (1L << 0x1d);\r
 537                                 if (value) {\r
 538                                         Valid |= mask;\r
 539                                 } else {\r
 540                                         Valid &= ~mask;\r
 541                                 }\r
 542                         }\r
 543                 }\r
 544 \r
 545                 /// <summary>\r
 546                 /// True if heap has ENCLog table.\r
 547                 /// </summary>\r
 548                 public bool HasENCLog {\r
 549                         get {\r
 550                                 return (Valid & (1L << 0x1e)) != 0;\r
 551                         }\r
 552                         set {\r
 553                                 long mask = (1L << 0x1e);\r
 554                                 if (value) {\r
 555                                         Valid |= mask;\r
 556                                 } else {\r
 557                                         Valid &= ~mask;\r
 558                                 }\r
 559                         }\r
 560                 }\r
 561 \r
 562                 /// <summary>\r
 563                 /// True if heap has ENCMap table.\r
 564                 /// </summary>\r
 565                 public bool HasENCMap {\r
 566                         get {\r
 567                                 return (Valid & (1L << 0x1f)) != 0;\r
 568                         }\r
 569                         set {\r
 570                                 long mask = (1L << 0x1f);\r
 571                                 if (value) {\r
 572                                         Valid |= mask;\r
 573                                 } else {\r
 574                                         Valid &= ~mask;\r
 575                                 }\r
 576                         }\r
 577                 }\r
 578 \r
 579                 /// <summary>\r
 580                 /// True if heap has Assembly table.\r
 581                 /// </summary>\r
 582                 public bool HasAssembly {\r
 583                         get {\r
 584                                 return (Valid & (1L << 0x20)) != 0;\r
 585                         }\r
 586                         set {\r
 587                                 long mask = (1L << 0x20);\r
 588                                 if (value) {\r
 589                                         Valid |= mask;\r
 590                                 } else {\r
 591                                         Valid &= ~mask;\r
 592                                 }\r
 593                         }\r
 594                 }\r
 595 \r
 596                 /// <summary>\r
 597                 /// True if heap has AssemblyProcessor table.\r
 598                 /// </summary>\r
 599                 public bool HasAssemblyProcessor {\r
 600                         get {\r
 601                                 return (Valid & (1L << 0x21)) != 0;\r
 602                         }\r
 603                         set {\r
 604                                 long mask = (1L << 0x21);\r
 605                                 if (value) {\r
 606                                         Valid |= mask;\r
 607                                 } else {\r
 608                                         Valid &= ~mask;\r
 609                                 }\r
 610                         }\r
 611                 }\r
 612 \r
 613                 /// <summary>\r
 614                 /// True if heap has AssemblyOS table.\r
 615                 /// </summary>\r
 616                 public bool HasAssemblyOS {\r
 617                         get {\r
 618                                 return (Valid & (1L << 0x22)) != 0;\r
 619                         }\r
 620                         set {\r
 621                                 long mask = (1L << 0x22);\r
 622                                 if (value) {\r
 623                                         Valid |= mask;\r
 624                                 } else {\r
 625                                         Valid &= ~mask;\r
 626                                 }\r
 627                         }\r
 628                 }\r
 629 \r
 630                 /// <summary>\r
 631                 /// True if heap has AssemblyRef table.\r
 632                 /// </summary>\r
 633                 public bool HasAssemblyRef {\r
 634                         get {\r
 635                                 return (Valid & (1L << 0x23)) != 0;\r
 636                         }\r
 637                         set {\r
 638                                 long mask = (1L << 0x23);\r
 639                                 if (value) {\r
 640                                         Valid |= mask;\r
 641                                 } else {\r
 642                                         Valid &= ~mask;\r
 643                                 }\r
 644                         }\r
 645                 }\r
 646 \r
 647                 /// <summary>\r
 648                 /// True if heap has AssemblyRefProcessor table.\r
 649                 /// </summary>\r
 650                 public bool HasAssemblyRefProcessor {\r
 651                         get {\r
 652                                 return (Valid & (1L << 0x24)) != 0;\r
 653                         }\r
 654                         set {\r
 655                                 long mask = (1L << 0x24);\r
 656                                 if (value) {\r
 657                                         Valid |= mask;\r
 658                                 } else {\r
 659                                         Valid &= ~mask;\r
 660                                 }\r
 661                         }\r
 662                 }\r
 663 \r
 664                 /// <summary>\r
 665                 /// True if heap has AssemblyRefOS table.\r
 666                 /// </summary>\r
 667                 public bool HasAssemblyRefOS {\r
 668                         get {\r
 669                                 return (Valid & (1L << 0x25)) != 0;\r
 670                         }\r
 671                         set {\r
 672                                 long mask = (1L << 0x25);\r
 673                                 if (value) {\r
 674                                         Valid |= mask;\r
 675                                 } else {\r
 676                                         Valid &= ~mask;\r
 677                                 }\r
 678                         }\r
 679                 }\r
 680 \r
 681                 /// <summary>\r
 682                 /// True if heap has File table.\r
 683                 /// </summary>\r
 684                 public bool HasFile {\r
 685                         get {\r
 686                                 return (Valid & (1L << 0x26)) != 0;\r
 687                         }\r
 688                         set {\r
 689                                 long mask = (1L << 0x26);\r
 690                                 if (value) {\r
 691                                         Valid |= mask;\r
 692                                 } else {\r
 693                                         Valid &= ~mask;\r
 694                                 }\r
 695                         }\r
 696                 }\r
 697 \r
 698                 /// <summary>\r
 699                 /// True if heap has ExportedType table.\r
 700                 /// </summary>\r
 701                 public bool HasExportedType {\r
 702                         get {\r
 703                                 return (Valid & (1L << 0x27)) != 0;\r
 704                         }\r
 705                         set {\r
 706                                 long mask = (1L << 0x27);\r
 707                                 if (value) {\r
 708                                         Valid |= mask;\r
 709                                 } else {\r
 710                                         Valid &= ~mask;\r
 711                                 }\r
 712                         }\r
 713                 }\r
 714 \r
 715                 /// <summary>\r
 716                 /// True if heap has ManifestResource table.\r
 717                 /// </summary>\r
 718                 public bool HasManifestResource {\r
 719                         get {\r
 720                                 return (Valid & (1L << 0x28)) != 0;\r
 721                         }\r
 722                         set {\r
 723                                 long mask = (1L << 0x28);\r
 724                                 if (value) {\r
 725                                         Valid |= mask;\r
 726                                 } else {\r
 727                                         Valid &= ~mask;\r
 728                                 }\r
 729                         }\r
 730                 }\r
 731 \r
 732                 /// <summary>\r
 733                 /// True if heap has NestedClass table.\r
 734                 /// </summary>\r
 735                 public bool HasNestedClass {\r
 736                         get {\r
 737                                 return (Valid & (1L << 0x29)) != 0;\r
 738                         }\r
 739                         set {\r
 740                                 long mask = (1L << 0x29);\r
 741                                 if (value) {\r
 742                                         Valid |= mask;\r
 743                                 } else {\r
 744                                         Valid &= ~mask;\r
 745                                 }\r
 746                         }\r
 747                 }\r
 748 \r
 749                 /// <summary>\r
 750                 /// True if heap has TypeTyPar table.\r
 751                 /// </summary>\r
 752                 public bool HasTypeTyPar {\r
 753                         get {\r
 754                                 return (Valid & (1L << 0x2a)) != 0;\r
 755                         }\r
 756                         set {\r
 757                                 long mask = (1L << 0x2a);\r
 758                                 if (value) {\r
 759                                         Valid |= mask;\r
 760                                 } else {\r
 761                                         Valid &= ~mask;\r
 762                                 }\r
 763                         }\r
 764                 }\r
 765 \r
 766                 /// <summary>\r
 767                 /// True if heap has MethodTyPar table.\r
 768                 /// </summary>\r
 769                 public bool HasMethodTyPar {\r
 770                         get {\r
 771                                 return (Valid & (1L << 0x2b)) != 0;\r
 772                         }\r
 773                         set {\r
 774                                 long mask = (1L << 0x2b);\r
 775                                 if (value) {\r
 776                                         Valid |= mask;\r
 777                                 } else {\r
 778                                         Valid &= ~mask;\r
 779                                 }\r
 780                         }\r
 781                 }\r
 782 \r
 783 \r
 784         }\r
 785 \r
 786 }\r
 787 \r