public WhoReferencesAssembly(UsageQueryAggregator aggregator, string fileName) : base(aggregator)
{
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentException("File name was null or empty.");
}
myAssembly = Path.GetFileNameWithoutExtension(fileName);
aggregator.AddVisitScope(fileName);
}
public WhoInstantiatesType(UsageQueryAggregator aggregator, TypeDefinition type)
: base(aggregator)
{
if (type == null)
{
throw new ArgumentNullException("type was null");
}
myType = type;
Aggregator.AddVisitScope(type.Module.Assembly.Name.Name);
}
public UsageVisitor(UsageQueryAggregator aggregator)
{
if (aggregator == null)
{
throw new ArgumentNullException("aggregator");
}
Aggregator = aggregator;
// subscribe ourself to the aggregator when the query is constructed
Aggregator.AddQuery(this);
}
public WhoUsesStringConstant(UsageQueryAggregator aggregator, string searchString, bool bExactMatch, StringComparison compMode) :
base(aggregator)
{
if (String.IsNullOrEmpty(searchString))
{
throw new ArgumentException("The search string was null or empty");
}
mySearchString = searchString;
mybExatchMatch = bExactMatch;
myComparisonMode = compMode;
}
public WhoDerivesFromType(UsageQueryAggregator aggregator, List <TypeDefinition> typeDefs) : base(aggregator)
{
if (typeDefs == null)
{
throw new ArgumentException("The type list to query for was null.");
}
foreach (var type in typeDefs)
{
Aggregator.AddVisitScope(type.Module.Assembly.Name.Name);
}
mySearchBaseTypes = typeDefs;
}
public WhoUsesEvents(UsageQueryAggregator aggreagator, List <EventDefinition> events) : base(aggreagator)
{
if (events == null)
{
throw new ArgumentException("The events list was null.");
}
myEvents = events;
foreach (var ev in myEvents)
{
Aggregator.AddVisitScope(ev.AddMethod.DeclaringType.Module.Assembly.Name.Name);
myEventNames.Add(ev.AddMethod.Name);
myEventNames.Add(ev.RemoveMethod.Name);
}
}
public WhoHasFieldOfType(UsageQueryAggregator aggregator, List <TypeDefinition> fieldTypes)
: base(aggregator)
{
if (fieldTypes == null)
{
throw new ArgumentNullException("fieldTypes");
}
mySearchTypes = fieldTypes;
foreach (TypeDefinition fieldType in fieldTypes)
{
mySearchTypeNames.Add(fieldType.Name);
Aggregator.AddVisitScope(fieldType.Module.Assembly.Name.Name);
}
}
public WhoUsesMethod(UsageQueryAggregator aggregator, List <MethodDefinition> methods) : base(aggregator)
{
if (methods == null)
{
throw new ArgumentNullException("The method list to query for was null.");
}
foreach (var method in methods)
{
Aggregator.AddVisitScope(method.DeclaringType.Module.Assembly.Name.Name);
List <MethodDefinition> typeMethods = null;
if (!myMethodNames.TryGetValue(method.DeclaringType.Name, out typeMethods))
{
typeMethods = new List <MethodDefinition>();
myMethodNames[method.DeclaringType.Name] = typeMethods;
}
myMethodNames[method.DeclaringType.Name].Add(method);
}
}
public WhoAccessesField(UsageQueryAggregator aggregator, List <FieldDefinition> fields) : base(aggregator)
{
if (fields == null)
{
throw new ArgumentException("The field list was null.");
}
mySearchFields = fields;
foreach (FieldDefinition field in fields)
{
if (field.HasConstant)
{
throw new ArgumentException(
String.Format("The field {0} is constant. Its value is compiled directly into the users of this constant which makes is impossible to search for users of it.",
field.Print(FieldPrintOptions.All)));
}
myDeclaringTypeNamesToSearch.Add(field.DeclaringType.Name);
Aggregator.AddVisitScope(field.DeclaringType.Module.Assembly.Name.Name);
}
}
public WhoUsesType(UsageQueryAggregator aggregator, List <TypeDefinition> funcArgTypes) :
base(aggregator)
{
using (Tracer t = new Tracer(Level.L5, myType, "WhoUsesType"))
{
if (funcArgTypes == null)
{
throw new ArgumentNullException("funcArgTypes");
}
mySearchArgTypes = funcArgTypes;
foreach (TypeDefinition funcArgType in funcArgTypes)
{
t.Info("Adding search type {0}", new LazyFormat(() => funcArgType.Print()));
myArgSearchTypeNames.Add(funcArgType.Name);
Aggregator.AddVisitScope(funcArgType.Module.Assembly.Name.Name);
new WhoAccessesField(aggregator, notConst.GetMatchingFields(funcArgType));
}
}
}
public WhoImplementsInterface(UsageQueryAggregator aggreator, List <TypeDefinition> interfaces) : base(aggreator)
{
if (interfaces == null || interfaces.Count == 0)
{
throw new ArgumentException("The interfaces collection was null.");
}
foreach (var type in interfaces)
{
if (!type.IsInterface)
{
throw new ArgumentException(
String.Format("The type {0} is not an interface", type.Print()));
}
Aggregator.AddVisitScope(type.Module.Assembly.Name.Name);
if (!myInterfaceNames.ContainsKey(type.Name))
{
myInterfaceNames.Add(type.Name, type);
}
}
}
public WhoDerivesFromType(UsageQueryAggregator aggregator, TypeDefinition typeDef)
: this(aggregator, new List <TypeDefinition> {
ThrowIfNull <TypeDefinition>("typeDef", typeDef)
})
{
}
public WhoHasFieldOfType(UsageQueryAggregator aggregator, TypeDefinition fieldType)
: this(aggregator, new List <TypeDefinition> {
ThrowIfNull <TypeDefinition>("fieldType", fieldType)
})
{
}
public WhoUsesStringConstant(UsageQueryAggregator aggregator, string searchString)
: this(aggregator, searchString, false, StringComparison.OrdinalIgnoreCase)
{
}
public WhoAccessesField(UsageQueryAggregator aggreagator, FieldDefinition field) :
this(aggreagator, new List <FieldDefinition> {
ThrowIfNull <FieldDefinition>("field", field)
})
{
}
public WhoImplementsInterface(UsageQueryAggregator aggregator, TypeDefinition itf)
: this(aggregator, new List <TypeDefinition>() { ThrowIfNull <TypeDefinition>("itf", itf) })
{
}
public WhoUsesStringConstant(UsageQueryAggregator aggregator, string searchString, bool bExactMatch)
: this(aggregator, searchString, bExactMatch, StringComparison.OrdinalIgnoreCase)
{
}
public WhoUsesType(UsageQueryAggregator aggregator, TypeDefinition funcArgType) :
this(aggregator, new List <TypeDefinition> {
ThrowIfNull <TypeDefinition>("funcArgType", funcArgType)
})
{
}
public WhoUsesEvents(UsageQueryAggregator aggregator, EventDefinition ev) :
this(aggregator, new List <EventDefinition> {
ThrowIfNull <EventDefinition>("ev", ev)
})
{
}
