/// <summary>
/// Queries for specific fields in a class
/// </summary>
/// <param name="query">Query string</param>
/// <remarks>
/// The field query must contain at least the field type and name to query for. Access modifier
/// are optional
/// Example:
/// public * *
/// protectd * *
/// static readonly protected * *
/// string m_*
/// * my* // Get all fields which field name begins with my
/// </remarks>
public FieldQuery(string query) : base(query)
{
Parser = FieldQueryParser;
var match = Parser.Match(query);
if (!match.Success)
{
throw new ArgumentException(
String.Format("The field query string {0} was not a valid query.", query));
}
myExcludeCompilerGeneratedFields = true;
SetModifierFilter(match);
FieldTypeFilter = GenericTypeMapper.ConvertClrTypeNames(Value(match, "fieldType"));
if (!FieldTypeFilter.StartsWith("*"))
{
FieldTypeFilter = "*" + FieldTypeFilter;
}
if (FieldTypeFilter == "*")
{
FieldTypeFilter = null;
}
NameFilter = Value(match, "fieldName");
}
public static Field Field(this IMembers members, Type fieldType, string fieldName)
{
var typed = new FieldTypeFilter(members.Fields(), fieldType);
var named = new MemberNameFilter <Field, FieldInfo>(typed, fieldName);
return(named.Single());
}
public void ReturnsFieldWithGivenType()
{
Assert.Same(selected, members.Field(fieldType));
FieldTypeFilter filter = VerifyFilter(selection, fieldType);
Assert.Same(fields, filter.Source);
}
public void ReturnsFieldWithGivenType()
{
Assert.Same(selected, testType.Field(fieldType));
FieldTypeFilter typed = VerifyFilter(selection, fieldType);
VerifyStaticFields(typed.Source, testType);
}
public void ReturnsFieldWithGivenType()
{
Assert.Same(selected, instance.Field(fieldType));
FieldTypeFilter named = VerifyFilter(selection, fieldType);
VerifyInstanceFields(named.Source, instance);
}
public void ReturnsFieldWithGivenTypeAndName()
{
Assert.Same(selected, members.Field(fieldType, fieldName));
MemberNameFilter <Field, FieldInfo> nameFilter = VerifyFilter(selection, fieldName);
FieldTypeFilter typeFilter = VerifyFilter(nameFilter.Source, fieldType);
Assert.Same(fields, typeFilter.Source);
}
public void ReturnsGenericFieldOfGivenType()
{
Field <FieldValue> generic = testType.Field <FieldValue>();
VerifyGenericField(selected, generic);
FieldTypeFilter typed = VerifyFilter(selection, typeof(FieldValue));
VerifyStaticFields(typed.Source, testType);
}
public void ReturnsFieldWithGivenTypeAndName()
{
Assert.Same(selected, testType.Field(fieldType, fieldName));
MemberNameFilter <Field, FieldInfo> named = VerifyFilter(selection, fieldName);
FieldTypeFilter typed = VerifyFilter(named.Source, fieldType);
VerifyStaticFields(typed.Source, testType);
}
public void ReturnsGenericFieldWithGivenType()
{
Field <FieldValue> generic = members.Field <FieldValue>();
VerifyGenericField(selected, generic);
FieldTypeFilter typeFilter = VerifyFilter(selection, typeof(FieldValue));
Assert.Same(fields, typeFilter.Source);
}
public void ReturnsGenericFieldWithGivenTypeAndName()
{
Field <FieldValue> generic = testType.Field <FieldValue>(fieldName);
VerifyGenericField(selected, generic);
MemberNameFilter <Field, FieldInfo> named = VerifyFilter(selection, fieldName);
FieldTypeFilter typed = VerifyFilter(named.Source, typeof(FieldValue));
VerifyStaticFields(typed.Source, testType);
}
public void ReturnsGenericFieldWithGivenTypeAndName()
{
Field <FieldValue> generic = members.Field <FieldValue>(fieldName);
VerifyGenericField(selected, generic);
MemberNameFilter <Field, FieldInfo> nameFilter = VerifyFilter(selection, fieldName);
FieldTypeFilter typeFilter = VerifyFilter(nameFilter.Source, fieldType);
Assert.Same(fields, typeFilter.Source);
}
