[Dotgnu-pnet-commits] pnetlib/runtime/System/Reflection ClrType.cs, 1.20, 1.21

[Rhys Weatherley <address@hidden>]

Update of /cvsroot/dotgnu-pnet/pnetlib/runtime/System/Reflection
In directory subversions:/tmp/cvs-serv20948/runtime/System/Reflection

Modified Files:
        ClrType.cs 
Log Message:


Redesign the "TrimMembers" function so that it is O(n log n) instead of O(n^2).


Index: ClrType.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/runtime/System/Reflection/ClrType.cs,v
retrieving revision 1.20
retrieving revision 1.21
diff -C2 -d -r1.20 -r1.21
*** ClrType.cs  22 Aug 2003 03:04:07 -0000      1.20
--- ClrType.cs  28 Sep 2003 22:48:25 -0000      1.21
***************
*** 35,38 ****
--- 35,51 ----
        // Internal state.
        internal IntPtr privateData;
+       private static IComparer memberNameComparer =
+                       new MemberNameComparer();
+ 
+       // Comparer class for member names.
+       private sealed class MemberNameComparer : IComparer
+       {
+               public int Compare(Object x, Object y)
+                               {
+                                       return String.CompareOrdinal
+                                               (((MemberInfo)x).Name, 
((MemberInfo)y).Name);
+                               }
+ 
+       }; // class MemberNameComparer
  
        // Constructor.  This class is normally instantiated
***************
*** 363,397 ****
                                int best;
  
!                               for(int i=0;i<members.Length;i++)
                                {
!                                       best=i;
!                                       if(members[best]==null)
!                                       {
!                                               continue;
!                                       }
!                                       for(int j=i+1;j<members.Length;j++)
                                        {
!                                               if(members[j]==null)
                                                {
!                                                       continue;
                                                }
! 
!                                               MemberComparison 
cmp=CompareMembers(members[j], 
!                                                                               
                                        members[best]);
!                                               if((cmp & 
MemberComparison.Candidate)!= 0)
                                                {
!                                                       if((cmp & 
MemberComparison.Override)!= 0)
!                                                       {
!                                                               
members[best]=null;
!                                                               best=j;
!                                                       }
!                                                       else
                                                        {
!                                                               members[j]=null;
                                                        }
                                                }
                                        }
                                        list.Add(members[best]);
-                                       members[best]=null;
                                }
                                return list.ToArray(type);
--- 376,408 ----
                                int best;
  
!                               // Sort the members on name to make it easier to
!                               // efficiently remove overrides.
!                               Array.Sort(members, memberNameComparer);
! 
!                               // Remove overrides from the list.
!                               int i = 0;
!                               while(i < members.Length)
                                {
!                                       best = i;
!                                       ++i;
!                                       while(i < members.Length &&
!                                             members[i].Name == 
members[best].Name)
                                        {
!                                               MemberComparison cmp = 
CompareMembers(members[i], 
!                                                                               
                                          members[best]);
!                                               if(cmp == MemberComparison.None)
                                                {
!                                                       break;
                                                }
!                                               if((cmp & 
MemberComparison.Candidate) != 0)
                                                {
!                                                       if((cmp & 
MemberComparison.Override) != 0)
                                                        {
!                                                               best = i;
                                                        }
                                                }
+                                               ++i;
                                        }
                                        list.Add(members[best]);
                                }
                                return list.ToArray(type);