public override void Visit(ISpecializedEventDefinition specializedEventDefinition)
{
if (Process(specializedEventDefinition))
{
visitor.Visit(specializedEventDefinition);
}
base.Visit(specializedEventDefinition);
}
public static T UnWrapMember <T>(this T member)
where T : ITypeMemberReference
{
IGenericMethodInstanceReference genericMethod = member as IGenericMethodInstanceReference;
if (genericMethod != null)
{
return((T)genericMethod.GenericMethod.UnWrapMember());
}
ISpecializedNestedTypeReference type = member as ISpecializedNestedTypeReference;
if (type != null)
{
return((T)type.UnspecializedVersion.UnWrapMember());
}
ISpecializedMethodReference method = member as ISpecializedMethodReference;
if (method != null)
{
return((T)method.UnspecializedVersion.UnWrapMember());
}
ISpecializedFieldReference field = member as ISpecializedFieldReference;
if (field != null)
{
return((T)field.UnspecializedVersion.UnWrapMember());
}
ISpecializedPropertyDefinition property = member as ISpecializedPropertyDefinition;
if (property != null)
{
return((T)property.UnspecializedVersion.UnWrapMember());
}
ISpecializedEventDefinition evnt = member as ISpecializedEventDefinition;
if (evnt != null)
{
return((T)evnt.UnspecializedVersion.UnWrapMember());
}
return(member);
}
public virtual void onMetadataElement(ISpecializedEventDefinition specializedEventDefinition) { }
/// <summary>
/// Performs some computation with the given specialized event definition.
/// </summary>
public void Visit(ISpecializedEventDefinition specializedEventDefinition)
{
this.Visit((IEventDefinition)specializedEventDefinition);
}
public void Visit(ISpecializedEventDefinition specializedEventDefinition)
{
//we are traversing a generic type instance.
this.traverser.Traverse((IEventDefinition)specializedEventDefinition);
}
/// <summary>
/// Performs some computation with the given specialized event definition.
/// </summary>
public virtual void Visit(ISpecializedEventDefinition specializedEventDefinition)
{
}
public void Visit(ISpecializedEventDefinition specializedEventDefinition)
{
throw new NotImplementedException();
}
public virtual void onMetadataElement(ISpecializedEventDefinition specializedEventDefinition)
{
}
/// <summary>
/// Performs some computation with the given specialized event definition.
/// </summary>
public virtual void Visit(ISpecializedEventDefinition specializedEventDefinition)
{
}
public static ITypeMemberReference CanonicalizeMemberReference(ITypeMemberReference member)
{
if (null == member)
{
return(null);
}
if (member == null || member == Dummy.Method)
{
throw new Exception("Can't resolve member");
}
// function pointers don't have declaring types and they don't
// really fit our model, so we ignore them.
if (null == member.ContainingType)
{
return(null);
}
//
// first canonicalize the method...
//
IGenericMethodInstanceReference genMeth = member as IGenericMethodInstanceReference;
if ((genMeth != null))
{
member = genMeth.GenericMethod;
}
ISpecializedMethodReference specializedMethodRef = member as ISpecializedMethodReference;
ISpecializedFieldReference specializedFieldRef = member as ISpecializedFieldReference;
ISpecializedPropertyDefinition specializedPropertyDef = member as ISpecializedPropertyDefinition;
ISpecializedEventDefinition specializedEventDef = member as ISpecializedEventDefinition;
ISpecializedMethodDefinition specializedMethodDef = member as ISpecializedMethodDefinition;
ISpecializedFieldDefinition specializedFieldDef = member as ISpecializedFieldDefinition;
if (specializedMethodRef != null)
{
member = specializedMethodRef.UnspecializedVersion;
}
else if (specializedFieldRef != null)
{
member = specializedFieldRef.UnspecializedVersion;
}
else if (specializedPropertyDef != null)
{
member = specializedPropertyDef.UnspecializedVersion;
}
else if (specializedEventDef != null)
{
member = specializedEventDef.UnspecializedVersion;
}
else if (specializedMethodDef != null)
{
member = specializedMethodDef.UnspecializedVersion;
}
else if (specializedFieldDef != null)
{
member = specializedFieldDef.UnspecializedVersion;
}
if (member == null)
{
throw new Exception("Can't canonicalize some member.");
}
return(member);
}
public override void Visit(ISpecializedEventDefinition specializedEventDefinition)
{
allElements.Add(new InvokInfo(Traverser, "ISpecializedEventDefinition", specializedEventDefinition));
}
public override void Visit(ISpecializedEventDefinition specializedEventDefinition)
{
if(Process(specializedEventDefinition)){visitor.Visit(specializedEventDefinition);}
base.Visit(specializedEventDefinition);
}
