Merge pull request #439 from mono-soc-2012/garyb/iconfix

[mono.git] / mcs / class / IKVM.Reflection / EventInfo.cs

diff --git a/mcs/class/IKVM.Reflection/EventInfo.cs b/mcs/class/IKVM.Reflection/EventInfo.cs
index 203a6368a453e49b91ac6661128499488764cc5c..ffd9a0df32dfe8bfc81590f006f1f01bdcecb6fd 100644 (file)
--- a/mcs/class/IKVM.Reflection/EventInfo.cs
+++ b/mcs/class/IKVM.Reflection/EventInfo.cs
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2009 Jeroen Frijters
+  Copyright (C) 2009-2012 Jeroen Frijters
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -21,6 +21,8 @@
   jeroen@frijters.net
   
 */
+using System.Collections.Generic;
+using System.Diagnostics;
 
 namespace IKVM.Reflection
 {
@@ -44,6 +46,7 @@ namespace IKVM.Reflection
                public abstract MethodInfo[] __GetMethods();
                public abstract Type EventHandlerType { get; }
                internal abstract bool IsPublic { get; }
+               internal abstract bool IsNonPrivate { get; }
                internal abstract bool IsStatic { get; }
 
                public bool IsSpecialName
@@ -75,5 +78,160 @@ namespace IKVM.Reflection
                {
                        return new GenericEventInfo(this.DeclaringType.BindTypeParameters(type), this);
                }
+
+               public override string ToString()
+               {
+                       return this.DeclaringType.ToString() + " " + Name;
+               }
+
+               internal sealed override bool BindingFlagsMatch(BindingFlags flags)
+               {
+                       return BindingFlagsMatch(IsPublic, flags, BindingFlags.Public, BindingFlags.NonPublic)
+                               && BindingFlagsMatch(IsStatic, flags, BindingFlags.Static, BindingFlags.Instance);
+               }
+
+               internal sealed override bool BindingFlagsMatchInherited(BindingFlags flags)
+               {
+                       return IsNonPrivate
+                               && BindingFlagsMatch(IsPublic, flags, BindingFlags.Public, BindingFlags.NonPublic)
+                               && BindingFlagsMatch(IsStatic, flags, BindingFlags.Static | BindingFlags.FlattenHierarchy, BindingFlags.Instance);
+               }
+
+               internal sealed override MemberInfo SetReflectedType(Type type)
+               {
+                       return new EventInfoWithReflectedType(type, this);
+               }
+
+               internal sealed override List<CustomAttributeData> GetPseudoCustomAttributes(Type attributeType)
+               {
+                       // events don't have pseudo custom attributes
+                       return null;
+               }
+       }
+
+       sealed class EventInfoWithReflectedType : EventInfo
+       {
+               private readonly Type reflectedType;
+               private readonly EventInfo eventInfo;
+
+               internal EventInfoWithReflectedType(Type reflectedType, EventInfo eventInfo)
+               {
+                       Debug.Assert(reflectedType != eventInfo.DeclaringType);
+                       this.reflectedType = reflectedType;
+                       this.eventInfo = eventInfo;
+               }
+
+               public override EventAttributes Attributes
+               {
+                       get { return eventInfo.Attributes; }
+               }
+
+               public override MethodInfo GetAddMethod(bool nonPublic)
+               {
+                       return SetReflectedType(eventInfo.GetAddMethod(nonPublic), reflectedType);
+               }
+
+               public override MethodInfo GetRaiseMethod(bool nonPublic)
+               {
+                       return SetReflectedType(eventInfo.GetRaiseMethod(nonPublic), reflectedType);
+               }
+
+               public override MethodInfo GetRemoveMethod(bool nonPublic)
+               {
+                       return SetReflectedType(eventInfo.GetRemoveMethod(nonPublic), reflectedType);
+               }
+
+               public override MethodInfo[] GetOtherMethods(bool nonPublic)
+               {
+                       return SetReflectedType(eventInfo.GetOtherMethods(nonPublic), reflectedType);
+               }
+
+               public override MethodInfo[] __GetMethods()
+               {
+                       return SetReflectedType(eventInfo.__GetMethods(), reflectedType);
+               }
+
+               public override Type EventHandlerType
+               {
+                       get { return eventInfo.EventHandlerType; }
+               }
+
+               internal override bool IsPublic
+               {
+                       get { return eventInfo.IsPublic; }
+               }
+
+               internal override bool IsNonPrivate
+               {
+                       get { return eventInfo.IsNonPrivate; }
+               }
+
+               internal override bool IsStatic
+               {
+                       get { return eventInfo.IsStatic; }
+               }
+
+               internal override EventInfo BindTypeParameters(Type type)
+               {
+                       return eventInfo.BindTypeParameters(type);
+               }
+
+               public override string ToString()
+               {
+                       return eventInfo.ToString();
+               }
+
+               public override bool __IsMissing
+               {
+                       get { return eventInfo.__IsMissing; }
+               }
+
+               public override Type DeclaringType
+               {
+                       get { return eventInfo.DeclaringType; }
+               }
+
+               public override Type ReflectedType
+               {
+                       get { return reflectedType; }
+               }
+
+               public override bool Equals(object obj)
+               {
+                       EventInfoWithReflectedType other = obj as EventInfoWithReflectedType;
+                       return other != null
+                               && other.reflectedType == reflectedType
+                               && other.eventInfo == eventInfo;
+               }
+
+               public override int GetHashCode()
+               {
+                       return reflectedType.GetHashCode() ^ eventInfo.GetHashCode();
+               }
+
+               public override int MetadataToken
+               {
+                       get { return eventInfo.MetadataToken; }
+               }
+
+               public override Module Module
+               {
+                       get { return eventInfo.Module; }
+               }
+
+               public override string Name
+               {
+                       get { return eventInfo.Name; }
+               }
+
+               internal override bool IsBaked
+               {
+                       get { return eventInfo.IsBaked; }
+               }
+
+               internal override int GetCurrentToken()
+               {
+                       return eventInfo.GetCurrentToken();
+               }
        }
 }