public static AccessLevelModifiers GetAccessModifiers(this PropertyInfo property)
{
if (property.CanRead && property.CanWrite)
{
AccessLevelModifiers read = property.GetGetMethod(true).GetAccessModifiers();
AccessLevelModifiers write = property.GetGetMethod(true).GetAccessModifiers();
if (read.CompareTo(write) < 0)
{
return(write);
}
else //If they're equal it doesn't matter; if write is lower than read, then use read's
//because the accessability of the property is always the highest of the two.
{
return(read);
}
}
else if (property.CanRead)
{
return(property.GetGetMethod(true).GetAccessModifiers());
}
else if (property.CanWrite)
{
return(property.GetSetMethod(true).GetAccessModifiers());
}
else
{
return(AccessLevelModifiers.Private);
}
}
internal static bool IsModifierAccessible(this AccessLevelModifiers modifiers)
{
switch (modifiers)
{
case AccessLevelModifiers.Private:
case AccessLevelModifiers.PrivateScope:
return(false);
case AccessLevelModifiers.ProtectedAndInternal:
case AccessLevelModifiers.Internal:
case AccessLevelModifiers.Public:
case AccessLevelModifiers.Protected:
case AccessLevelModifiers.ProtectedOrInternal:
default:
return(true);
}
}
internal static AccessLevelModifiers ObtainAccessLevelModifiers(this IEnumerable <ICliMetadataMethodDefinitionTableRow> methods)
{
AccessLevelModifiers resultModifiers = AccessLevelModifiers.PrivateScope;
foreach (var method in methods)
{
AccessLevelModifiers currentModifiers;
switch (method.UsageDetails.Accessibility)
{
case MethodMemberAccessibility.Private:
currentModifiers = AccessLevelModifiers.Private;
break;
case MethodMemberAccessibility.FamilyAndAssembly:
currentModifiers = AccessLevelModifiers.ProtectedAndInternal;
break;
case MethodMemberAccessibility.Assembly:
currentModifiers = AccessLevelModifiers.Internal;
break;
case MethodMemberAccessibility.Family:
currentModifiers = AccessLevelModifiers.Protected;
break;
case MethodMemberAccessibility.FamilyOrAssembly:
currentModifiers = AccessLevelModifiers.ProtectedOrInternal;
break;
case MethodMemberAccessibility.Public:
currentModifiers = AccessLevelModifiers.Public;
break;
default:
currentModifiers = AccessLevelModifiers.PrivateScope;
break;
}
if (resultModifiers.CompareTo(currentModifiers) < 0)
{
resultModifiers = currentModifiers;
}
}
return(resultModifiers);
}
public static IEnumerable <IMember> GetAvailableMembersFor(this IClassType targetClass, string name, AccessLevelModifiers lowestAccessLevel)
{
return(targetClass.GetAvailableMembersFor(k =>
{
if (k.Name != name)
{
return false;
}
if (k is IScopedDeclaration)
{
var scopedMember = (IScopedDeclaration)k;
return IsAtLeast(scopedMember.AccessLevel, lowestAccessLevel);
}
return false;
}));
}
public static IEnumerable <IMember> GetAvailableMembersFor(this IClassType targetClass, AccessLevelModifiers lowestAccessLevel, Predicate <IMember> predicate = null)
{
return(targetClass.GetAvailableMembersFor(predicate.And(k =>
{
if (k is IScopedDeclaration)
{
var scopedMember = (IScopedDeclaration)k;
return IsAtLeast(scopedMember.AccessLevel, lowestAccessLevel);
}
return false;
})));
}
/// <summary>
/// Determines how the <paramref name="modifiers"/> <paramref name="compare"/> to the
/// second set of <see cref="AccessLevelModifiers"/> provided.
/// </summary>
/// <param name="modifiers">The <see cref="AccessLevelModifiers"/> which denote
/// the left side of the comparison.</param>
/// <param name="compare">The <see cref="AccessLevelModifiers"/> which denote the right
/// side of the comparison.</param>
/// <returns>-1 if <paramref name="modifiers"/> is less than
/// the second <see cref="AccessLevelModifiers"/>
/// <paramref name="compare"/>d; 1 if the <see cref="AccessLevelModifiers"/>
/// to <paramref name="compare"/> to is less than the <paramref name="modifiers"/>
/// provided; and '0' if they are equal.</returns>
public static int CompareToEx(this AccessLevelModifiers modifiers, AccessLevelModifiers compare)
{
switch (modifiers)
{
case AccessLevelModifiers.ProtectedAndInternal:
if (compare == AccessLevelModifiers.Private || compare == AccessLevelModifiers.PrivateScope)
{
return(1);
}
else if (compare == AccessLevelModifiers.ProtectedAndInternal)
{
return(0);
}
else
{
return(-1);
}
case AccessLevelModifiers.Internal:
switch (compare)
{
case AccessLevelModifiers.ProtectedAndInternal:
case AccessLevelModifiers.Private:
case AccessLevelModifiers.PrivateScope:
return(1);
case AccessLevelModifiers.Protected:
case AccessLevelModifiers.ProtectedOrInternal:
case AccessLevelModifiers.Public:
return(-1);
case AccessLevelModifiers.Internal:
default:
return(0);
}
case AccessLevelModifiers.Private:
if (compare == AccessLevelModifiers.PrivateScope)
{
return(1);
}
else if (compare == AccessLevelModifiers.Private)
{
return(0);
}
else
{
return(-1);
}
case AccessLevelModifiers.Protected:
switch (compare)
{
case AccessLevelModifiers.ProtectedAndInternal:
case AccessLevelModifiers.PrivateScope:
case AccessLevelModifiers.Internal:
case AccessLevelModifiers.Private:
return(1);
case AccessLevelModifiers.ProtectedOrInternal:
case AccessLevelModifiers.Public:
return(-1);
case AccessLevelModifiers.Protected:
default:
return(0);
}
case AccessLevelModifiers.ProtectedOrInternal:
if (compare == AccessLevelModifiers.Public)
{
return(-1);
}
else if (compare == AccessLevelModifiers.ProtectedOrInternal)
{
return(0);
}
else
{
return(1);
}
case AccessLevelModifiers.Public:
if (compare == AccessLevelModifiers.Public)
{
return(0);
}
else
{
return(1);
}
default:
return(0);
}
}
public static IEnumerable <IClassMethodMember> GetAvailableMethodsFor(this IClassType targetClass, AccessLevelModifiers lowestAccessLevel, Predicate <IClassMethodMember> predicate = null)
{
return(targetClass.GetAvailableMethodsFor(predicate.And(k => IsAtLeast(k.AccessLevel, lowestAccessLevel))));
}
public static IEnumerable <IClassMethodMember> GetAvailableMethodsFor(this IClassType targetClass, string name, AccessLevelModifiers lowestAccessLevel = AccessLevelModifiers.Public)
{
return(targetClass.GetAvailableMethodsFor(m => m.Name == name && IsAtLeast(m.AccessLevel, lowestAccessLevel)));
}
public static IEnumerable <IClassMethodMember> Filter(this IMethodSignatureMemberDictionary <IMethodParameterMember <IClassMethodMember, IClassType>, IClassMethodMember, IClassType> target, string name, AccessLevelModifiers lowestAccessLevel = AccessLevelModifiers.Public)
{
return(from m in target.Values
where m.Name == name
where IsAtLeast(m.AccessLevel, lowestAccessLevel)
select m);
}
public static bool IsAtLeast(AccessLevelModifiers source, AccessLevelModifiers target)
{
switch (source)
{
case AccessLevelModifiers.ProtectedAndInternal:
switch (target)
{
case AccessLevelModifiers.ProtectedAndInternal:
case AccessLevelModifiers.Private:
case AccessLevelModifiers.PrivateScope:
return(true);
default:
return(false);
}
case AccessLevelModifiers.Internal:
switch (target)
{
case AccessLevelModifiers.ProtectedAndInternal:
case AccessLevelModifiers.Internal:
case AccessLevelModifiers.Private:
case AccessLevelModifiers.PrivateScope:
case AccessLevelModifiers.ProtectedOrInternal:
return(true);
default:
return(false);
}
case AccessLevelModifiers.Private:
switch (target)
{
case AccessLevelModifiers.Private:
case AccessLevelModifiers.PrivateScope:
return(true);
default:
return(false);
}
case AccessLevelModifiers.PrivateScope:
switch (target)
{
case AccessLevelModifiers.PrivateScope:
return(true);
default:
return(false);
}
case AccessLevelModifiers.Public:
return(true);
case AccessLevelModifiers.Protected:
switch (target)
{
case AccessLevelModifiers.Public:
case AccessLevelModifiers.Internal:
return(false);
default:
return(true);
}
case AccessLevelModifiers.ProtectedOrInternal:
switch (target)
{
case AccessLevelModifiers.Public:
return(false);
default:
return(true);
}
}
return(false);
}
