private void AddMember(UField field, string name, bool isResolvedName)
{
CollapsedMember collapsedMember = null;
UProperty property = field as UProperty;
if (property != null)
{
structInfo.collapsedMembersByProperty.TryGetValue(property, out collapsedMember);
}
UFunction function = field as UFunction;
if (function != null)
{
structInfo.collapsedMembersByFunction.TryGetValue(function, out collapsedMember);
}
if (collapsedMember != null)
{
if (isResolvedName)
{
collapsedMember.ResolvedName = name;
}
else
{
name = collapsedMember.Name;
}
}
NameConflictFieldInfo fieldInfo;
if (!MembersByName.TryGetValue(name, out fieldInfo))
{
MembersByName.Add(name, fieldInfo = new NameConflictFieldInfo(name));
}
fieldInfo.AddField(field, collapsedMember);
}
private void ResolveNameConflicts()
{
List <NameConflictInfo> baseConflictInfos = new List <NameConflictInfo>();
UStruct parentStruct = Struct.GetSuperStruct();
if (parentStruct != null)
{
StructInfo parentInfo = codeGenerator.GetStructInfo(parentStruct);
if (parentInfo != null && parentInfo.conflictInfo != null)
{
baseConflictInfos.Add(parentInfo.conflictInfo);
}
}
if (Class != null)
{
foreach (FImplementedInterface implementedInterface in Class.Interfaces)
{
UClass interfaceClass = implementedInterface.InterfaceClass;
if (interfaceClass != null)
{
StructInfo interfaceInfo = codeGenerator.GetStructInfo(interfaceClass);
if (interfaceInfo != null && interfaceInfo.conflictInfo != null)
{
baseConflictInfos.Add(interfaceInfo.conflictInfo);
}
}
}
}
conflictInfo = new NameConflictInfo(this);
foreach (KeyValuePair <UProperty, string> property in exportableProperties)
{
conflictInfo.AddMember(property.Key, codeGenerator.GetMemberName(property.Key, false, property.Value));
}
foreach (UFunction function in exportableFunctions)
{
// Functions are a special case. They can be redefined in the hierarchy but for name resolving
// we want them to have the same name throughout. Therefore only resolve the base-most function
// name (even if redefined later in the hierarchy). Then when we do a name conflict lookup find that
// base-most function and use that name for all of the functions in the hierarchy with that name.
// - This is lookup is done in ResolveNameConflict().
if (codeGenerator.GetOriginalFunctionOwner(function) == Class)
{
conflictInfo.AddMember(function, codeGenerator.GetFunctionName(function, false));
}
}
foreach (NameConflictInfo baseConflictInfo in baseConflictInfos)
{
foreach (KeyValuePair <string, NameConflictFieldInfo> baseMembersByName in baseConflictInfo.MembersByName)
{
NameConflictFieldInfo baseMembers;
if (!conflictInfo.BaseMembersByName.TryGetValue(baseMembersByName.Key, out baseMembers))
{
conflictInfo.BaseMembersByName.Add(baseMembersByName.Key,
baseMembers = new NameConflictFieldInfo(baseMembersByName.Key));
}
foreach (KeyValuePair <UField, CollapsedMember> baseMember in baseMembersByName.Value.Fields)
{
baseMembers.AddField(baseMember.Key, baseMember.Value);
}
}
foreach (KeyValuePair <string, NameConflictFieldInfo> baseBaseMembersByName in baseConflictInfo.BaseMembersByName)
{
NameConflictFieldInfo baseBaseMembers;
if (!conflictInfo.BaseMembersByName.TryGetValue(baseBaseMembersByName.Key, out baseBaseMembers))
{
conflictInfo.BaseMembersByName.Add(baseBaseMembersByName.Key,
baseBaseMembers = new NameConflictFieldInfo(baseBaseMembersByName.Key));
}
foreach (KeyValuePair <UField, CollapsedMember> baseBaseMember in baseBaseMembersByName.Value.Fields)
{
baseBaseMembers.AddField(baseBaseMember.Key, baseBaseMember.Value);
}
}
}
var tempMembersByName = new Dictionary <string, NameConflictFieldInfo>(conflictInfo.MembersByName);
foreach (KeyValuePair <string, NameConflictFieldInfo> membersByName in tempMembersByName)
{
// What about overridden functions? where do they appear?
if (membersByName.Value.HasConflict() || conflictInfo.BaseMembersByName.ContainsKey(membersByName.Key))
{
foreach (KeyValuePair <UField, CollapsedMember> field in membersByName.Value.Fields)
{
if (field.Value == null)
{
string hashedName = membersByName.Key + "_" + field.Key.GetPathName().GetHashCode().ToString("X8");
NameConflictResolved(field.Key, hashedName);
}
}
foreach (KeyValuePair <CollapsedMember, List <UField> > collapsedMember in membersByName.Value.FieldsByCollapsedMember)
{
UField field = null;
if (collapsedMember.Key.Getter != null)
{
field = collapsedMember.Key.Getter;
}
else if (collapsedMember.Key.Setter != null)
{
field = collapsedMember.Key.Setter;
}
else if (collapsedMember.Key.BackingProperty != null)
{
field = collapsedMember.Key.BackingProperty;
}
string hashedName = membersByName.Key + "_" + field.GetPathName().GetHashCode().ToString("X8");
if (collapsedMember.Key.Getter != null)
{
NameConflictResolved(collapsedMember.Key.Getter, hashedName);
}
if (collapsedMember.Key.Setter != null)
{
NameConflictResolved(collapsedMember.Key.Setter, hashedName);
}
if (collapsedMember.Key.BackingProperty != null)
{
NameConflictResolved(collapsedMember.Key.BackingProperty, hashedName);
}
}
// All fields with this name should have been renamed. Remove the old name.
conflictInfo.MembersByName.Remove(membersByName.Key);
}
}
}
