public IAnalysisResult GetMember(GetMemberInput input)
{
if (MemberDictionary.Count == 0 && MimicTableName != null)
{
return(null);
}
else
{
VariableDef varDef = null;
MemberDictionary.TryGetValue(input.Name, out varDef);
return(varDef);
}
}
public IAnalysisResult GetMember(string name, Genero4glAst ast, out IGeneroProject definingProject, out IProjectEntry projEntry, bool function)
{
definingProject = null;
projEntry = null;
if (MemberDictionary.Count == 0 && MimicTableName != null)
{
return(null);
}
else
{
VariableDef varDef = null;
MemberDictionary.TryGetValue(name, out varDef);
return(varDef);
}
}
public bool TryGetCache <TEntity>(Snowflake parentId, out ISynchronizedDictionary <Snowflake, TEntity> cache, bool lookupOnly = false)
where TEntity : CachedSnowflakeEntity
{
lock (this)
{
if (!_nestedCaches.TryGetValue(typeof(TEntity), out var nestedCache))
{
cache = default;
return(false);
}
if (nestedCache.TryGetValue(parentId, out var boxedCache))
{
cache = (ISynchronizedDictionary <Snowflake, TEntity>)boxedCache;
return(true);
}
if (!lookupOnly && _supportedNestedTypes.Contains(typeof(TEntity)))
{
if (typeof(TEntity) == typeof(CachedUserMessage))
{
var messageCache = new MessageDictionary(MessagesPerChannel).Synchronized();
cache = (ISynchronizedDictionary <Snowflake, TEntity>)messageCache;
}
else if (typeof(TEntity) == typeof(CachedMember))
{
var memberCache = new MemberDictionary(this).Synchronized();
cache = (ISynchronizedDictionary <Snowflake, TEntity>)memberCache;
}
else
{
cache = new SynchronizedDictionary <Snowflake, TEntity>();
}
nestedCache.Add(parentId, cache);
return(true);
}
cache = default;
return(false);
}
}
/// <summary>
/// Determines whether an extension method is hidden by a member that's already defined on the type being extended.
/// The extension method is hidden if it has the same name, template params, and parameters as a defined method.
/// </summary>
/// <param name="extensionMethod">The extension method to compare.</param>
/// <param name="members">A dictionary of the members defined on the type being extended.</param>
/// <returns></returns>
private bool IsExtensionMethodHidden(Method extensionMethod, MemberDictionary members)
{
if (!members.MemberNames.Contains(extensionMethod.Name.Name))
{
return(false);
}
// get a list of members with the same name as the extension method
List <Member> membersList = members[extensionMethod.Name.Name];
foreach (Member member in membersList)
{
// the hiding member must be a method
if (member.NodeType != NodeType.Method)
{
continue;
}
Method method = (Method)member;
// do the generic template parameters of both methods match?
if (!method.TemplateParametersMatch(extensionMethod.TemplateParameters))
{
continue;
}
// do both methods have the same number of parameters?
// (not counting the extension method's first param, which identifies the extended type)
if (method.Parameters.Count != (extensionMethod.Parameters.Count - 1))
{
continue;
}
// do the parameter types of both methods match?
if (DoParameterTypesMatch(extensionMethod.Parameters, method.Parameters))
{
return(true);
}
}
return(false);
}
public SymbolDefMember FindMember(string name)
{
if (MemberDictionary.ContainsKey(name))
{
SymbolDefMember member = MemberDictionary.Get(name);
return(member);
}
if (IsStaticClass)
{
return(null);
}
ZMemberInfo zmember = BaseZType.SearchZMember(name);
if (zmember == null)
{
return(null);
}
SymbolDefMember symbol = SymbolDefMember.Create(name, zmember);
return(symbol);
}
/// <summary>
/// 创建分组字典缓存
/// </summary>
/// <typeparam name="keyType">分组字典关键字类型</typeparam>
/// <typeparam name="targetType">目标表格类型</typeparam>
/// <typeparam name="targetModelType">目标模型类型</typeparam>
/// <typeparam name="targetMemberCacheType">目标缓存绑定类型</typeparam>
/// <typeparam name="valueKeyType">目标数据关键字类型</typeparam>
/// <param name="targetCache">目标缓存</param>
/// <param name="getKey">分组字典关键字获取器</param>
/// <param name="member">缓存字段表达式</param>
/// <param name="getValueKey">获取数据关键字委托</param>
/// <param name="isReset">是否绑定事件并重置数据</param>
/// <param name="isSave">是否保存缓存对象防止被垃圾回收</param>
/// <returns></returns>
public MemberDictionary <valueType, modelType, keyType, valueKeyType, targetMemberCacheType> CreateMemberDictionary <keyType, targetType, targetModelType, targetMemberCacheType, valueKeyType>
(Key <targetType, targetModelType, targetMemberCacheType, keyType> targetCache, Func <modelType, keyType> getKey
, Expression <Func <targetMemberCacheType, Dictionary <RandomKey <valueKeyType>, valueType> > > member
, Func <modelType, valueKeyType> getValueKey, bool isReset = true, bool isSave = true)
where keyType : IEquatable <keyType>
where targetType : class, targetModelType
where targetModelType : class
where targetMemberCacheType : class
where valueKeyType : IEquatable <valueKeyType>
{
MemberDictionary <valueType, modelType, keyType, valueKeyType, targetMemberCacheType> cache = new MemberDictionary <valueType, modelType, keyType, valueKeyType, targetMemberCacheType>(this, getKey, targetCache.GetMemberCacheByKey, member, targetCache.GetAllMemberCache, getValueKey, isReset);
if (isSave)
{
memberCaches.Add(cache);
}
return(cache);
}
private void AddExtensionMethods(XmlWriter writer, Object info)
{
MemberDictionary members = info as MemberDictionary;
if (members == null)
{
return;
}
TypeNode type = members.Type;
InterfaceList contracts = type.Interfaces;
foreach (Interface contract in contracts)
{
List <Method> extensionMethods = null;
if (index.TryGetValue(contract, out extensionMethods))
{
foreach (Method extensionMethod in extensionMethods)
{
if (!IsExtensionMethodHidden(extensionMethod, members))
{
AddExtensionMethod(writer, type, extensionMethod, null);
}
}
}
if (contract.IsGeneric && (contract.TemplateArguments != null) && (contract.TemplateArguments.Count > 0))
{
Interface templateContract = (Interface)ReflectionUtilities.GetTemplateType(contract);
TypeNode specialization = contract.TemplateArguments[0];
if (index.TryGetValue(templateContract, out extensionMethods))
{
foreach (Method extensionMethod in extensionMethods)
{
if (IsValidTemplateArgument(specialization, extensionMethod.TemplateParameters[0]))
{
if (!IsExtensionMethodHidden(extensionMethod, members))
{
AddExtensionMethod(writer, type, extensionMethod, specialization);
}
}
}
}
}
}
TypeNode comparisonType = type;
while (comparisonType != null)
{
List <Method> extensionMethods = null;
if (index.TryGetValue(comparisonType, out extensionMethods))
{
foreach (Method extensionMethod in extensionMethods)
{
if (!IsExtensionMethodHidden(extensionMethod, members))
{
AddExtensionMethod(writer, type, extensionMethod, null);
}
}
}
if (comparisonType.IsGeneric && (comparisonType.TemplateArguments != null) && (comparisonType.TemplateArguments.Count > 0))
{
TypeNode templateType = ReflectionUtilities.GetTemplateType(comparisonType);
TypeNode specialization = comparisonType.TemplateArguments[0];
if (index.TryGetValue(templateType, out extensionMethods))
{
foreach (Method extensionMethod in extensionMethods)
{
if (IsValidTemplateArgument(specialization, extensionMethod.TemplateParameters[0]))
{
if (!IsExtensionMethodHidden(extensionMethod, members))
{
AddExtensionMethod(writer, type, extensionMethod, specialization);
}
}
}
}
}
comparisonType = comparisonType.BaseType;
}
}
private void WriteTypeElements(TypeNode type) {
// collect members
MemberDictionary members = new MemberDictionary(type, this.ApiFilter);
if (members.Count == 0) return;
writer.WriteStartElement("elements");
StartElementCallbacks("elements", members);
foreach (Member member in members) {
writer.WriteStartElement("element");
Member template = ReflectionUtilities.GetTemplateMember(member);
writer.WriteAttributeString("api", namer.GetMemberName(template));
bool write = false;
// inherited, specialized generics get a displayed target different from the target
// we also write out their info, since it can't be looked up anywhere
if (!member.DeclaringType.IsStructurallyEquivalentTo(template.DeclaringType)) {
writer.WriteAttributeString("display-api", namer.GetMemberName(member));
write = true;
}
// if a member is from a type in a dependency assembly, write out its info, since it can't be looked up in this file
if (!assemblyNames.ContainsKey(member.DeclaringType.DeclaringModule.ContainingAssembly.StrongName)) write = true;
// if (Array.BinarySearch(assemblyNames, member.DeclaringType.DeclaringModule.ContainingAssembly.Name) < 0) write = true;
if (write) WriteMember(member);
writer.WriteEndElement();
}
EndElementCallbacks("elements", members);
writer.WriteEndElement();
}
/// <summary>
/// Determines whether an extension method is hidden by a member that's already defined on the type being
/// extended. The extension method is hidden if it has the same name, template parameters, and
/// parameters as a defined method.
/// </summary>
/// <param name="extensionMethod">The extension method to compare</param>
/// <param name="members">A dictionary of the members defined on the type being extended</param>
/// <returns>True if hidden, false if not</returns>
private static bool IsExtensionMethodHidden(Method extensionMethod, MemberDictionary members)
{
if(!members.MemberNames.Contains(extensionMethod.Name.Name))
return false;
// Get a list of members with the same name as the extension method
foreach(Member member in members[extensionMethod.Name.Name])
{
// The hiding member must be a method
if(member.NodeType != NodeType.Method)
continue;
Method method = (Method)member;
// Do the generic template parameters of both methods match?
if(!method.TemplateParametersMatch(extensionMethod.TemplateParameters))
continue;
// !EFW - Don't exclude the first parameter, it does need to be included.
// Do both methods have the same number of parameters?
if(method.Parameters.Count != extensionMethod.Parameters.Count)
continue;
// Do the parameter types of both methods match?
if(DoParameterTypesMatch(extensionMethod.Parameters, method.Parameters))
return true;
}
return false;
}
/// <summary>
/// Determines whether an extension method is hidden by a member that's already defined on the type being
/// extended. The extension method is hidden if it has the same name, template parameters, and
/// parameters as a defined method.
/// </summary>
/// <param name="extensionMethod">The extension method to compare</param>
/// <param name="members">A dictionary of the members defined on the type being extended</param>
/// <returns>True if hidden, false if not</returns>
private static bool IsExtensionMethodHidden(Method extensionMethod, MemberDictionary members)
{
if(!members.MemberNames.Contains(extensionMethod.Name.Name))
return false;
// Get a list of members with the same name as the extension method
foreach(Member member in members[extensionMethod.Name.Name])
{
// The hiding member must be a method
if(member.NodeType != NodeType.Method)
continue;
Method method = (Method)member;
// Do the generic template parameters of both methods match?
if(!method.TemplateParametersMatch(extensionMethod.TemplateParameters))
continue;
// Do both methods have the same number of parameters (not counting the extension method's first
// parameter which identifies the extended type)?
if(method.Parameters.Count != extensionMethod.Parameters.Count - 1)
continue;
// Do the parameter types of both methods match?
if(DoParameterTypesMatch(extensionMethod.Parameters, method.Parameters))
return true;
}
return false;
}
/// <summary>
/// Write out the elements for a type
/// </summary>
/// <param name="type">The type for which to write out elements</param>
private void WriteTypeElements(TypeNode type)
{
MemberDictionary members = new MemberDictionary(type, this.ApiFilter);
if(members.Count != 0)
{
writer.WriteStartElement("elements");
this.StartElementCallbacks("elements", members);
foreach(Member member in members)
{
writer.WriteStartElement("element");
Member template = member.GetTemplateMember();
// !EFW - Change from ComponentOne
writer.WriteAttributeString("api", namer.GetMemberName(template).TranslateToValidXmlValue());
bool write = false;
// Inherited, specialized generics get a displayed target different from the target. We also
// write out their info since it can't be looked up anywhere.
if(!member.DeclaringType.IsStructurallyEquivalentTo(template.DeclaringType))
{
// !EFW - Change from ComponentOne
writer.WriteAttributeString("display-api", namer.GetMemberName(member).TranslateToValidXmlValue());
write = true;
}
// If a member is from a type in a dependency assembly, write out its info, since it can't be
// looked up in this file.
if(!assemblyNames.Contains(member.DeclaringType.DeclaringModule.ContainingAssembly.StrongName))
write = true;
if(write)
this.WriteMember(member);
writer.WriteEndElement();
}
this.EndElementCallbacks("elements", members);
writer.WriteEndElement();
}
}
