private CodebaseSubset(IEnumerable <Type> typeSet, TypeFilter typeFilter, MemberFilter memberFilter, TypeFilter memberTypeFilter = null)
{
Ensure.That(nameof(typeSet)).IsNotNull(typeSet);
Ensure.That(nameof(typeFilter)).IsNotNull(typeFilter);
Ensure.That(nameof(memberFilter)).IsNotNull(memberFilter);
this.typeSet = typeSet;
this.typeFilter = typeFilter;
this.memberFilter = memberFilter;
this.memberTypeFilter = memberTypeFilter;
}
public Query(IEnumerable <Type> typeSet, TypeFilter typeFilter, MemberFilter memberFilter, TypeFilter memberTypeFilter)
{
types = null;
this.typeSet = typeSet;
this.typeFilter = typeFilter;
this.memberFilter = memberFilter;
this.memberTypeFilter = memberTypeFilter;
}
internal static CodebaseSubset Get(IEnumerable <Type> typeSet, TypeFilter typeFilter, MemberFilter memberFilter, TypeFilter memberTypeFilter = null)
{
var query = new Query(typeSet, typeFilter, memberFilter, memberTypeFilter);
if (!cache.ContainsKey(query))
{
cache.Add(query, new CodebaseSubset(typeSet, typeFilter, memberFilter, memberTypeFilter));
}
return(cache[query]);
}
public MemberOptionTree(UnityObject target, MemberFilter memberFilter, TypeFilter memberTypeFilter, ActionDirection direction)
: this(EditorUnityObjectUtility.GetUnityTypes(target), memberFilter, memberTypeFilter, direction)
{
rootMode = RootMode.Types;
}
public bool ValidateMember(MemberInfo member, TypeFilter typeFilter = null)
{
if (member is FieldInfo)
{
var field = (FieldInfo)member;
// Whitelist
var isGettable = true;
var isSettable = !field.IsLiteral && !field.IsInitOnly;
var whitelisted = Fields || (Gettable && isGettable) || (Settable && isSettable);
if (!whitelisted)
{
return(false);
}
// Targetting
var isTargeted = !field.IsStatic;
if (!Targeted && isTargeted)
{
return(false);
}
if (!NonTargeted && !isTargeted)
{
return(false);
}
// Accessibility
if (!WriteOnly && !isGettable)
{
return(false);
}
if (!ReadOnly && !isSettable)
{
return(false);
}
// Visibility
if (!Public && field.IsPublic)
{
return(false);
}
if (!NonPublic && !field.IsPublic)
{
return(false);
}
// Type
if (typeFilter != null && !typeFilter.ValidateType(field.FieldType))
{
return(false);
}
// Other
if (field.IsSpecialName)
{
return(false);
}
}
else if (member is PropertyInfo)
{
var property = (PropertyInfo)member;
var getter = property.GetGetMethod(true);
var setter = property.GetSetMethod(true);
// Whitelist
var isGettable = property.CanRead;
var isSettable = property.CanWrite;
var whitelisted = Properties || (Gettable && isGettable) || (Settable && isSettable);
if (!whitelisted)
{
return(false);
}
// Visibility & Accessibility
// TODO: Refactor + Take into account when Public = false
var requiresRead = (!WriteOnly || (!Properties && Gettable));
var requiresWrite = (!ReadOnly || (!Properties && Settable));
var canRead = property.CanRead && (NonPublic || getter.IsPublic);
var canWrite = property.CanWrite && (NonPublic || setter.IsPublic);
if (requiresRead && !canRead)
{
return(false);
}
if (requiresWrite && !canWrite)
{
return(false);
}
// Targetting
var isTargeted = !(getter ?? setter).IsStatic;
if (!Targeted && isTargeted)
{
return(false);
}
if (!NonTargeted && !isTargeted)
{
return(false);
}
// Type
if (typeFilter != null && !typeFilter.ValidateType(property.PropertyType))
{
return(false);
}
// Other
if (property.IsSpecialName)
{
return(false);
}
if (property.GetIndexParameters().Any())
{
return(false);
}
}
else if (member is MethodBase)
{
var methodOrConstructor = (MethodBase)member;
var isExtension = methodOrConstructor.IsExtensionMethod();
var isTargeted = !methodOrConstructor.IsStatic || isExtension;
// Visibility
if (!Public && methodOrConstructor.IsPublic)
{
return(false);
}
if (!NonPublic && !methodOrConstructor.IsPublic)
{
return(false);
}
// Other
if (!Parameters && (methodOrConstructor.GetParameters().Length > (isExtension ? 1 : 0)))
{
return(false);
}
if (!OpenConstructedGeneric && methodOrConstructor.ContainsGenericParameters)
{
return(false);
}
if (member is MethodInfo)
{
var method = (MethodInfo)member;
var isOperator = method.IsOperator();
var isConversion = method.IsUserDefinedConversion();
// Whitelist
var isGettable = method.ReturnType != typeof(void);
var isSettable = false;
var whitelisted = Methods || (Gettable && isGettable) || (Settable && isSettable);
if (!whitelisted)
{
return(false);
}
// Targetting
if (!Targeted && isTargeted)
{
return(false);
}
if (!NonTargeted && !isTargeted)
{
return(false);
}
// Operators
if (!Operators && isOperator)
{
return(false);
}
// Extensions
if (!Extensions && isExtension)
{
return(false);
}
// Type
if (typeFilter != null && !typeFilter.ValidateType(method.ReturnType))
{
return(false);
}
// Other
if (method.IsSpecialName && !(isOperator || isConversion))
{
return(false);
}
}
else if (member is ConstructorInfo)
{
var constructor = (ConstructorInfo)member;
// Whitelist
var isGettable = true;
var isSettable = false;
var whitelisted = Constructors || (Gettable && isGettable) || (Settable && isSettable);
if (!whitelisted)
{
return(false);
}
// Type
if (typeFilter != null && !typeFilter.ValidateType(constructor.DeclaringType))
{
return(false);
}
// Type Initializers
if (constructor.IsStatic && !TypeInitializers)
{
return(false);
}
// Other
if (typeof(Component).IsAssignableFrom(member.DeclaringType) || typeof(ScriptableObject).IsAssignableFrom(member.DeclaringType))
{
return(false);
}
}
}
// Obsolete
if (!Obsolete && member.HasAttribute <ObsoleteAttribute>(false))
{
return(false);
}
// CLS Compliance
if (!ClsNonCompliant)
{
var clsCompliantAttribute = member.GetAttribute <CLSCompliantAttribute>();
if (clsCompliantAttribute != null && !clsCompliantAttribute.IsCompliant)
{
return(false);
}
}
return(true);
}
public static CodebaseSubset Subset(IEnumerable <Type> typeSet, TypeFilter typeFilter, MemberFilter memberFilter, TypeFilter memberTypeFilter = null)
{
return(CodebaseSubset.Get(typeSet, typeFilter, memberFilter, memberTypeFilter));
}
