The Labs \ Source Viewer \ SSCLI \ System.CodeDom \ CodeTypeDeclaration

  1. //------------------------------------------------------------------------------
  2. // <copyright file="CodeTypeDeclaration.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.CodeDom
  16. {
  17.    
  18.     using System.Diagnostics;
  19.     using System;
  20.     using Microsoft.Win32;
  21.     using System.Collections;
  22.     using System.Reflection;
  23.     using System.Runtime.Serialization;
  24.     using System.Runtime.InteropServices;
  25.    
  26.     /// <devdoc>
  27.     /// <para>
  28.     /// Represents a
  29.     /// class or nested class.
  30.     /// </para>
  31.     /// </devdoc>
  32.     [ClassInterface(ClassInterfaceType.AutoDispatch), ComVisible(true), Serializable()]
  33.     public class CodeTypeDeclaration : CodeTypeMember
  34.     {
  35.        
  36.        
  37.         private TypeAttributes attributes = Reflection.TypeAttributes.Public | Reflection.TypeAttributes.Class;
  38.         private CodeTypeReferenceCollection baseTypes = new CodeTypeReferenceCollection();
  39.         private CodeTypeMemberCollection members = new CodeTypeMemberCollection();
  40.        
  41.         private bool isEnum;
  42.         private bool isStruct;
  43.         private int populated = 0;
  44.         private const int BaseTypesCollection = 1;
  45.         private const int MembersCollection = 2;
  46.        
  47.         // Need to be made optionally serializable
  48.         [OptionalField()]
  49.         private CodeTypeParameterCollection typeParameters;
  50.         [OptionalField()]
  51.         private bool isPartial = false;
  52.        
  53.        
  54.         /// <devdoc>
  55.         /// <para>
  56.         /// An event that will be fired the first time the BaseTypes Collection is accessed.
  57.         /// </para>
  58.         /// </devdoc>
  59.         public event EventHandler PopulateBaseTypes;
  60.        
  61.         /// <devdoc>
  62.         /// <para>
  63.         /// An event that will be fired the first time the Members Collection is accessed.
  64.         /// </para>
  65.         /// </devdoc>
  66.         public event EventHandler PopulateMembers;
  67.        
  68.        
  69.         /// <devdoc>
  70.         /// <para>
  71.         /// Initializes a new instance of <see cref='System.CodeDom.CodeTypeDeclaration'/>.
  72.         /// </para>
  73.         /// </devdoc>
  74.         public CodeTypeDeclaration()
  75.         {
  76.         }
  77.        
  78.         /// <devdoc>
  79.         /// <para>
  80.         /// Initializes a new instance of <see cref='System.CodeDom.CodeTypeDeclaration'/> with the specified name.
  81.         /// </para>
  82.         /// </devdoc>
  83.         public CodeTypeDeclaration(string name)
  84.         {
  85.             Name = name;
  86.         }
  87.        
  88.         /// <devdoc>
  89.         /// <para>
  90.         /// Gets or sets the attributes of the class.
  91.         /// </para>
  92.         /// </devdoc>
  93.         public TypeAttributes TypeAttributes {
  94.             get { return attributes; }
  95.             set { attributes = value; }
  96.         }
  97.        
  98.         /// <devdoc>
  99.         /// <para>
  100.         /// Gets or sets
  101.         /// the base types of the class.
  102.         /// </para>
  103.         /// </devdoc>
  104.         public CodeTypeReferenceCollection BaseTypes {
  105.             get {
  106.                 if (0 == (populated & BaseTypesCollection)) {
  107.                     populated |= BaseTypesCollection;
  108.                     if (PopulateBaseTypes != null)
  109.                         PopulateBaseTypes(this, EventArgs.Empty);
  110.                 }
  111.                 return baseTypes;
  112.             }
  113.         }
  114.        
  115.         /// <devdoc>
  116.         /// <para>
  117.         /// Gets or sets a value
  118.         /// indicating whether the class is a class.
  119.         /// </para>
  120.         /// </devdoc>
  121.         public bool IsClass {
  122.             get { return (attributes & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class && !isEnum && !isStruct; }
  123.             set {
  124.                 if (value) {
  125.                     attributes &= ~TypeAttributes.ClassSemanticsMask;
  126.                     attributes |= TypeAttributes.Class;
  127.                     isStruct = false;
  128.                     isEnum = false;
  129.                 }
  130.             }
  131.         }
  132.        
  133.         /// <devdoc>
  134.         /// <para>
  135.         /// Gets or sets a value
  136.         /// indicating whether the class is a struct.
  137.         /// </para>
  138.         /// </devdoc>
  139.         public bool IsStruct {
  140.             get { return isStruct; }
  141.             set {
  142.                 if (value) {
  143.                     attributes &= ~TypeAttributes.ClassSemanticsMask;
  144.                     isStruct = true;
  145.                     isEnum = false;
  146.                 }
  147.                 else {
  148.                     isStruct = false;
  149.                 }
  150.             }
  151.         }
  152.        
  153.         /// <devdoc>
  154.         /// <para>
  155.         /// Gets or sets a value
  156.         /// indicating whether the class is an enumeration.
  157.         /// </para>
  158.         /// </devdoc>
  159.         public bool IsEnum {
  160.             get { return isEnum; }
  161.             set {
  162.                 if (value) {
  163.                     attributes &= ~TypeAttributes.ClassSemanticsMask;
  164.                     isStruct = false;
  165.                     isEnum = true;
  166.                 }
  167.                 else {
  168.                     isEnum = false;
  169.                 }
  170.             }
  171.         }
  172.        
  173.         /// <devdoc>
  174.         /// <para>
  175.         /// Gets or sets a value
  176.         /// indicating whether the class is an interface.
  177.         /// </para>
  178.         /// </devdoc>
  179.         public bool IsInterface {
  180.             get { return (attributes & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface; }
  181.             set {
  182.                 if (value) {
  183.                     attributes &= ~TypeAttributes.ClassSemanticsMask;
  184.                     attributes |= TypeAttributes.Interface;
  185.                     isStruct = false;
  186.                     isEnum = false;
  187.                 }
  188.                 else {
  189.                     attributes &= ~TypeAttributes.Interface;
  190.                 }
  191.             }
  192.         }
  193.        
  194.         public bool IsPartial {
  195.             get { return isPartial; }
  196.             set { isPartial = value; }
  197.         }
  198.        
  199.         /// <devdoc>
  200.         /// <para>
  201.         /// Gets or sets the class member collection members.
  202.         /// </para>
  203.         /// </devdoc>
  204.         public CodeTypeMemberCollection Members {
  205.             get {
  206.                 if (0 == (populated & MembersCollection)) {
  207.                     populated |= MembersCollection;
  208.                     if (PopulateMembers != null)
  209.                         PopulateMembers(this, EventArgs.Empty);
  210.                 }
  211.                 return members;
  212.             }
  213.         }
  214.        
  215.         [System.Runtime.InteropServices.ComVisible(false)]
  216.         public CodeTypeParameterCollection TypeParameters {
  217.             get {
  218.                 if (typeParameters == null) {
  219.                     typeParameters = new CodeTypeParameterCollection();
  220.                 }
  221.                 return typeParameters;
  222.             }
  223.         }
  224.     }
  225. }

Developer Fusion