/// <summary>
/// Creates a new MutationCodeScope using the scope information provided.
/// </summary>
/// <param name="@namespace">Full type name for the code scope</param>
/// <param name="parentNamepace">Full type name of the parent type/namespace including the namespace</param>
/// <param name="definitionAddress">Guerilla definition address that corresponds to this code scope</param>
/// <param name="scopeType">Type of code scope</param>
public MutationCodeScope(string @namespace, string parentNamepace, int definitionAddress, MutationCodeScopeType scopeType)
{
// Initialize fields.
this.Namespace = @namespace;
this.ParentNamespace = parentNamepace;
this.DefinitionAddress = definitionAddress;
this.Type = scopeType;
// Initialize field/type lists.
this.Fields = new HashSet <string>();
this.Types = new Dictionary <string, MutationCodeScope>();
}
/// <summary>
/// Creates a new code scope for a type is one does not already exist, else it turns the existing scope for the type.
/// </summary>
/// <param name="typeName">Name of the type</param>
/// <param name="definitionAddress">Guerilla definition address for the type</param>
/// <param name="scopeType">Type of code scope to be created</param>
/// <returns>The code scope for the type.</returns>
public MutationCodeScope CreateCodeScopeForType(string typeName, int definitionAddress, MutationCodeScopeType scopeType)
{
// Check if there is an entry in the Types list with the same definition address.
MutationCodeScope codeScope = FindExistingCodeScope(definitionAddress);
if (codeScope != null)
{
// There is an existing code scope for this type so just return that.
return(codeScope);
}
// Create a code safe type name for the new type.
string newTypeName, displayName, units, tooltip;
EditorMarkUpFlags markupFlags;
MutationCodeFormatter.ProcessFieldName(typeName, out newTypeName, out displayName, out units, out tooltip, out markupFlags);
if (newTypeName == "" || MutationCodeFormatter.IsValidFieldName(newTypeName) == false)
{
// For now we will create a no name type for it, and I will create a preprocessing function later on.
newTypeName = this.CreateNoNameType();
}
// Check if the type is an enum or flags and append the corresponding character.
if (scopeType == MutationCodeScopeType.Bitmask)
{
// Append 'b' for bitmask.
newTypeName = newTypeName.Insert(0, char.IsUpper(newTypeName[0]) == true ? "b" : "b_");
}
else if (scopeType == MutationCodeScopeType.Enum)
{
// Append 'e' for enum.
newTypeName = newTypeName.Insert(0, char.IsUpper(newTypeName[0]) == true ? "e" : "e_");
}
// Check if the type name is unique or if it already exists.
if (this.Types.Keys.Contains(newTypeName) == true)
{
string tempTypeName = "";
// This shouldn't really happen, but if it does loop until we have a valid type name.
int uniqueInt = 1;
do
{
// Append an integer to the type name to try and make it unique.
tempTypeName = string.Format("{0}{1}", newTypeName, uniqueInt++);
}while (this.Types.Keys.Contains(tempTypeName) == true);
// Save the temp type name.
newTypeName = tempTypeName;
}
// Create a new code scope for this type.
codeScope = new MutationCodeScope(newTypeName, this.Namespace, definitionAddress, scopeType);
// Add the new type to the types dictionary.
this.Types.Add(newTypeName, codeScope);
// Return the new code scope for the type.
return(codeScope);
}
