/// <summary>
/// Create a new enum choice with a specified value.
/// </summary>
/// <param name="i">The specified value for this enum choice.</param>
/// <param name="propertyName">The name of the enum choice.</param>
internal EnumClass(int i, string propertyName)
{
Name = propertyName;
EnumMetaData meta = getMetaData();
Value = this.AddEnum(i, meta);
}
/// <summary>
/// Create a new enum choice. It will automatically be assigned a value, starting at 0 or the next
/// available value above the previous enum's choice.
/// </summary>
/// <param name="propertyName">The name of the enum choice.</param>
internal EnumClass(string propertyName)
{
Name = propertyName;
EnumMetaData meta = getMetaData();
Value = this.AddEnum(meta.NextValue, meta);
}
public void ChangeEnum(EnumMetaData @enum)
{
Contract.Requires(@enum != null);
MetaData = @enum;
GetParentContainer()?.ChildHasChanged(this);
}
private int AddEnum(int number, EnumMetaData meta)
{
dataForTypes[GetType()] = meta;
while (meta.EnumOptions.ContainsKey(number))
{
number++;
}
meta.EnumOptions.Add(number, this);
meta.NextValue = number + 1;
meta.EnumNames.Add(Name, this);
return(number);
}
private void addEnumIconButton_Click(object sender, EventArgs e)
{
var @enum = new EnumMetaData
{
Name = "Enum"
};
using (var eef = new EnumEditorForm(@enum))
{
if (eef.ShowDialog() == DialogResult.OK)
{
project.AddEnum(@enum);
ShowFilteredEnums();
}
}
}
public EnumEditorForm(EnumMetaData @enum)
{
Contract.Requires(@enum != null);
InitializeComponent();
this.@enum = @enum;
enumNameTextBox.Text = @enum.Name;
enumUnderlyingTypeSizeComboBox.SelectedValue = @enum.Size;
enumFlagCheckBox.Checked = @enum.UseFlagsMode;
foreach (var kv in @enum.Values)
{
enumDataGridView.Rows.Add(kv.Key, kv.Value);
}
}
private EnumMetaData getMetaData()
{
EnumMetaData data = metaData;
if (data != null)
{
return(data);
}
lock (dataForTypes)
{
if (!dataForTypes.TryGetValue(this.GetType(), out data))
{
data = new EnumMetaData();
dataForTypes[this.GetType()] = data;
}
}
return(data);
}
public EnumNode()
{
MetaData = new EnumMetaData
{
Name = "TestEnum"
};
MetaData.SetData(true, 4, new SortedDictionary <long, string>
{
{ 0, "Val0" },
{ 1, "Val1" },
{ 2, "Val2" },
{ 4, "Val4" },
{ 8, "Val8" },
{ 16, "Val16" },
{ 32, "Val32" },
{ 64, "Val64" },
{ 128, "Val128" },
{ 256, "Val256" },
{ 512, "Val512" },
{ 1024, "Val1024" }
});
}
public void Load(Stream input, ILogger logger)
{
Contract.Requires(input != null);
Contract.Requires(logger != null);
using (var archive = new ZipArchive(input, ZipArchiveMode.Read))
{
var dataEntry = archive.GetEntry(DataFileName);
if (dataEntry == null)
{
throw new FormatException();
}
using (var entryStream = dataEntry.Open())
{
var document = XDocument.Load(entryStream);
if (document.Root?.Element(XmlClassesElement) == null)
{
throw new FormatException("The data has not the correct format.");
}
uint.TryParse(document.Root.Attribute(XmlVersionAttribute)?.Value, out var fileVersion);
if ((fileVersion & FileVersionCriticalMask) > (FileVersion & FileVersionCriticalMask))
{
throw new FormatException($"The file version is unsupported. A newer {Constants.ApplicationName} version is required to read it.");
}
var platform = document.Root.Attribute(XmlPlatformAttribute)?.Value;
if (platform != Constants.Platform)
{
logger.Log(LogLevel.Warning, $"The platform of the file ({platform}) doesn't match the program platform ({Constants.Platform}).");
}
var customDataElement = document.Root.Element(XmlCustomDataElement);
if (customDataElement != null)
{
project.CustomData.Deserialize(customDataElement);
}
var typeMappingElement = document.Root.Element(XmlTypeMappingElement);
if (typeMappingElement != null)
{
project.TypeMapping.Deserialize(typeMappingElement);
}
var enumsElement = document.Root.Element(XmlEnumsElement);
if (enumsElement != null)
{
foreach (var enumElement in enumsElement.Elements(XmlEnumElement))
{
var name = enumElement.Attribute(XmlNameAttribute)?.Value ?? string.Empty;
var useFlagsMode = (bool?)enumElement.Attribute(XmlFlagsAttribute) ?? false;
var size = enumElement.Attribute(XmlSizeAttribute).GetEnumValue <EnumMetaData.UnderlyingTypeSize>();
var values = new Dictionary <string, long>();
foreach (var itemElement in enumElement.Elements(XmlItemElement))
{
var itemName = itemElement.Attribute(XmlNameAttribute)?.Value ?? string.Empty;
var itemValue = (long?)itemElement.Attribute(XmlValueAttribute) ?? 0L;
values.Add(itemName, itemValue);
}
var @enum = new EnumMetaData
{
Name = name
};
@enum.SetData(useFlagsMode, size, values);
project.AddEnum(@enum);
}
}
var classes = new List <Tuple <XElement, ClassNode> >();
var classesElement = document.Root.Element(XmlClassesElement);
if (classesElement != null)
{
foreach (var element in classesElement
.Elements(XmlClassElement)
.DistinctBy(e => e.Attribute(XmlUuidAttribute)?.Value))
{
var node = new ClassNode(false)
{
Uuid = NodeUuid.FromBase64String(element.Attribute(XmlUuidAttribute)?.Value, true),
Name = element.Attribute(XmlNameAttribute)?.Value ?? string.Empty,
Comment = element.Attribute(XmlCommentAttribute)?.Value ?? string.Empty,
AddressFormula = element.Attribute(XmlAddressAttribute)?.Value ?? string.Empty
};
if (!project.ContainsClass(node.Uuid))
{
project.AddClass(node);
classes.Add(Tuple.Create(element, node));
}
}
}
foreach (var t in classes)
{
var nodes = t.Item1.Elements(XmlNodeElement)
.Select(e => CreateNodeFromElement(e, t.Item2, logger))
.Where(n => n != null);
foreach (var node in nodes)
{
t.Item2.AddNode(node);
}
}
}
}
}
