/// <summary>
/// A list of referencing members and members referenced by which members
/// </summary>
/// <param name="includeSelfRefs"></param>
/// <returns></returns>
public string Info(bool includeSelfRefs)
{
/* Name [ArchMember]
* Referenced by types:
* ReferentClass_1 ...
* Referenced by members:
* ReferentMember_1 --> Member_1 ...
*/
string headIndent = "\n";
string itemIndent = "\n\t";
string info = FullName;
ArchList <ArchitectMember> refMembs = ReferencedMembers(includeSelfRefs);
if (refMembs.Count > 0)
{
info += $"{headIndent}References members:";
}
refMembs.ForEach(M => info += $"{itemIndent}{M.SimpleName}");
refMembs = ReferentMembers(includeSelfRefs);
if (refMembs.Count > 0)
{
info += $"{headIndent}Referenced by members:";
}
refMembs.ForEach(M => info += $"{itemIndent}{M.SimpleName}");
return(info);
}
/// <summary>
/// Find all ArchitectTypes that reference this Type
/// </summary>
/// <param name="includingSelf"></param>
/// <returns></returns>
public ArchList <ArchitectType> ReferentTypes(bool includingSelf)
{
ArchList <ArchitectType> alist = new ArchList <ArchitectType>();
Members.ForEach(M => alist.AddRange(M.ReferentTypes(includingSelf)));
return(alist.Clean());
}
/// <summary>
/// ArchitectMembers of this type that are referenced by other members
/// </summary>
/// <param name="includingSelf"></param>
/// <returns></returns>
public ArchList <ArchitectMember> ReferentMembers(bool includingSelf)
{
// found by reverse analyzing each type ReferencedMembers
ArchList <ArchitectMember> alist = new ArchList <ArchitectMember>();
Members.ForEach(M => alist.AddRange(M.ReferentMembers(includingSelf)));
return(alist.Clean());
}
/// <summary>
/// Remove compiled-created types and re-order
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
internal static ArchList <ArchitectType> Clean(this ArchList <ArchitectType> list)
{
ArchList <ArchitectType> alist = new ArchList <ArchitectType>();
list.FindAll(a => !a.FullName.Contains("<>c") && !a.FullName.Contains("b__"))
.OrderBy(a => a.FullName).ToList().ForEach(a => alist.Add(a));
return(alist);
}
/// <summary>
/// Retrieve only call, calli, and callvirt instructions from the stream
/// </summary>
/// <returns></returns>
public ArchList <Instruction> GetCallInstructions()
{
ArchList <Instruction> list = new ArchList <Instruction>();
list.AddRange(InstructionStream.FindAll(I => I.Code.Name.Contains("call")));
list.AddRange(StrayInstructions.FindAll(I => I.Code.Name.Contains("call")));
return(list);
}
/// <summary>
/// Post-initialization Architech Types Referenced
/// </summary>
/// <param name="includingSelf"></param>
/// <returns></returns>
public ArchList <ArchitectType> ReferencedTypes(bool includingSelf)
{
ArchList <ArchitectType> alist = new ArchList <ArchitectType>();
if (referencedTypes == null)
{
DirectRefTypes.ForEach(a => alist.Add(DeclaringType.Architecture.Types.Find(A => A.Class == a)));
referencedTypes = alist;
}
else
{
referencedTypes.ForEach(M => alist.Add(M));
}
if (!includingSelf)
{
alist.RemoveAll(A => A.FullName.Contains(DeclaringType.Name));
}
return(alist.Clean());
}
/// <summary>
/// Post-initialization Architech Types Referenced
/// </summary>
/// <param name="includingSelf"></param>
/// <returns></returns>
public ArchList <ArchitectType> ReferentTypes(bool includingSelf)
{
ArchList <ArchitectType> alist = new ArchList <ArchitectType>();
if (referentTypes == null)
{
DeclaringType.Architecture.Types.ForEach(A =>
{ A.Members.FindAll(M => M.ReferencedTypes(includingSelf).Contains(DeclaringType)).ForEach(M => alist.Add(M.DeclaringType)); });
referentTypes = alist;
}
else
{
referentTypes.ForEach(M => alist.Add(M));
}
if (!includingSelf)
{
alist.RemoveAll(A => A.FullName.Contains(DeclaringType.Name));
}
return(alist.Clean());
}
/// <summary>
/// Post-initialization Architech Members Referenced
/// </summary>
/// <param name="includingSelf"></param>
/// <returns></returns>
public ArchList <ArchitectMember> ReferentMembers(bool includingSelf)
{
ArchList <ArchitectMember> alist = new ArchList <ArchitectMember>();
if (referentMembers == null)
{
DeclaringType.Architecture.Types.ForEach(A =>
{ alist.AddRange(A.Members.FindAll(M => M.ReferencedMembers(includingSelf).Contains(this))); });
referentMembers = alist;
}
else
{
referentMembers.ForEach(M => alist.Add(M));
}
if (!includingSelf)
{
alist.RemoveAll(M => M.DeclaringType == DeclaringType);
}
return(alist.Clean());
}
/// <summary>
/// Add only non-duplicate items
/// </summary>
/// <param name="tLst"></param>
public void AddRange(ArchList <T> tLst) => tLst.ForEach(t => { if (!Contains(t))
{
base.Add(t);
}
});
