public QueuedType(string name, ParserSchema.Table table, QueuedType parent)
{
if (name != null && string.IsNullOrEmpty(name) == true)
{
throw new ArgumentException();
}
this.Name = name;
this.Table = table;
this.Parent = parent;
}
private void ResolveParser(ParserSchema.Table table)
{
foreach (var column in table.Columns
.Where(c => c.Subtable != null))
{
ResolveParser(column.Subtable);
}
foreach (var column in table.Columns
.Where(c => string.IsNullOrEmpty(c.SubtableExternalName) == false))
{
var external = this.LoadParser(column.SubtableExternalName);
column.Subtable = external.Table;
}
}
public static void DeserializeTable(ParserSchema.Table table, Stream input, XmlWriter output)
{
//output.Flush();
var dataSize = input.ReadValueU32();
using (var data = input.ReadToMemoryStream((int)dataSize))
{
/*
Counter++;
using (var temp = File.Create(string.Format("{0}.struct", Counter)))
{
temp.WriteFromStream(data, data.Length);
data.Position = 0;
}
*/
output.WriteStartElement("table");
foreach (var column in table.Columns)
{
if (column.Flags.HasAnyOptions(Parser.ColumnFlags.REDUNDANTNAME |
Parser.ColumnFlags.UNOWNED |
Parser.ColumnFlags.NO_WRITE) == true)
{
continue;
}
//output.WriteComment(string.Format(" offset = {0} ", data.Position));
output.WriteStartElement("column");
output.WriteAttributeString("name", column.Name);
DeserializeColumn(column, data, output);
output.WriteEndElement();
//output.Flush();
}
output.WriteEndElement();
if (data.Position != data.Length)
{
throw new InvalidOperationException();
}
}
//output.Flush();
}
public static string GetColumnName(
ParserSchema.Table table,
ParserSchema.Column column)
{
if (string.IsNullOrEmpty(column.Name) == true)
{
if (table.Columns.Count(c => string.IsNullOrEmpty(c.Name)) > 1)
{
return("__unnamed_" + column.Offset.ToString("X"));
}
return("_");
}
if (table.Columns.Count(c => c != column && c.Name.ToLowerInvariant() == column.Name.ToLowerInvariant()) > 1)
{
throw new InvalidOperationException();
}
return(column.Name);
}
private static ParserSchema.Table LoadTable(XPathNavigator nav)
{
var table = new ParserSchema.Table();
var columnIterator = nav.Select("column");
while (columnIterator.MoveNext() == true)
{
var columnNode = columnIterator.Current;
if (columnNode == null)
{
throw new InvalidOperationException();
}
// ReSharper disable UseObjectOrCollectionInitializer
var column = new ParserSchema.Column();
// ReSharper restore UseObjectOrCollectionInitializer
column.Name = columnNode.GetAttribute("name", "");
var type = columnNode.GetAttribute("type", "");
var token = Parser.GlobalTokens.MatchToken(type, out column.Token, out column.Flags);
var flagIterator = columnNode.Select("flags/flag");
while (flagIterator.MoveNext() == true)
{
if (flagIterator.Current == null)
{
throw new InvalidOperationException();
}
var flag = flagIterator.Current.Value;
if (Enum.IsDefined(typeof(Parser.ColumnFlags), flag) == false)
{
throw new FormatException("invalid schema flag");
}
column.Flags |= (Parser.ColumnFlags)Enum.Parse(typeof(Parser.ColumnFlags), flag);
}
column.Offset = (uint)GetIntElement(columnNode, "offset", 0);
column.RedundantName = GetStringElement(columnNode, "redundant_name", null);
column.MinBits = (byte)GetIntElement(columnNode, "min_bits", 0);
column.FloatRounding = GetStringElement(columnNode, "float_rounding", null);
column.NumberOfElements = GetIntElement(columnNode, "num_elements", 0);
column.Default = GetIntElement(columnNode, "default", 0);
column.StringLength = GetIntElement(columnNode, "string_length", 0);
column.DefaultString = GetStringElement(columnNode, "default_string", null);
column.CommandString = GetStringElement(columnNode, "command_string", null);
column.Size = GetIntElement(columnNode, "size", 0);
column.BitOffset = GetIntElement(columnNode, "bit_offset", 0);
var subtable = columnNode.SelectSingleNode("subtable");
if (subtable != null)
{
column.SubtableExternalName = subtable.GetAttribute("external", "");
column.SubtableIsExternal = true;
var subtableTable = subtable.SelectSingleNode("table");
if (subtableTable != null)
{
column.SubtableIsExternal = false;
column.Subtable = LoadTable(subtableTable);
}
}
var staticDefineList = columnNode.SelectSingleNode("static_define_list");
if (staticDefineList != null)
{
column.StaticDefineListExternalName = staticDefineList.GetAttribute("external", "");
column.StaticDefineListIsExternal = true;
var staticDefineListElements = staticDefineList.SelectSingleNode("elements");
if (staticDefineListElements != null)
{
column.StaticDefineListIsExternal = false;
column.StaticDefineList = ParserEnumFile.LoadEnumeration(staticDefineListElements);
}
}
var formatName = GetStringElement(columnNode, "format", null);
if (string.IsNullOrEmpty(formatName) == false)
{
ParserSchema.ColumnFormat format;
if (Enum.TryParse(formatName, true, out format) == false)
{
throw new FormatException("invalid column format");
}
column.Format = format;
}
var formatStringIterator = columnNode.Select("format_strings/format_string");
column.FormatStrings.Clear();
while (formatStringIterator.MoveNext() == true)
{
var formatStringNode = formatStringIterator.Current;
if (formatStringNode == null)
{
throw new InvalidOperationException();
}
var formatStringKey = formatStringNode.GetAttribute("name", "");
if (string.IsNullOrEmpty(formatStringKey) == true)
{
throw new FormatException("invalid schema format string key");
}
/*Console.WriteLine("Adding {0}={1} to {2}",
* formatStringKey, formatStringNode.Value, column.Name);*/
column.FormatStrings.Add(formatStringKey, formatStringNode.Value);
}
table.Columns.Add(column);
}
return(table);
}
public QueuedType(string name, ParserSchema.Table table)
: this(name, table, null)
{
}
