void CheckSearchMode(TypeQueryMode mode)
{
if (!IsEnabled(mode, TypeQueryMode.Internal) && !IsEnabled(mode, TypeQueryMode.Public))
{
throw new ArgumentException("You must set QueryMode.Internal and/or QueryMode.Public find something.");
}
if (!IsEnabled(mode, TypeQueryMode.Interface) && !IsEnabled(mode, TypeQueryMode.Class) && !IsEnabled(mode, TypeQueryMode.ValueType))
{
throw new ArgumentException("You must search for a class, interface or value type in your module. See QueryMode enumeration for values");
}
}
/// <summary>
/// Query for specifc types in a specific namespace
/// </summary>
/// <param name="mode">The mode.</param>
/// <param name="namespaceFilter">The namespace filter.</param>
/// <param name="typeNameFilter">The type name filter.</param>
public TypeQuery(TypeQueryMode mode, string namespaceFilter, string typeNameFilter)
{
this.myQueryMode = mode;
// To search for nothing makes no sense. Seearch for types with any visibility
if (!this.IsEnabled(TypeQueryMode.Public) && !this.IsEnabled(TypeQueryMode.Internal))
{
this.myQueryMode |= TypeQueryMode.Internal | TypeQueryMode.Public;
}
// If no type interface,struct,class is searched enable all by default
if (!this.IsEnabled(TypeQueryMode.Class) && !this.IsEnabled(TypeQueryMode.Interface) && !this.IsEnabled(TypeQueryMode.ValueType) && !this.IsEnabled(TypeQueryMode.Enum))
{
this.myQueryMode |= TypeQueryMode.Class | TypeQueryMode.Interface | TypeQueryMode.ValueType | TypeQueryMode.Enum;
}
this.NamespaceFilter = namespaceFilter;
this.TypeNameFilter = typeNameFilter;
}
private TypeQueryMode GetQueryMode(Match m)
{
TypeQueryMode mode = TypeQueryMode.None;
if (Captures(m, "public"))
{
mode |= TypeQueryMode.Public;
}
if (Captures(m, "internal"))
{
mode |= TypeQueryMode.Internal;
}
if (Captures(m, "class"))
{
mode |= TypeQueryMode.Class;
}
if (Captures(m, "interface"))
{
mode |= TypeQueryMode.Interface;
}
if (Captures(m, "struct"))
{
mode |= TypeQueryMode.ValueType;
}
if (Captures(m, "enum"))
{
mode |= TypeQueryMode.Enum;
}
if (Captures(m, "nocompiler"))
{
mode |= TypeQueryMode.NotCompilerGenerated;
}
if (Captures(m, "api"))
{
mode |= TypeQueryMode.ApiRelevant;
}
return(mode);
}
public List <TypeQuery> GetQueries(string typeQueries, TypeQueryMode additionalFlags)
{
if (typeQueries == null)
{
throw new ArgumentNullException("typeQueries");
}
string trimedQuery = typeQueries.Trim();
if (trimedQuery == "")
{
throw new ArgumentException("typeQueries was an empty string");
}
string[] queries = trimedQuery.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
List <TypeQuery> ret = new List <TypeQuery>();
foreach (string query in queries)
{
Match m = myQueryParser.Match(query);
if (!m.Success)
{
throw new ArgumentException(
String.Format("The type query \"{0}\" is not of the form [public|internal|class|interface|struct|enum|nocompiler|api] typename", query));
}
TypeQueryMode mode = GetQueryMode(m);
var nameSpaceTypeName = SplitNameSpaceAndType(m.Groups["typeName"].Value);
var typeQuery = new TypeQuery(mode, nameSpaceTypeName.Key, nameSpaceTypeName.Value);
if (typeQuery.SearchMode == TypeQueryMode.None)
{
typeQuery.SearchMode |= additionalFlags;
}
ret.Add(typeQuery);
}
return(ret);
}
public List<TypeQuery> GetQueries(string typeQueries, TypeQueryMode additionalFlags)
{
if (typeQueries == null)
{
throw new ArgumentNullException("typeQueries");
}
var trimedQuery = typeQueries.Trim();
if (trimedQuery == "")
{
throw new ArgumentException("typeQueries was an empty string");
}
var queries = trimedQuery.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
var ret = new List<TypeQuery>();
foreach (var query in queries)
{
var m = myQueryParser.Match(query);
if (!m.Success)
{
throw new ArgumentException(string.Format("The type query \"{0}\" is not of the form [public|internal|class|interface|struct|enum|nocompiler|api] typename", query));
}
var mode = this.GetQueryMode(m);
var nameSpaceTypeName = this.SplitNameSpaceAndType(m.Groups["typeName"].Value);
var typeQuery = new TypeQuery(mode, nameSpaceTypeName.Key, nameSpaceTypeName.Value);
if (typeQuery.SearchMode == TypeQueryMode.None)
{
typeQuery.SearchMode |= additionalFlags;
}
ret.Add(typeQuery);
}
return ret;
}
bool IsEnabled(TypeQueryMode mode)
{
return(IsEnabled(myQueryMode, mode));
}
bool IsEnabled(TypeQueryMode current, TypeQueryMode requested)
{
return((current & requested) == requested);
}
/// <summary>
/// Query for specific types in a namespace
/// </summary>
/// <param name="mode"></param>
/// <param name="nameSpaceFilter"></param>
public TypeQuery(TypeQueryMode mode, string nameSpaceFilter)
: this(mode, nameSpaceFilter, null)
{
}
/// <summary>
/// Query for specific types like interfaces, public classes, ...
/// </summary>
/// <param name="mode"></param>
public TypeQuery(TypeQueryMode mode) : this(mode, null)
{
}
/// <summary>
/// Parse a query string which can contain a list of type queries separated by ;. A type query can be like a
/// normal class declaration. E.g. "public class *;public interface *" would be a valid type query list.
/// </summary>
/// <param name="typeQueryList">Type query list</param>
/// <param name="defaultFlags">Default query flags to use if none are part of the query. A query does not need to specify visbility falgs.</param>
/// <returns>List of parsed queries</returns>
/// <exception cref="ArgumentException">When the query was empty or invalid.</exception>
/// <exception cref="ArgumentNullException">The input string was null</exception>
public static List <TypeQuery> GetQueries(string typeQueryList, TypeQueryMode defaultFlags)
{
return(myQueryFactory.GetQueries(typeQueryList, defaultFlags));
}
private bool IsEnabled(TypeQueryMode mode)
{
return(this.IsEnabled(this.myQueryMode, mode));
}
