public virtual bool ShouldProcessMember(CacheMember holder)
{
// check MemberTypes filter
if (m_typeFilter != MemberTypes.All && m_typeFilter != holder.MemInfo?.MemberType)
{
return(false);
}
// hide failed reflection
if (!string.IsNullOrEmpty(holder.ReflectionException) && m_hideFailedReflection)
{
return(false);
}
// check scope filter
if (m_scopeFilter == MemberScopes.Instance && holder.IsStatic)
{
return(false);
}
else if (m_scopeFilter == MemberScopes.Static && !holder.IsStatic)
{
return(false);
}
// see if we should do name search
if (m_search == "" || holder.MemInfo == null)
{
return(true);
}
// ok do name search
return((holder.MemInfo.DeclaringType.Name + "." + holder.MemInfo.Name)
.ToLower()
.Contains(m_search.ToLower()));
}
// Setting target
private void SetTarget(object target)
{
string prefix;
if (StaticOnly)
{
Target = null;
TargetType = target as Type;
prefix = "[S]";
}
else
{
TargetType = target.GetActualType();
prefix = "[R]";
}
// Setup main labels and tab text
currentBaseTabText = $"{prefix} {SignatureHighlighter.Parse(TargetType, false)}";
Tab.TabText.text = currentBaseTabText;
NameText.text = SignatureHighlighter.Parse(TargetType, true);
string asmText;
if (TargetType.Assembly is AssemblyBuilder || string.IsNullOrEmpty(TargetType.Assembly.Location))
{
asmText = $"{TargetType.Assembly.GetName().Name} <color=grey><i>(in memory)</i></color>";
}
else
{
asmText = Path.GetFileName(TargetType.Assembly.Location);
}
AssemblyText.text = $"<color=grey>Assembly:</color> {asmText}";
// unity helpers
SetUnityTargets();
// Get cache members
this.members = CacheMember.GetCacheMembers(Target, TargetType, this);
// reset filters
this.filterInputField.Text = "";
SetFilter("", StaticOnly ? BindingFlags.Static : BindingFlags.Instance);
scopeFilterButtons[BindingFlags.Default].Component.gameObject.SetActive(!StaticOnly);
scopeFilterButtons[BindingFlags.Instance].Component.gameObject.SetActive(!StaticOnly);
foreach (var toggle in memberTypeToggles)
{
toggle.isOn = true;
}
refreshWanted = true;
}
public override void OnException(CacheMember member)
{
base.OnException(member);
if (m_subContentConstructed && m_hiddenObj.gameObject.activeSelf)
{
m_hiddenObj.gameObject.SetActive(false);
}
m_labelLayout.minWidth = 200;
m_labelLayout.flexibleWidth = 5000;
}
public void OnBorrowedFromPool(CacheMember owner)
{
this.Owner = owner;
arguments = owner.Arguments;
argumentInput = new string[arguments.Length];
genericArguments = owner.GenericArguments;
genericInput = new string[genericArguments.Length];
SetArgRows();
this.UIRoot.SetActive(true);
}
public void OnBorrowedFromPool(CacheMember owner)
{
this.Owner = owner;
parameters = owner.Arguments;
paramHandlers = new ParameterHandler[parameters.Length];
genericArguments = owner.GenericArguments;
genericHandlers = new GenericArgumentHandler[genericArguments.Length];
SetArgRows();
this.UIRoot.SetActive(true);
}
public override void OnException(CacheMember member)
{
base.OnException(member);
if (m_valueInput.gameObject.activeSelf)
{
m_valueInput.gameObject.SetActive(false);
}
if (Owner.CanWrite)
{
if (m_applyBtn.gameObject.activeSelf)
{
m_applyBtn.gameObject.SetActive(false);
}
}
}
public void RefreshDisplay()
{
var members = m_membersFiltered;
m_pageHandler.ListCount = members.Count;
// disable current members
for (int i = 0; i < m_displayedMembers.Length; i++)
{
var mem = m_displayedMembers[i];
if (mem != null)
{
mem.Disable();
}
else
{
break;
}
}
if (members.Count < 1)
{
return;
}
foreach (var itemIndex in m_pageHandler)
{
if (itemIndex >= members.Count)
{
break;
}
CacheMember member = members[itemIndex];
m_displayedMembers[itemIndex - m_pageHandler.StartIndex] = member;
member.Enable();
}
m_widthUpdateWanted = true;
}
public override void OnException(CacheMember member)
{
base.OnException(member);
}
public void CacheMembers(Type type)
{
var list = new List <CacheMember>();
var cachedSigs = new HashSet <string>();
var types = ReflectionUtility.GetAllBaseTypes(type);
var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static;
if (this is InstanceInspector)
{
flags |= BindingFlags.Instance;
}
foreach (var declaringType in types)
{
var target = Target;
target = target.Cast(declaringType);
IEnumerable <MemberInfo> infos = declaringType.GetMethods(flags);
infos = infos.Concat(declaringType.GetProperties(flags));
infos = infos.Concat(declaringType.GetFields(flags));
foreach (var member in infos)
{
try
{
var sig = GetSig(member);
//ExplorerCore.Log($"Trying to cache member {sig}...");
//ExplorerCore.Log(member.DeclaringType.FullName + "." + member.Name);
var mi = member as MethodInfo;
var pi = member as PropertyInfo;
var fi = member as FieldInfo;
if (IsBlacklisted(sig) || (mi != null && IsBlacklisted(mi)))
{
continue;
}
var args = mi?.GetParameters() ?? pi?.GetIndexParameters();
if (args != null)
{
if (!CacheMember.CanProcessArgs(args))
{
continue;
}
sig += AppendArgsToSig(args);
}
if (cachedSigs.Contains(sig))
{
continue;
}
cachedSigs.Add(sig);
if (mi != null)
{
list.Add(new CacheMethod(mi, target, m_scrollContent));
}
else if (pi != null)
{
list.Add(new CacheProperty(pi, target, m_scrollContent));
}
else
{
list.Add(new CacheField(fi, target, m_scrollContent));
}
list.Last().ParentInspector = this;
}
catch (Exception e)
{
ExplorerCore.LogWarning($"Exception caching member {member.DeclaringType.FullName}.{member.Name}!");
ExplorerCore.Log(e.ToString());
}
}
}
var typeList = types.ToList();
var sorted = new List <CacheMember>();
sorted.AddRange(list.Where(it => it is CacheMethod)
.OrderBy(it => typeList.IndexOf(it.DeclaringType))
.ThenBy(it => it.NameForFiltering));
sorted.AddRange(list.Where(it => it is CacheProperty)
.OrderBy(it => typeList.IndexOf(it.DeclaringType))
.ThenBy(it => it.NameForFiltering));
sorted.AddRange(list.Where(it => it is CacheField)
.OrderBy(it => typeList.IndexOf(it.DeclaringType))
.ThenBy(it => it.NameForFiltering));
m_allMembers = sorted.ToArray();
}
public override bool ShouldProcessMember(CacheMember holder)
{
return(base.ShouldProcessMember(holder));
}
