| public Inherits ( Mono.Cecil.TypeDefinition type, string interfaceFullName ) : bool | ||
| type | Mono.Cecil.TypeDefinition | |
| interfaceFullName | string | |
| return | bool | |
public bool Test(TypeKey type, InheritMap map)
{
if (!string.IsNullOrEmpty(attrib))
{
if (string.Equals(attrib, "public", StringComparison.InvariantCultureIgnoreCase))
{
if (!type.TypeDefinition.IsTypePublic())
{
return(false);
}
}
else
{
throw new ObfuscarException(string.Format(
"'{0}' is not valid for the 'attrib' value of the SkipType element. Only 'public' is supported by now.",
attrib));
}
}
// type's regex matches
if (nameRx != null && !nameRx.IsMatch(type.Fullname))
{
return(false);
}
// type's name matches
if (!string.IsNullOrEmpty(name) && !Helper.CompareOptionalRegex(type.Fullname, name))
{
return(false);
}
if (isSerializable.HasValue)
{
if (isSerializable != type.TypeDefinition.IsSerializable)
{
return(false);
}
}
if (isStatic.HasValue)
{
if (isStatic != (type.TypeDefinition.IsSealed && type.TypeDefinition.IsAbstract))
{
return(false);
}
}
if (!string.IsNullOrEmpty(inherits))
{
if (!map.Inherits(type.TypeDefinition, inherits))
{
return(false);
}
}
return(true);
}
public bool Test(MethodKey method, InheritMap map)
{
if (key != null)
{
return(method == key);
}
// method name matches type regex?
if (!String.IsNullOrEmpty(type) && !Helper.CompareOptionalRegex(method.TypeKey.Fullname, type))
{
return(false);
}
// method visibility matches
if (CheckMemberVisibility(this.attrib, typeAttrib, method.MethodAttributes, method.DeclaringType))
{
return(false);
}
// method's name matches
if (nameRx != null && !nameRx.IsMatch(method.Name))
{
return(false);
}
// method's name matches
if (!string.IsNullOrEmpty(name) && !Helper.CompareOptionalRegex(method.Name, name))
{
return(false);
}
// check is method's static flag matches.
if (isStatic.HasValue)
{
bool methodIsStatic = (method.MethodAttributes & MethodAttributes.Static) == MethodAttributes.Static;
if (isStatic != methodIsStatic)
{
return(false);
}
}
// finally does method's type inherit?
if (!string.IsNullOrEmpty(inherits))
{
if (!map.Inherits(method.DeclaringType, inherits))
{
return(false);
}
}
return(true);
}
public bool Test(FieldKey field, InheritMap map)
{
if (!string.IsNullOrEmpty(decorator))
{
var match = false;
foreach (var typeField in field.TypeKey.TypeDefinition.Fields)
{
if (typeField.Name != field.Name)
{
continue;
}
if (!typeField.HasCustomAttributes)
{
return(false);
}
foreach (var customAttr in typeField.CustomAttributes)
{
if (customAttr.AttributeType.FullName == decorator)
{
match = true;
break;
}
}
}
if (!match)
{
return(false);
}
}
if (!string.IsNullOrEmpty(type) && !Helper.CompareOptionalRegex(field.TypeKey.Fullname, type))
{
return(false);
}
// It's not very clean to use CheckMethodVisibility() from MethodTester. But we don't want duplicate code either.
if (MethodTester.CheckMemberVisibility(attrib, typeAttrib, (MethodAttributes)field.FieldAttributes,
field.DeclaringType))
{
return(false);
}
if (nameRx != null && !nameRx.IsMatch(field.Name))
{
return(false);
}
if (!string.IsNullOrEmpty(name) && !Helper.CompareOptionalRegex(field.Name, name))
{
return(false);
}
if (isStatic.HasValue)
{
bool fieldIsStatic = (field.FieldAttributes & FieldAttributes.Static) == FieldAttributes.Static;
if (isStatic.Value != fieldIsStatic)
{
return(false);
}
}
if (isSerializable.HasValue)
{
if (isSerializable.Value && ((field.FieldAttributes & FieldAttributes.NotSerialized) ==
FieldAttributes.NotSerialized))
{
return(false);
}
bool fieldIsPublic = (field.FieldAttributes & FieldAttributes.Public) == FieldAttributes.Public;
bool parentIsSerializable = field.DeclaringType.IsSerializable;
if (isSerializable != (fieldIsPublic && parentIsSerializable))
{
return(false);
}
}
// finally does method's type inherit?
if (!string.IsNullOrEmpty(inherits))
{
if (!map.Inherits(field.DeclaringType, inherits))
{
return(false);
}
}
return(true);
}