mcs/class/corlib/System.Reflection/TypeDelegator.cs

   1 // System.Reflection/TypeDelegator.cs
   2 //
   3 // Paolo Molaro (lupus@ximian.com)
   4 //
   5 // (C) 2002 Ximian, Inc.
   6
   7 using System;
   8 using System.Reflection;
   9 using System.Globalization;
  10
  11 namespace System.Reflection {
  12
  13         public class TypeDelegator : Type {
  14                 protected Type typeImpl;
  15
  16                 protected TypeDelegator () {
  17                 }
  18
  19                 public TypeDelegator( Type delegatingType) {
  20                         if (delegatingType == null)
  21                                 throw new ArgumentNullException ("delegatingType must be non-null");
  22                         typeImpl = delegatingType;
  23                 }
  24
  25                 public override Assembly Assembly {
  26                         get {return typeImpl.Assembly;}
  27                 }
  28
  29                 public override string AssemblyQualifiedName {
  30                         get {return typeImpl.AssemblyQualifiedName;}
  31                 }
  32
  33                 public override Type BaseType {
  34                         get {return typeImpl.BaseType;}
  35                 }
  36
  37                 public override string FullName {
  38                         get {return typeImpl.FullName;}
  39                 }
  40
  41                 public override Guid GUID {
  42                         get {return typeImpl.GUID;}
  43                 }
  44
  45                 public override Module Module {
  46                         get {return typeImpl.Module;}
  47                 }
  48
  49                 public override string Name {
  50                         get {return typeImpl.Name;}
  51                 }
  52
  53                 public override string Namespace {
  54                         get {return typeImpl.Namespace;}
  55                 }
  56
  57                 public override RuntimeTypeHandle TypeHandle {
  58                         get {return typeImpl.TypeHandle;}
  59                 }
  60
  61                 public override Type UnderlyingSystemType {
  62                         get {return typeImpl.UnderlyingSystemType;}
  63                 }
  64
  65                 protected override TypeAttributes GetAttributeFlagsImpl () {
  66                         throw new NotImplementedException ();
  67                         //return typeImpl.GetAttributeFlagsImpl ();
  68                 }
  69
  70                 protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) {
  71                         throw new NotImplementedException ();
  72                         //return typeImpl.GetConstructorImpl (bindingAttr, binder, callConvention, types, modifiers);
  73                 }
  74
  75                 public override ConstructorInfo[] GetConstructors( BindingFlags bindingAttr) {
  76                         return typeImpl.GetConstructors (bindingAttr);
  77                 }
  78
  79                 public override object[] GetCustomAttributes (bool inherit)
  80                 {
  81                         return typeImpl.GetCustomAttributes (inherit);
  82                 }
  83
  84                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
  85                 {
  86                         return typeImpl.GetCustomAttributes (attributeType, inherit);
  87                 }
  88
  89                 public override Type GetElementType() {
  90                         return typeImpl.GetElementType ();
  91                 }
  92
  93                 public override EventInfo GetEvent( string name, BindingFlags bindingAttr) {
  94                         return typeImpl.GetEvent (name, bindingAttr);
  95                 }
  96
  97                 public override EventInfo[] GetEvents() {
  98                         return GetEvents (BindingFlags.Public);
  99                 }
 100
 101                 public override EventInfo[] GetEvents( BindingFlags bindingAttr) {
 102                         return typeImpl.GetEvents (bindingAttr);
 103                 }
 104
 105                 public override FieldInfo GetField( string name, BindingFlags bindingAttr) {
 106                         return typeImpl.GetField (name, bindingAttr);
 107                 }
 108
 109                 public override FieldInfo[] GetFields( BindingFlags bindingAttr) {
 110                         return typeImpl.GetFields (bindingAttr);
 111                 }
 112
 113                 public override Type GetInterface( string name, bool ignoreCase) {
 114                         return typeImpl.GetInterface (name, ignoreCase);
 115                 }
 116
 117                 public override InterfaceMapping GetInterfaceMap( Type interfaceType) {
 118                         return typeImpl.GetInterfaceMap (interfaceType);
 119                 }
 120
 121                 public override Type[] GetInterfaces() {
 122                         return typeImpl.GetInterfaces ();
 123                 }
 124
 125                 public override MemberInfo[] GetMember( string name, MemberTypes type, BindingFlags bindingAttr) {
 126                         return typeImpl.GetMember (name, type, bindingAttr);
 127                 }
 128
 129                 public override MemberInfo[] GetMembers( BindingFlags bindingAttr) {
 130                         return typeImpl.GetMembers (bindingAttr);
 131                 }
 132
 133                 protected override MethodInfo GetMethodImpl( string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) {
 134                         throw new NotImplementedException ();
 135                         //return typeImpl.GetMethodImpl (name, bindingAttr, binder, callConvention, types, modifiers);
 136                 }
 137
 138                 public override MethodInfo[] GetMethods( BindingFlags bindingAttr) {
 139                         return typeImpl.GetMethods (bindingAttr);
 140                 }
 141
 142                 public override Type GetNestedType( string name, BindingFlags bindingAttr) {
 143                         return typeImpl.GetNestedType (name, bindingAttr);
 144                 }
 145
 146                 public override Type[] GetNestedTypes( BindingFlags bindingAttr) {
 147                         return typeImpl.GetNestedTypes (bindingAttr);
 148                 }
 149
 150                 public override PropertyInfo[] GetProperties( BindingFlags bindingAttr) {
 151                         return typeImpl.GetProperties (bindingAttr);
 152                 }
 153
 154                 protected override PropertyInfo GetPropertyImpl( string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) {
 155                         throw new NotImplementedException ();
 156                         //return typeImpl.GetPropertyImpl (name, bindingAttr, bindingAttr, returnType, types, modifiers);
 157                 }
 158
 159                 protected override bool HasElementTypeImpl() {
 160                         throw new NotImplementedException ();
 161                         //return typeImpl.HasElementTypeImpl ();
 162                 }
 163
 164                 public override object InvokeMember( string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) {
 165                         return typeImpl.InvokeMember (name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
 166                 }
 167
 168                 protected override bool IsArrayImpl() {
 169                         throw new NotImplementedException ();
 170                         //return typeImpl.IsArrayImpl ();
 171                 }
 172
 173                 protected override bool IsByRefImpl() {
 174                         throw new NotImplementedException ();
 175                         //return typeImpl.IsByRefImpl ();
 176                 }
 177
 178                 protected override bool IsCOMObjectImpl() {
 179                         throw new NotImplementedException ();
 180                         //return typeImpl.IsCOMObjectImpl ();
 181                 }
 182
 183                 public override bool IsDefined( Type attributeType, bool inherit) {
 184                         return typeImpl.IsDefined (attributeType, inherit);
 185                 }
 186
 187                 protected override bool IsPointerImpl() {
 188                         throw new NotImplementedException ();
 189                         //return typeImpl.IsPointerImpl ();
 190                 }
 191
 192                 protected override bool IsPrimitiveImpl() {
 193                         throw new NotImplementedException ();
 194                         //return typeImpl.IsPrimitiveImpl ();
 195                 }
 196
 197                 protected override bool IsValueTypeImpl() {
 198                         throw new NotImplementedException ();
 199                         //return typeImpl.IsValueTypeImpl ();
 200                 }
 201
 202         }
 203 }