The Labs \ Source Viewer \ SSCLI \ System.Reflection.Emit \ GenericTypeParameterBuilder

  1. // ==++==
  2. //
  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. //
  14. // ==--==
  15. using System;
  16. using System.Reflection;
  17. using System.Reflection.Emit;
  18. using System.Collections;
  19. using System.Globalization;
  20. namespace System.Reflection.Emit
  21. {
  22.     [System.Runtime.InteropServices.ComVisible(true)]
  23.     public sealed class GenericTypeParameterBuilder : Type
  24.     {
  25.         #region Private Data Mebers
  26.         internal TypeBuilder m_type;
  27.         #endregion
  28.        
  29.         #region Constructor
  30.         internal GenericTypeParameterBuilder(TypeBuilder type)
  31.         {
  32.             m_type = type;
  33.         }
  34.         #endregion
  35.        
  36.         #region Object Overrides
  37.         public override string ToString()
  38.         {
  39.             return m_type.Name;
  40.         }
  41.         public override bool Equals(object o)
  42.         {
  43.             GenericTypeParameterBuilder g = o as GenericTypeParameterBuilder;
  44.            
  45.             if (g == null)
  46.                 return false;
  47.            
  48.             return g.m_type == m_type;
  49.         }
  50.         public override int GetHashCode()
  51.         {
  52.             return m_type.GetHashCode();
  53.         }
  54.         #endregion
  55.        
  56.         #region MemberInfo Overrides
  57.         public override Type DeclaringType {
  58.             get { return m_type.DeclaringType; }
  59.         }
  60.        
  61.         public override Type ReflectedType {
  62.             get { return m_type.ReflectedType; }
  63.         }
  64.        
  65.         public override string Name {
  66.             get { return m_type.Name; }
  67.         }
  68.        
  69.         public override Module Module {
  70.             get { return m_type.Module; }
  71.         }
  72.        
  73.         internal override int MetadataTokenInternal {
  74.             get { return m_type.MetadataTokenInternal; }
  75.         }
  76.         #endregion
  77.        
  78.         #region Type Overrides
  79.        
  80.         public override Type MakePointerType()
  81.         {
  82.             return SymbolType.FormCompoundType("*".ToCharArray(), this, 0);
  83.         }
  84.        
  85.         public override Type MakeByRefType()
  86.         {
  87.             return SymbolType.FormCompoundType("&".ToCharArray(), this, 0);
  88.         }
  89.        
  90.         public override Type MakeArrayType()
  91.         {
  92.             return SymbolType.FormCompoundType("[]".ToCharArray(), this, 0);
  93.         }
  94.        
  95.         public override Type MakeArrayType(int rank)
  96.         {
  97.             if (rank <= 0)
  98.                 throw new IndexOutOfRangeException();
  99.            
  100.             string szrank = "";
  101.             if (rank == 1) {
  102.                 szrank = "*";
  103.             }
  104.             else {
  105.                 for (int i = 1; i < rank; i++)
  106.                     szrank += ",";
  107.             }
  108.            
  109.             string s = String.Format(CultureInfo.InvariantCulture, "[{0}]", szrank);
  110.             // [,,]
  111.             SymbolType st = SymbolType.FormCompoundType(s.ToCharArray(), this, 0) as SymbolType;
  112.             return st;
  113.         }
  114.        
  115.         public override Guid GUID {
  116.             get {
  117.                 throw new NotSupportedException();
  118.             }
  119.         }
  120.        
  121.         public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
  122.         {
  123.             throw new NotSupportedException();
  124.         }
  125.        
  126.         public override Assembly Assembly {
  127.             get { return m_type.Assembly; }
  128.         }
  129.        
  130.         public override RuntimeTypeHandle TypeHandle {
  131.             get {
  132.                 throw new NotSupportedException();
  133.             }
  134.         }
  135.        
  136.         public override string FullName {
  137.             get { return null; }
  138.         }
  139.        
  140.         public override string Namespace {
  141.             get { return null; }
  142.         }
  143.        
  144.         public override string AssemblyQualifiedName {
  145.             get { return null; }
  146.         }
  147.        
  148.         public override Type BaseType {
  149.             get { return m_type.BaseType; }
  150.         }
  151.        
  152.         protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  153.         {
  154.             throw new NotSupportedException();
  155.         }
  156.        
  157.         [System.Runtime.InteropServices.ComVisible(true)]
  158.         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
  159.         {
  160.             throw new NotSupportedException();
  161.         }
  162.        
  163.         protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  164.         {
  165.             throw new NotSupportedException();
  166.         }
  167.        
  168.         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
  169.         {
  170.             throw new NotSupportedException();
  171.         }
  172.        
  173.         public override FieldInfo GetField(string name, BindingFlags bindingAttr)
  174.         {
  175.             throw new NotSupportedException();
  176.         }
  177.        
  178.         public override FieldInfo[] GetFields(BindingFlags bindingAttr)
  179.         {
  180.             throw new NotSupportedException();
  181.         }
  182.        
  183.         public override Type GetInterface(string name, bool ignoreCase)
  184.         {
  185.             throw new NotSupportedException();
  186.         }
  187.        
  188.         public override Type[] GetInterfaces()
  189.         {
  190.             throw new NotSupportedException();
  191.         }
  192.        
  193.         public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
  194.         {
  195.             throw new NotSupportedException();
  196.         }
  197.        
  198.         public override EventInfo[] GetEvents()
  199.         {
  200.             throw new NotSupportedException();
  201.         }
  202.        
  203.         protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
  204.         {
  205.             throw new NotSupportedException();
  206.         }
  207.        
  208.         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
  209.         {
  210.             throw new NotSupportedException();
  211.         }
  212.        
  213.         public override Type[] GetNestedTypes(BindingFlags bindingAttr)
  214.         {
  215.             throw new NotSupportedException();
  216.         }
  217.        
  218.         public override Type GetNestedType(string name, BindingFlags bindingAttr)
  219.         {
  220.             throw new NotSupportedException();
  221.         }
  222.        
  223.         public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
  224.         {
  225.             throw new NotSupportedException();
  226.         }
  227.        
  228.         [System.Runtime.InteropServices.ComVisible(true)]
  229.         public override InterfaceMapping GetInterfaceMap(Type interfaceType)
  230.         {
  231.             throw new NotSupportedException();
  232.         }
  233.        
  234.         public override EventInfo[] GetEvents(BindingFlags bindingAttr)
  235.         {
  236.             throw new NotSupportedException();
  237.         }
  238.        
  239.         public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
  240.         {
  241.             throw new NotSupportedException();
  242.         }
  243.        
  244.         protected override TypeAttributes GetAttributeFlagsImpl()
  245.         {
  246.             throw new NotSupportedException();
  247.         }
  248.        
  249.         protected override bool IsArrayImpl()
  250.         {
  251.             return false;
  252.         }
  253.        
  254.         protected override bool IsByRefImpl()
  255.         {
  256.             return false;
  257.         }
  258.        
  259.         protected override bool IsPointerImpl()
  260.         {
  261.             return false;
  262.         }
  263.        
  264.         protected override bool IsPrimitiveImpl()
  265.         {
  266.             return false;
  267.         }
  268.        
  269.         protected override bool IsCOMObjectImpl()
  270.         {
  271.             return false;
  272.         }
  273.        
  274.         public override Type GetElementType()
  275.         {
  276.             throw new NotSupportedException();
  277.         }
  278.        
  279.         protected override bool HasElementTypeImpl()
  280.         {
  281.             return false;
  282.         }
  283.        
  284.         public override Type UnderlyingSystemType {
  285.             get { return this; }
  286.         }
  287.        
  288.         public override Type[] GetGenericArguments()
  289.         {
  290.             throw new InvalidOperationException();
  291.         }
  292.        
  293.         public override bool IsGenericTypeDefinition {
  294.             get { return false; }
  295.         }
  296.        
  297.         public override bool IsGenericType {
  298.             get { return false; }
  299.         }
  300.        
  301.         public override bool IsGenericParameter {
  302.             get { return true; }
  303.         }
  304.        
  305.         public override int GenericParameterPosition {
  306.             get { return m_type.GenericParameterPosition; }
  307.         }
  308.        
  309.         public override bool ContainsGenericParameters {
  310.             get { return m_type.ContainsGenericParameters; }
  311.         }
  312.        
  313.         public override MethodBase DeclaringMethod {
  314.             get { return m_type.DeclaringMethod; }
  315.         }
  316.        
  317.         public override Type GetGenericTypeDefinition()
  318.         {
  319.             throw new InvalidOperationException();
  320.         }
  321.        
  322.         public override Type MakeGenericType(params Type[] typeArguments)
  323.         {
  324.             throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericTypeDefinition"));
  325.         }
  326.        
  327.         protected override bool IsValueTypeImpl()
  328.         {
  329.             return false;
  330.         }
  331.        
  332.         public override bool IsAssignableFrom(Type c)
  333.         {
  334.             throw new NotSupportedException();
  335.         }
  336.        
  337.         [System.Runtime.InteropServices.ComVisible(true)]
  338.         public override bool IsSubclassOf(Type c)
  339.         {
  340.             throw new NotSupportedException();
  341.         }
  342.         #endregion
  343.        
  344.         #region ICustomAttributeProvider Implementation
  345.         public override object[] GetCustomAttributes(bool inherit)
  346.         {
  347.             throw new NotSupportedException();
  348.         }
  349.        
  350.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  351.         {
  352.             throw new NotSupportedException();
  353.         }
  354.        
  355.         public override bool IsDefined(Type attributeType, bool inherit)
  356.         {
  357.             throw new NotSupportedException();
  358.         }
  359.         #endregion
  360.        
  361.         #region Public Members
  362.         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
  363.         {
  364.             if (m_type.m_ca == null)
  365.                 m_type.m_ca = new ArrayList();
  366.            
  367.             m_type.m_ca.Add(new TypeBuilder.CustAttr(con, binaryAttribute));
  368.         }
  369.        
  370.         public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
  371.         {
  372.             if (m_type.m_ca == null)
  373.                 m_type.m_ca = new ArrayList();
  374.            
  375.             m_type.m_ca.Add(new TypeBuilder.CustAttr(customBuilder));
  376.         }
  377.        
  378.         public void SetBaseTypeConstraint(Type baseTypeConstraint)
  379.         {
  380.             m_type.CheckContext(baseTypeConstraint);
  381.             m_type.SetParent(baseTypeConstraint);
  382.         }
  383.        
  384.         [System.Runtime.InteropServices.ComVisible(true)]
  385.         public void SetInterfaceConstraints(params Type[] interfaceConstraints)
  386.         {
  387.             m_type.CheckContext(interfaceConstraints);
  388.             m_type.SetInterfaces(interfaceConstraints);
  389.         }
  390.        
  391.         public void SetGenericParameterAttributes(GenericParameterAttributes genericParameterAttributes)
  392.         {
  393.             m_type.m_genParamAttributes = genericParameterAttributes;
  394.         }
  395.         #endregion
  396.     }
  397. }

Developer Fusion