private void GetTableDeclParseFuncReadNameLine( TableDescriptor.TableDef tableDef, string indent, out string output) { StringBuilder sb = new StringBuilder(); string start = string.Format( "{0}// read name line{1}" + "{0}lineBuffer = r.NextLine();{1}" + "{0}if (lineBuffer == null) {{{1}" + "{0} errorInfo = \"name line is required\";{1}" + "{0} return false;{1}" + "{0}}}{1}" + "{0}if (lineBuffer.Count != columnCountReq) {{{1}" + "{0} errorInfo = string.Format({1}" + "{0} \"name line column count {{0}} is invalid," + " should be {{1}}\",{1}" + "{0} lineBuffer.Count, columnCountReq);{1}" + "{0} return false;{1}" + "{0}}}{1}" + "{0}{{{1}" + "{0} int colNumber = 0;{1}" + "{1}", indent, this.newLineStr); string end = string.Format( "{0}}}{1}" + "{1}", indent, this.newLineStr); sb.Append(start); indent += " "; for (int i = 0; i < tableDef.Columns.Count; ++i) { TableDescriptor.TableDef.ColumnDef columnDef = tableDef.Columns[i]; sb.AppendFormat( "{0}if (lineBuffer[colNumber++] != \"{1}\") {{{2}" + "{0} errorInfo = string.Format({2}" + "{0} \"column {{0}} should be named as `{1}`\"," + " colNumber);{2}" + "{0} return false;{2}" + "{0}}}{2}", indent, columnDef.Name, this.newLineStr); } sb.Append(end); output = sb.ToString(); }
private void CalculateTableKeyColumnIndex( TableDescriptor.TableDef tableDef) { for (int i = 0; i < tableDef.Columns.Count; ++i) { TableDescriptor.TableDef.ColumnDef columnDef = tableDef.Columns[i]; if (columnDef == tableDef.TableKey) { tableDef.TableKeyColumnIndex = i; return; } } }
private void GetTableDeclRowClassDecl( TableDescriptor.TableDef tableDef, string indent, out string output) { StringBuilder sb = new StringBuilder(); string start = string.Format( "{0}public sealed class Row{1}" + "{0}{{{1}", indent, this.newLineStr); string end = string.Format( "{0}}}{1}", indent, this.newLineStr); indent += " "; sb.Append(start); for (int i = 0; i < tableDef.Columns.Count; ++i) { TableDescriptor.TableDef.ColumnDef columnDef = tableDef.Columns[i]; string csharpType = GetCSharpType(columnDef); string defaultValue = GetCSharpTypeDefaultValue(columnDef); if (defaultValue.Length > 10) { sb.AppendFormat( "{0}public {1} {2} ={4}" + "{0} {3};{4}", indent, csharpType, columnDef.Name, defaultValue, this.newLineStr); } else { sb.AppendFormat("{0}public {1} {2} = {3};{4}", indent, csharpType, columnDef.Name, defaultValue, this.newLineStr); } } sb.Append(end); output = sb.ToString(); }
private string GetCSharpTypeDefaultValue( TableDescriptor.TableDef.ColumnDef columnDef) { string defaultValue = ""; if (columnDef.Type == ColumnType.Int) { defaultValue = "0"; } else if (columnDef.Type == ColumnType.String) { defaultValue = "\"\""; } else if (columnDef.Type == ColumnType.Struct || columnDef.Type == ColumnType.List) { defaultValue = string.Format("new {0}()", GetCSharpType(columnDef)); } return(defaultValue); }
private string GetCSharpType( TableDescriptor.TableDef.ColumnDef columnDef) { ColumnType checkType; if (columnDef.Type == ColumnType.List) { checkType = columnDef.ListType; } else { checkType = columnDef.Type; } string csharpType = ""; if (checkType == ColumnType.Int) { csharpType = "int"; } else if (checkType == ColumnType.String) { csharpType = "string"; } else if (checkType == ColumnType.Struct) { csharpType = columnDef.RefStructDef.Name; } if (columnDef.Type == ColumnType.List) { return(string.Format("System.Collections.Generic.List<{0}>", csharpType)); } else { return(csharpType); } }
private void GetTableDeclParseFuncParseColumns( TableDescriptor.TableDef tableDef, string indent, out string output) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < tableDef.Columns.Count; ++i) { TableDescriptor.TableDef.ColumnDef columnDef = tableDef.Columns[i]; ColumnType checkType; if (columnDef.Type == ColumnType.List) { checkType = columnDef.ListType; } else { checkType = columnDef.Type; } bool isList = (columnDef.Type == ColumnType.List); if (checkType == ColumnType.Int) { if (isList) { sb.AppendFormat( "{0}Brickred.Table.Util.ReadColumnIntList(" + "lineBuffer[colNumber++], ref row.{1});{2}", indent, columnDef.Name, this.newLineStr); } else { sb.AppendFormat( "{0}row.{1} = Brickred.Table.Util.Atoi(" + "lineBuffer[colNumber++]);{2}", indent, columnDef.Name, this.newLineStr); } } else if (checkType == ColumnType.String) { if (isList) { sb.AppendFormat( "{0}Brickred.Table.Util.ReadColumnStringList(" + "lineBuffer[colNumber++], ref row.{1});{2}", indent, columnDef.Name, this.newLineStr); } else { sb.AppendFormat( "{0}row.{1} = lineBuffer[colNumber++];{2}", indent, columnDef.Name, this.newLineStr); } } else if (checkType == ColumnType.Struct) { if (isList) { sb.AppendFormat( "{0}if (Brickred.Table.Util.ReadColumnStructList({1}" + "{0} lineBuffer[colNumber++], ref row.{2}) " + "== false) {{{1}" + "{0} errorInfo = string.Format({1}" + "{0} \"line {{0}} column `{2}` value is invalid\", " + "lineNumber);{1}" + "{0} return false;{1}" + "{0}}}{1}", indent, this.newLineStr, columnDef.Name); } else { sb.AppendFormat( "{0}if (row.{1}.Parse(" + "lineBuffer[colNumber++]) == false) {{{2}" + "{0} errorInfo = string.Format({2}" + "{0} \"line {{0}} column `{1}` value is invalid\", " + "lineNumber);{2}" + "{0} return false;{2}" + "{0}}}{2}", indent, columnDef.Name, this.newLineStr); } } } output = sb.ToString(); }
private bool AddTableColumnDef( TableDescriptor.TableDef tableDef, XElement element) { // check name attr string name; { XAttribute attr = element.Attribute("name"); if (attr == null) { PrintLineError(element, "`col` node must contain a `name` attribute"); return(false); } name = attr.Value; } if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false) { PrintLineError(element, "`col` node `name` attribute is invalid"); return(false); } if (tableDef.ColumnNameIndex.ContainsKey(name)) { PrintLineError(element, "`col` node `name` attribute duplicated"); return(false); } // check type attr string type; { XAttribute attr = element.Attribute("type"); if (attr == null) { PrintLineError(element, "`col` node must contain a `type` attribute"); return(false); } type = attr.Value; } TableDescriptor.TableDef.ColumnDef def = new TableDescriptor.TableDef.ColumnDef(); def.ParentRef = tableDef; def.Name = name; def.LineNumber = GetLineNumber(element); // get type info string columnTypeStr = type; { Match m = Regex.Match(type, @"^list{(.+)}$"); if (m.Success) { columnTypeStr = m.Groups[1].Value; def.Type = TableDescriptor.TableDef.ColumnType.List; } } TableDescriptor.TableDef.ColumnType columnType = TableDescriptor.TableDef.ColumnType.None; if (columnTypeStr == "int") { columnType = TableDescriptor.TableDef.ColumnType.Int; } else if (columnTypeStr == "string") { columnType = TableDescriptor.TableDef.ColumnType.String; } else { for (;;) { TableDescriptor.StructDef refStructDef = null; // check is local struct if (tableDef.LocalStructNameIndex.TryGetValue( columnTypeStr, out refStructDef)) { columnType = TableDescriptor.TableDef.ColumnType.Struct; def.RefStructDef = refStructDef; break; } // check is global struct if (this.descriptor.GlobalStructNameIndex.TryGetValue( columnTypeStr, out refStructDef)) { columnType = TableDescriptor.TableDef.ColumnType.Struct; def.RefStructDef = refStructDef; break; } PrintLineError(element, "type `{0}` is undefined", columnTypeStr); return(false); } } if (def.Type == TableDescriptor.TableDef.ColumnType.List) { def.ListType = columnType; } else { def.Type = columnType; } // check readby attr { XAttribute attr = element.Attribute("readby"); if (attr != null) { string[] readers = attr.Value.Split('|'); for (int i = 0; i < readers.Length; ++i) { string reader = readers[i]; TableDescriptor.ReaderDef readerDef = null; if (this.descriptor.Readers.TryGetValue( reader, out readerDef) == false) { PrintLineError(element, "reader `{0}` is not defined", reader); return(false); } def.Readers[reader] = readerDef; } } } tableDef.Columns.Add(def); tableDef.ColumnNameIndex.Add(def.Name, def); return(true); }
private bool AddTableDef(XElement element) { // check name attr string name; { XAttribute attr = element.Attribute("name"); if (attr == null) { PrintLineError(element, "`table` node must contain a `name` attribute"); return(false); } name = attr.Value; } if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false) { PrintLineError(element, "`table` node `name` attribute is invalid"); return(false); } if (this.descriptor.TableNameIndex.ContainsKey(name) || this.descriptor.GlobalStructNameIndex.ContainsKey(name)) { PrintLineError(element, "`table` node `name` attribute duplicated"); return(false); } TableDescriptor.TableDef def = new TableDescriptor.TableDef(); def.Name = name; def.LineNumber = GetLineNumber(element); { IEnumerator <XElement> iter = element.Elements().GetEnumerator(); while (iter.MoveNext()) { XElement childElement = iter.Current; if (childElement.Name == "struct") { // parse local struct if (AddStructDef(def, childElement) == false) { return(false); } } else if (childElement.Name == "col") { // parse column if (AddTableColumnDef(def, childElement) == false) { return(false); } } else { PrintLineError(childElement, "expect a `struct` or `col` node"); return(false); } } } // check key/setkey attr { string key; XAttribute attr = element.Attribute("key"); if (attr != null) { key = attr.Value; def.TableKeyType = TableDescriptor.TableDef.KeyType.SingleKey; } else { attr = element.Attribute("setkey"); if (attr != null) { key = attr.Value; def.TableKeyType = TableDescriptor.TableDef.KeyType.SetKey; } else { PrintLineError(element, "`table` node must contain a " + "`key` or `setkey` attribute"); return(false); } } TableDescriptor.TableDef.ColumnDef tableKey = null; if (def.ColumnNameIndex.TryGetValue( key, out tableKey) == false) { PrintLineError(element, "table key `{0}` is not defined", key); return(false); } if (tableKey.Type != TableDescriptor.TableDef.ColumnType.Int && tableKey.Type != TableDescriptor.TableDef.ColumnType.String) { PrintLineError(element, "table key can only be `int` or `string` type"); return(false); } def.TableKey = tableKey; } // check file attr { XAttribute attr = element.Attribute("file"); if (attr == null) { PrintLineError(element, "`table` node must contain a `file` attribute"); return(false); } def.FileName = attr.Value; } // check readby attr { XAttribute attr = element.Attribute("readby"); if (attr != null) { string[] readers = attr.Value.Split('|'); for (int i = 0; i < readers.Length; ++i) { string reader = readers[i]; TableDescriptor.ReaderDef readerDef = null; if (this.descriptor.Readers.TryGetValue( reader, out readerDef) == false) { PrintLineError(element, "reader `{0}` is not defined", reader); return(false); } def.Readers[reader] = readerDef; } } } CalculateTableKeyColumnIndex(def); this.descriptor.Tables.Add(def); this.descriptor.TableNameIndex.Add(def.Name, def); return(true); }
public bool FilterByReader(string reader) { if (this.descriptor == null) { return(false); } if (this.descriptor.Readers.ContainsKey(reader) == false) { Console.Error.WriteLine(string.Format( "error: reader `{0}` is not defined", reader)); return(false); } // remove unread tables List <TableDescriptor.TableDef> filteredTables = new List <TableDescriptor.TableDef>(); for (int i = 0; i < this.descriptor.Tables.Count; ++i) { TableDescriptor.TableDef tableDef = this.descriptor.Tables[i]; if (tableDef.Readers.Count == 0 || tableDef.Readers.ContainsKey(reader)) { filteredTables.Add(tableDef); } else { this.descriptor.TableNameIndex.Remove(tableDef.Name); } } this.descriptor.Tables = filteredTables; // remove unread columns for (int i = 0; i < this.descriptor.Tables.Count; ++i) { TableDescriptor.TableDef tableDef = this.descriptor.Tables[i]; List <TableDescriptor.TableDef.ColumnDef> filteredColumns = new List <TableDescriptor.TableDef.ColumnDef>(); for (int j = 0; j < tableDef.Columns.Count; ++j) { TableDescriptor.TableDef.ColumnDef columnDef = tableDef.Columns[j]; if (columnDef == tableDef.TableKey || columnDef.Readers.Count == 0 || columnDef.Readers.ContainsKey(reader)) { filteredColumns.Add(columnDef); } else { tableDef.ColumnNameIndex.Remove(columnDef.Name); } } tableDef.Columns = filteredColumns; CalculateTableKeyColumnIndex(tableDef); } // collect used structs Dictionary <TableDescriptor.StructDef, bool> usedStructs = new Dictionary <TableDescriptor.StructDef, bool>(); for (int i = 0; i < this.descriptor.Tables.Count; ++i) { TableDescriptor.TableDef tableDef = this.descriptor.Tables[i]; for (int j = 0; j < tableDef.Columns.Count; ++j) { TableDescriptor.TableDef.ColumnDef columnDef = tableDef.Columns[j]; if (columnDef.RefStructDef != null) { usedStructs[columnDef.RefStructDef] = true; } } } // remove unused global structs List <TableDescriptor.StructDef> filteredGlobalStructs = new List <TableDescriptor.StructDef>(); for (int i = 0; i < this.descriptor.GlobalStructs.Count; ++i) { TableDescriptor.StructDef structDef = this.descriptor.GlobalStructs[i]; if (usedStructs.ContainsKey(structDef)) { filteredGlobalStructs.Add(structDef); } else { this.descriptor.GlobalStructNameIndex.Remove( structDef.Name); } } this.descriptor.GlobalStructs = filteredGlobalStructs; // remove unused local structs for (int i = 0; i < this.descriptor.Tables.Count; ++i) { TableDescriptor.TableDef tableDef = this.descriptor.Tables[i]; List <TableDescriptor.StructDef> filteredLocalStructs = new List <TableDescriptor.StructDef>(); for (int j = 0; j < tableDef.LocalStructs.Count; ++j) { TableDescriptor.StructDef structDef = tableDef.LocalStructs[j]; if (usedStructs.ContainsKey(structDef)) { filteredLocalStructs.Add(structDef); } else { tableDef.LocalStructNameIndex.Remove(structDef.Name); } } tableDef.LocalStructs = filteredLocalStructs; } return(true); }