/// <summary>
/// Set the generic context
/// </summary>
/// <param name="codeEntityReference">The member ID for which to set the context</param>
public static void SetGenericContext(string codeEntityReference)
{
// Reset the context
genericTypeContext = null;
// Get the new context
Reference context = CreateReference(codeEntityReference);
if (context == null)
{
return;
}
// If it is a type context, set it to be the type context
SimpleTypeReference typeContext = context as SimpleTypeReference;
if (typeContext != null)
{
genericTypeContext = typeContext;
return;
}
// If it is a member context, set it to be the member context and use it to obtain a type context, too
SimpleMemberReference memberContext = context as SimpleMemberReference;
if (memberContext != null)
{
string typeId, memberName, arguments;
DecomposeMemberIdentifier(memberContext.Id, out typeId, out memberName, out arguments);
genericTypeContext = CreateSimpleTypeReference(typeId);
return;
}
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="templateMember"></param>
/// <param name="specializedType"></param>
public SpecializedMemberReference(SimpleMemberReference templateMember,
SpecializedTypeReference specializedType)
{
if(templateMember == null)
throw new ArgumentNullException("templateMember");
if(specializedType == null)
throw new ArgumentNullException("specializedType");
this.TemplateMember = templateMember;
this.SpecializedType = specializedType;
}
private void WriteSimpleMember(SimpleMemberReference member, DisplayOptions options, XmlWriter writer, Dictionary <IndexedTemplateTypeReference, TypeReference> dictionary)
{
MemberTarget target = targets[member.Id] as MemberTarget;
if (target != null)
{
WriteMemberTarget(target, options, writer, dictionary);
}
else
{
TextReferenceUtilities.WriteSimpleMemberReference(member, options, writer, this);
}
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="templateMember"></param>
/// <param name="specializedType"></param>
public SpecializedMemberReference(SimpleMemberReference templateMember,
SpecializedTypeReference specializedType)
{
if (templateMember == null)
{
throw new ArgumentNullException("templateMember");
}
if (specializedType == null)
{
throw new ArgumentNullException("specializedType");
}
this.TemplateMember = templateMember;
this.SpecializedType = specializedType;
}
/// <summary>
/// Create a member reference
/// </summary>
/// <param name="node">The node from which to get the target information</param>
/// <returns>The member reference</returns>
public static MemberReference CreateMemberReference(XPathNavigator node)
{
string api = node.GetAttribute("api", String.Empty);
SimpleMemberReference member = new SimpleMemberReference(api);
bool isSpecialized = (bool)node.Evaluate("boolean(./type//specialization)");
if (isSpecialized)
{
XPathNavigator typeNode = node.SelectSingleNode("type");
SpecializedTypeReference type = CreateSpecializedTypeReference(typeNode);
return(new SpecializedMemberReference(member, type));
}
return(member);
}
internal static void WriteSimpleMemberReference(SimpleMemberReference member, DisplayOptions options, XmlWriter writer, LinkTextResolver resolver)
{
string cer = member.Id;
string typeCer, memberName, arguments;
DecomposeMemberIdentifier(cer, out typeCer, out memberName, out arguments);
if ((options & DisplayOptions.ShowContainer) > 0)
{
SimpleTypeReference type = CreateSimpleTypeReference(typeCer);
WriteSimpleTypeReference(type, options & ~DisplayOptions.ShowContainer, writer);
writer.WriteString(".");
}
// Change this so that we deal with EII names correctly, too
writer.WriteString(memberName);
if ((options & DisplayOptions.ShowParameters) > 0)
{
if (String.IsNullOrEmpty(arguments))
{
Parameter[] parameters = new Parameter[0];
resolver.WriteMethodParameters(parameters, writer);
}
else
{
IList <string> parameterTypeCers = SeparateTypes(arguments);
Parameter[] parameters = new Parameter[parameterTypeCers.Count];
for (int i = 0; i < parameterTypeCers.Count; i++)
{
TypeReference parameterType = CreateTypeReference(parameterTypeCers[i]);
if (parameterType == null)
{
parameterType = new NamedTemplateTypeReference("UAT");
}
parameters[i] = new Parameter(String.Empty, parameterType);
}
resolver.WriteMethodParameters(parameters, writer);
}
}
}
/// <summary>
/// Write out a member reference
/// </summary>
/// <param name="member">The member reference information</param>
/// <param name="options">The link display options</param>
/// <param name="writer">The write to which the information is written</param>
public void WriteMember(MemberReference member, DisplayOptions options, XmlWriter writer)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
SimpleMemberReference simple = member as SimpleMemberReference;
if (simple != null)
{
WriteSimpleMember(simple, options, writer);
return;
}
SpecializedMemberReference special = member as SpecializedMemberReference;
if (special != null)
{
WriteSpecializedMember(special, options, writer);
return;
}
SpecializedMemberWithParametersReference ugly = member as SpecializedMemberWithParametersReference;
if (ugly != null)
{
WriteSpecializedMemberWithParameters(ugly, options, writer);
return;
}
throw new InvalidOperationException("Unknown member reference type");
}
private void WriteSimpleMember(SimpleMemberReference member, DisplayOptions options, XmlWriter writer)
{
WriteSimpleMember(member, options, writer, null);
}
/// <summary>
/// Create a member reference
/// </summary>
/// <param name="node">The node from which to get the target information</param>
/// <returns>The member reference</returns>
public static MemberReference CreateMemberReference(XPathNavigator node)
{
string api = node.GetAttribute("api", String.Empty);
SimpleMemberReference member = new SimpleMemberReference(api);
bool isSpecialized = (bool)node.Evaluate("boolean(./type//specialization)");
if(isSpecialized)
{
XPathNavigator typeNode = node.SelectSingleNode("type");
SpecializedTypeReference type = CreateSpecializedTypeReference(typeNode);
return new SpecializedMemberReference(member, type);
}
return member;
}
private void WriteSimpleMember(SimpleMemberReference member, DisplayOptions options, XmlWriter writer, Dictionary<IndexedTemplateTypeReference, TypeReference> dictionary)
{
MemberTarget target = targets[member.Id] as MemberTarget;
if(target != null)
WriteMemberTarget(target, options, writer, dictionary);
else
TextReferenceUtilities.WriteSimpleMemberReference(member, options, writer, this);
}
private void WriteSimpleMember(SimpleMemberReference member, DisplayOptions options, XmlWriter writer)
{
WriteSimpleMember(member, options, writer, null);
}
internal static void WriteSimpleMemberReference(SimpleMemberReference member, DisplayOptions options, XmlWriter writer, LinkTextResolver resolver)
{
string cer = member.Id;
string typeCer, memberName, arguments;
DecomposeMemberIdentifier(cer, out typeCer, out memberName, out arguments);
if((options & DisplayOptions.ShowContainer) > 0)
{
SimpleTypeReference type = CreateSimpleTypeReference(typeCer);
WriteSimpleTypeReference(type, options & ~DisplayOptions.ShowContainer, writer);
writer.WriteString(".");
}
// Change this so that we deal with EII names correctly, too
writer.WriteString(memberName);
if((options & DisplayOptions.ShowParameters) > 0)
{
if(String.IsNullOrEmpty(arguments))
{
Parameter[] parameters = new Parameter[0];
resolver.WriteMethodParameters(parameters, writer);
}
else
{
IList<string> parameterTypeCers = SeparateTypes(arguments);
Parameter[] parameters = new Parameter[parameterTypeCers.Count];
for(int i = 0; i < parameterTypeCers.Count; i++)
{
TypeReference parameterType = CreateTypeReference(parameterTypeCers[i]);
if(parameterType == null)
parameterType = new NamedTemplateTypeReference("UAT");
parameters[i] = new Parameter(String.Empty, parameterType);
}
resolver.WriteMethodParameters(parameters, writer);
}
}
}
/// <summary>
/// Create a member reference
/// </summary>
/// <param name="api">The member ID for which to create a reference</param>
/// <returns>The member reference</returns>
public static MemberReference CreateMemberReference(string api)
{
if(ValidSimpleMember.IsMatch(api))
{
// This is just a normal member of a simple type
return new SimpleMemberReference(api);
}
if(ValidSpecializedMember.IsMatch(api))
{
// This is a member of a specialized type; we need to extract:
// (1) the underlying specialized type, (2) the member name, (3) the arguments
// Separate the member prefix
int colonPosition = api.IndexOf(':');
string prefix = api.Substring(0, colonPosition);
string text = api.Substring(colonPosition + 1);
// Get the arguments
string arguments = String.Empty;
int startParenthesisPosition = text.IndexOf('(');
if(startParenthesisPosition > 0)
{
int endParenthesisPosition = text.LastIndexOf(')');
arguments = text.Substring(startParenthesisPosition + 1, endParenthesisPosition - startParenthesisPosition - 1);
text = text.Substring(0, startParenthesisPosition);
}
// Separate the type and member name
int lastDotPosition;
int firstHashPosition = text.IndexOf('#');
if(firstHashPosition > 0)
{
// If this is an EII, the boundary is at the last dot before the hash
lastDotPosition = text.LastIndexOf('.', firstHashPosition);
}
else
{
// Otherwise, the boundary is at the last dot
lastDotPosition = text.LastIndexOf('.');
}
string name = text.Substring(lastDotPosition + 1);
text = text.Substring(0, lastDotPosition);
// Text now contains a specialized generic type; use it to create a reference
SpecializedTypeReference type = CreateSpecializedTypeReference("T:" + text);
// If there are no arguments, we simply create a reference to a member whose identifier we
// construct in the specialized type.
if(String.IsNullOrEmpty(arguments))
{
string typeId = type.Specializations[type.Specializations.Count - 1].TemplateType.Id;
string memberId = String.Format(CultureInfo.InvariantCulture, "{0}:{1}.{2}", prefix,
typeId.Substring(2), name);
SimpleMemberReference member = new SimpleMemberReference(memberId);
return new SpecializedMemberReference(member, type);
}
// If there are arguments, life is not so simple. We can't be sure we can identify the
// corresponding member of the template type because any particular type that appears in
// the argument might have come from the template or it might have come from the specialization.
// We need to create a special kind of reference to handle this situation.
IList<string> parameterTypeCers = SeparateTypes(arguments);
TypeReference[] parameterTypes = new TypeReference[parameterTypeCers.Count];
for(int i = 0; i < parameterTypeCers.Count; i++)
parameterTypes[i] = CreateTypeReference(parameterTypeCers[i]);
return new SpecializedMemberWithParametersReference(prefix, type, name, parameterTypes);
}
return null;
}
/// <summary>
/// Create a member reference
/// </summary>
/// <param name="api">The member ID for which to create a reference</param>
/// <returns>The member reference</returns>
public static MemberReference CreateMemberReference(string api)
{
if (ValidSimpleMember.IsMatch(api))
{
// This is just a normal member of a simple type
return(new SimpleMemberReference(api));
}
if (ValidSpecializedMember.IsMatch(api))
{
// This is a member of a specialized type; we need to extract:
// (1) the underlying specialized type, (2) the member name, (3) the arguments
// Separate the member prefix
int colonPosition = api.IndexOf(':');
string prefix = api.Substring(0, colonPosition);
string text = api.Substring(colonPosition + 1);
// Get the arguments
string arguments = String.Empty;
int startParenthesisPosition = text.IndexOf('(');
if (startParenthesisPosition > 0)
{
int endParenthesisPosition = text.LastIndexOf(')');
arguments = text.Substring(startParenthesisPosition + 1, endParenthesisPosition - startParenthesisPosition - 1);
text = text.Substring(0, startParenthesisPosition);
}
// Separate the type and member name
int lastDotPosition;
int firstHashPosition = text.IndexOf('#');
if (firstHashPosition > 0)
{
// If this is an EII, the boundary is at the last dot before the hash
lastDotPosition = text.LastIndexOf('.', firstHashPosition);
}
else
{
// Otherwise, the boundary is at the last dot
lastDotPosition = text.LastIndexOf('.');
}
string name = text.Substring(lastDotPosition + 1);
text = text.Substring(0, lastDotPosition);
// Text now contains a specialized generic type; use it to create a reference
SpecializedTypeReference type = CreateSpecializedTypeReference("T:" + text);
// If there are no arguments, we simply create a reference to a member whose identifier we
// construct in the specialized type.
if (String.IsNullOrEmpty(arguments))
{
string typeId = type.Specializations[type.Specializations.Count - 1].TemplateType.Id;
string memberId = String.Format(CultureInfo.InvariantCulture, "{0}:{1}.{2}", prefix,
typeId.Substring(2), name);
SimpleMemberReference member = new SimpleMemberReference(memberId);
return(new SpecializedMemberReference(member, type));
}
// If there are arguments, life is not so simple. We can't be sure we can identify the
// corresponding member of the template type because any particular type that appears in
// the argument might have come from the template or it might have come from the specialization.
// We need to create a special kind of reference to handle this situation.
IList <string> parameterTypeCers = SeparateTypes(arguments);
TypeReference[] parameterTypes = new TypeReference[parameterTypeCers.Count];
for (int i = 0; i < parameterTypeCers.Count; i++)
{
parameterTypes[i] = CreateTypeReference(parameterTypeCers[i]);
}
return(new SpecializedMemberWithParametersReference(prefix, type, name, parameterTypes));
}
return(null);
}
