xiang.li
/
luban
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

【删除】删除对配置双键表的支持

main
walon 2021-06-21 22:53:47 +08:00
parent 75c92d4685
commit 0aef438e0c
20 changed files with 14 additions and 589 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
README.md
View File

@ -47,7 +47,7 @@ Luban适合有以下需求的开发者：
- 支持数据标签。 可以选择导出符合要求的数据，发布正式数据时策划不必手动注释掉那些测试或者非正式数据了。
- 强大的数据校验能力。支持内建数据格式检查；支持ref表引用检查（策划不用担心填错id）；支持path资源检查（策划不用担心填错资源路径）。
- 支持常量别名。策划不必再为诸如 升级丹 这样的道具手写具体道具id了。
- 支持多种常见数据表模式。 one(单例表)、map（常规key-value表）、bmap(双键表)
- 支持多种常见数据表模式。 one(单例表)、map（常规key-value表）
- 支持emmylua anntations。生成的lua包含符合emmylua 格式anntations信息。配合emmylua有良好的配置代码提示能力。
- 支持res资源标记。可以一键导出配置中引用的所有资源列表(icon,ui,assetbundle等等)
- 生成代码良好模块化。
@ -311,20 +311,6 @@ Luban适合有以下需求的开发者：
![multi_data](docs/images/examples/multi_02.png)
### 双主键表
两个主键的表，以key1,key2为主键。
```xml
<bean name="TwoKeyTable">
<var name="key1" type="int"/>
<var name="key2" type="string"/>
<var name="name" type="string"/>
</bean>
<table name="TbTowKey" value="TwoKeyTable" index="key1,key2" input="examples.xlsx"/>
```
![ex_91](docs/images/examples/ex_91.png)
### 单例表
@ -713,8 +699,6 @@ return
print(require("TbGlobal").name)
-- 访问普通的 key-value 表
print(require("TbItem")[12].x1)
-- 访问 双键表
print(require("TbTwoKey")[1][10].x8)
```
- C# 使用示例
@ -726,11 +710,8 @@ return
Console.WriteLine(tables.TbGlobal.Name);
// 访问普通的 key-value 表
Console.WriteLine(tables.TbItem.Get(12).X1);
// 访问 双键表
Console.WriteLine(tables.TbTwoKey.Get(1, 10).X8);
// 支持 operator []用法
Console.WriteLine(tables.TbMail[1001].X2);
Console.WriteLine(tables.TbTwoKey[100, 1].X8);
```
- typescript 使用示例
@ -742,8 +723,6 @@ return
console.log(tables.TbGlobal.name)
// 访问普通的 key-value 表
console.log(tables.TbItem.get(12).x1)
// 访问 双键表
console.log(tables.TbTwoKey.get(1,10).x8)
```
- go 使用示例
@ -757,8 +736,6 @@ return
println(tables.TbGlobal.Name)
// 访问普通的 key-value 表
println(tables.TbItem.Get(12).X1)
// 访问 双键表
println(tables.TbTwoKey.Get(1, 10).X8)
```
- [更多语言的例子](docs/samples.md)

3
config/Defines/test.xml
View File

@ -100,9 +100,6 @@
<table name="TbDataFromLua" value="DemoType2" input="test/lua_datas"/> 普通表，不过数据从tbrole_datas目录递归读入，每个文件是一个记录
<table name="TbTwoKey" value="DemoType2" index="x3,x4" input="test/json_datas" mode="bmap"/>
<bean name="MultiRowType1">
<var name="id" type="int"/>
<var name="x" type="int"/>

28
src/Luban.Job.Cfg/Source/DataVisitors/LuaExportor.cs
View File

@ -37,34 +37,6 @@ namespace Luban.Job.Cfg.DataVisitors
result.Add("}");
}
public void ExportTableTwoKeyMap(DefTable t, List<Record> records, List<string> result)
{
result.Add("return ");
result.Add("{");
var s = new StringBuilder();
var ks = new StringBuilder();
foreach (var g in records.GroupBy(r => r.Data.GetField(t.Index1)))
{
result.Add($"[{ToLuaCodeString(g.Key, t.Assembly, ks)}] =");
result.Add("{");
foreach (Record r in g)
{
DBean d = r.Data;
s.Clear();
s.Append($"[{ToLuaCodeString(d.GetField(t.Index2), t.Assembly, ks)}] = ");
Accept(d, t.Assembly, s);
s.Append(',');
result.Add(s.ToString());
}
result.Add("},");
}
result.Add("}");
}
private string ToLuaCodeString(DType data, DefAssembly ass, StringBuilder b)
{
b.Clear();

5
src/Luban.Job.Cfg/Source/DataVisitors/ValidatorVisitor.cs
View File

@ -37,11 +37,6 @@ namespace Luban.Job.Cfg.DataVisitors
{
_path.Push(data.Fields[keyIndex]);
}
else if (table.IsTwoKeyMapTable)
{
_path.Push(data.Fields[keyIndex]);
_path.Push(data.Fields[table.IndexFieldIdIndex2]);
}
Accept(data, ass);
}
}

21
src/Luban.Job.Cfg/Source/Defs/CfgDefLoader.cs
View File

@ -200,28 +200,9 @@ namespace Luban.Job.Cfg.Defs
mode = ETableMode.MAP;
break;
}
case "bmap":
{
if ((string.IsNullOrWhiteSpace(indexStr) || indexStr.Split(',').Length != 2))
{
throw new Exception($"定义文件:{CurImportFile} table:{tableName} 是双键表，必须在index属性里指定2个key");
}
mode = ETableMode.BMAP;
break;
}
case "":
{
// 当 mode 属性为空时, 智能根据 index 值推测表类型
// 如果index为空或一个键,则为 MAP类型
// 如果index为2个键，则为 BMAP类型
var indexs = indexStr.Split(',').Select(s => s.Trim()).ToList();
switch (indexs.Count)
{
case 0:
case 1: mode = ETableMode.MAP; break;
case 2: mode = ETableMode.BMAP; break;
default: throw new Exception($"定义文件:{CurImportFile} table:{tableName} 最多只能有两个 index");
}
mode = ETableMode.MAP;
break;
}
default:

5
src/Luban.Job.Cfg/Source/Defs/DefAssembly.cs
View File

@ -114,11 +114,6 @@ namespace Luban.Job.Cfg.Defs
_recordsByTables[table.FullName] = new TableDataInfo(mainRecords, branchRecords);
}
//public void SetDataTableMap(DefTable table, Dictionary<DType, Record> recordMap)
//{
// _recordsByTables[table.FullName].FinalRecordMap = recordMap;
//}
public List<Record> GetTableAllDataList(DefTable table)
{
return _recordsByTables[table.FullName].FinalRecords;

51
src/Luban.Job.Cfg/Source/Defs/DefTable.cs
View File

@ -33,8 +33,6 @@ namespace Luban.Job.Cfg.Defs
public bool IsOneValueTable => Mode == ETableMode.ONE;
public bool IsTwoKeyMapTable => Mode == ETableMode.BMAP;
public List<string> InputFiles { get; }
private readonly Dictionary<string, List<string>> _branchInputFiles;
@ -49,16 +47,6 @@ namespace Luban.Job.Cfg.Defs
public int IndexFieldIdIndex { get; private set; }
public string Index1 { get; private set; }
public TType KeyTType1 { get; private set; }
public DefField IndexField1 { get; private set; }
public int IndexFieldIdIndex1 { get; private set; }
public string Index2 { get; private set; }
public TType KeyTType2 { get; private set; }
public DefField IndexField2 { get; private set; }
public int IndexFieldIdIndex2 { get; private set; }
public bool NeedExport => Assembly.NeedExport(this.Groups);
public string OutputDataFile => $"{FullName}.bin";
@ -91,7 +79,7 @@ namespace Luban.Job.Cfg.Defs
{
case ETableMode.ONE:
{
KeyTType = KeyTType2 = null;
KeyTType = null;
break;
}
case ETableMode.MAP:
@ -121,43 +109,6 @@ namespace Luban.Job.Cfg.Defs
KeyTType = IndexField.CType;
break;
}
case ETableMode.BMAP:
{
string[] indexs = Index.Split(',').Where(k => !string.IsNullOrWhiteSpace(k)).ToArray();
if (indexs.Length != 2)
{
throw new Exception($"table:{FullName}是双键表,index 必须指定两个key");
}
{
Index1 = indexs[0];
if (ValueTType.GetBeanAs<DefBean>().TryGetField(Index1, out var f, out var i))
{
IndexField1 = f;
KeyTType = KeyTType1 = IndexField1.CType;
IndexFieldIdIndex1 = i;
}
else
{
throw new Exception($"table:{FullName} index:{Index} 字段不存在");
}
}
{
Index2 = indexs[1];
if (ValueTType.Bean.TryGetField(Index2, out var f, out var i))
{
IndexField2 = (DefField)f;
KeyTType2 = IndexField2.CType;
IndexFieldIdIndex2 = i;
}
else
{
throw new Exception($"table:{FullName} index:{indexs[1]} 字段不存在");
}
}
break;
}
default: throw new Exception($"unknown mode:{Mode}");
}
}

41
src/Luban.Job.Cfg/Source/Generate/CppBinCodeRender.cs
View File

@ -104,46 +104,7 @@ class {{name}} : public {{if parent_def_type}} {{parent_def_type.cpp_full_name}}
class {{name}}
{
{{~ if x.is_two_key_map_table ~}}
private:
std::unordered_map<{{cpp_define_type key_type1}}, std::vector<{{cpp_define_type value_type}}>> _dataListMap;
std::unordered_map<{{cpp_define_type key_type1}}, std::unordered_map<{{cpp_define_type key_type2}}, {{cpp_define_type value_type}}>> _dataMapMap;
std::vector<{{cpp_define_type value_type}}> _dataList;
public:
bool load(ByteBuf& _buf)
{
int n;
if (!_buf.readSize(n)) return false;
for(; n > 0 ; --n)
{
{{cpp_define_type value_type}} _v;
{{cpp_deserialize '_buf' '_v' value_type}}
_dataList.push_back(_v);
auto _key = _v->{{x.index_field1.cpp_style_name}};
auto& list = _dataListMap[_key];
list.push_back(_v);
auto& map = _dataMapMap[_key];
map[_v->{{x.index_field2.cpp_style_name}}] = _v;
}
return true;
}
const std::unordered_map<{{cpp_define_type key_type1}},std::vector<{{cpp_define_type value_type}}>>& getDataListMap() const { return _dataListMap; }
const std::unordered_map<{{cpp_define_type key_type1}}, std::unordered_map<{{cpp_define_type key_type2}}, {{cpp_define_type value_type}}>>& getDataMapMap() const {return _dataMapMap;}
const std::vector<{{cpp_define_type value_type}}>& getDataList() const { return _dataList; }
const {{cpp_define_type value_type}} get({{cpp_define_type key_type1}} key1, {{cpp_define_type key_type2}} key2) const
{
auto it1 = _dataMapMap.find(key1);
if (it1 == _dataMapMap.end()) { return nullptr; }
auto it2 = it1->second.find(key2);
return it2 != it1->second.end() ? it2->second : nullptr;
}
{{~else if x.is_map_table ~}}
{{~if x.is_map_table ~}}
private:
std::unordered_map<{{cpp_define_type key_type}}, {{cpp_define_type value_type}}> _dataMap;
std::vector<{{cpp_define_type value_type}}> _dataList;

53
src/Luban.Job.Cfg/Source/Generate/CsBinCodeRender.cs
View File

@ -137,58 +137,7 @@ namespace {{x.namespace_with_top_module}}
}}
public sealed partial class {{name}}
{
{{~ if x.is_two_key_map_table ~}}
private readonly Dictionary<{{cs_define_type key_type1}}, List<{{cs_define_type value_type}}>> _dataListMap;
private readonly Dictionary<{{cs_define_type key_type1}}, Dictionary<{{cs_define_type key_type2}}, {{cs_define_type value_type}}>> _dataMapMap;
private readonly List<{{cs_define_type value_type}}> _dataList;
public {{name}}(ByteBuf _buf)
{
_dataListMap = new Dictionary<{{cs_define_type key_type1}}, List<{{cs_define_type value_type}}>>();
_dataMapMap = new Dictionary<{{cs_define_type key_type1}}, Dictionary<{{cs_define_type key_type2}}, {{cs_define_type value_type}}>>();
_dataList = new List<{{cs_define_type value_type}}>();
for(int n = _buf.ReadSize() ; n > 0 ; --n)
{
{{cs_define_type value_type}} _v;
{{cs_deserialize '_buf' '_v' value_type}}
_dataList.Add(_v);
var _key = _v.{{x.index_field1.cs_style_name}};
if (!_dataListMap.TryGetValue(_key, out var list))
{
list = new List<{{cs_define_type value_type}}>();
_dataListMap.Add(_key, list);
}
list.Add(_v);
if (!_dataMapMap.TryGetValue(_key, out var map))
{
map = new Dictionary<{{cs_define_type key_type2}}, {{cs_define_type value_type}}>();
_dataMapMap.Add(_key, map);
}
map.Add(_v.{{x.index_field2.cs_style_name}}, _v);
}
}
public Dictionary<{{cs_define_type key_type1}}, List<{{cs_define_type value_type}}>> DataListMap => _dataListMap;
public Dictionary<{{cs_define_type key_type1}}, Dictionary<{{cs_define_type key_type2}}, {{cs_define_type value_type}}>> DataMapMap => _dataMapMap;
public List<{{cs_define_type value_type}}> DataList => _dataList;
{{if value_type.is_dynamic}}
public T GetOrDefaultAs<T>({{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2) where T : {{cs_define_type value_type}} => _dataMapMap.TryGetValue(key1, out var m) && m.TryGetValue(key2, out var v) ? (T)v : null;
public T GetAs<T>({{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2) where T : {{cs_define_type value_type}} => (T)_dataMapMap[key1][key2];
{{end}}
public {{cs_define_type value_type}} GetOrDefault({{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2) => _dataMapMap.TryGetValue(key1, out var m) && m.TryGetValue(key2, out var v) ? v : null;
public {{cs_define_type value_type}} Get({{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2) => _dataMapMap[key1][key2];
public {{cs_define_type value_type}} this[{{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2] => _dataMapMap[key1][key2];
public void Resolve(Dictionary<string, object> _tables)
{
foreach(var v in _dataList)
{
v.Resolve(_tables);
}
OnResolveFinish(_tables);
}
{{~else if x.is_map_table ~}}
{{~if x.is_map_table ~}}
private readonly Dictionary<{{cs_define_type key_type}}, {{cs_define_type value_type}}> _dataMap;
private readonly List<{{cs_define_type value_type}}> _dataList;

52
src/Luban.Job.Cfg/Source/Generate/CsJsonCodeRender.cs
View File

@ -133,57 +133,7 @@ namespace {{x.namespace_with_top_module}}
{
public sealed partial class {{name}}
{
{{~ if x.is_two_key_map_table ~}}
private readonly Dictionary<{{cs_define_type key_type1}}, List<{{cs_define_type value_type}}>> _dataListMap;
private readonly Dictionary<{{cs_define_type key_type1}}, Dictionary<{{cs_define_type key_type2}}, {{cs_define_type value_type}}>> _dataMapMap;
private readonly List<{{cs_define_type value_type}}> _dataList;
public {{name}}(JsonElement _buf)
{
_dataListMap = new Dictionary<{{cs_define_type key_type1}}, List<{{cs_define_type value_type}}>>();
_dataMapMap = new Dictionary<{{cs_define_type key_type1}}, Dictionary<{{cs_define_type key_type2}}, {{cs_define_type value_type}}>>();
_dataList = new List<{{cs_define_type value_type}}>();
foreach(JsonElement _row in _buf.EnumerateArray())
{
var _v = {{cs_define_type value_type}}.Deserialize{{value_type.bean.name}}(_row);
_dataList.Add(_v);
var _key = _v.{{x.index_field1.cs_style_name}};
if (!_dataListMap.TryGetValue(_key, out var list))
{
list = new List<{{cs_define_type value_type}}>();
_dataListMap.Add(_key, list);
}
list.Add(_v);
if (!_dataMapMap.TryGetValue(_key, out var map))
{
map = new Dictionary<{{cs_define_type key_type2}}, {{cs_define_type value_type}}>();
_dataMapMap.Add(_key, map);
}
map.Add(_v.{{x.index_field2.cs_style_name}}, _v);
}
}
public Dictionary<{{cs_define_type key_type1}}, List<{{cs_define_type value_type}}>> DataListMap => _dataListMap;
public Dictionary<{{cs_define_type key_type1}}, Dictionary<{{cs_define_type key_type2}}, {{cs_define_type value_type}}>> DataMapMap => _dataMapMap;
public List<{{cs_define_type value_type}}> DataList => _dataList;
{{if value_type.is_dynamic}}
public T GetOrDefaultAs<T>({{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2) where T : {{cs_define_type value_type}} => _dataMapMap.TryGetValue(key1, out var m) && m.TryGetValue(key2, out var v) ? (T)v : null;
public T GetAs<T>({{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2) where T : {{cs_define_type value_type}} => (T)_dataMapMap[key1][key2];
{{end}}
public {{cs_define_type value_type}} GetOrDefault({{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2) => _dataMapMap.TryGetValue(key1, out var m) && m.TryGetValue(key2, out var v) ? v : null;
public {{cs_define_type value_type}} Get({{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2) => _dataMapMap[key1][key2];
public {{cs_define_type value_type}} this[{{cs_define_type key_type1}} key1, {{cs_define_type key_type2}} key2] => _dataMapMap[key1][key2];
public void Resolve(Dictionary<string, object> _tables)
{
foreach(var v in _dataList)
{
v.Resolve(_tables);
}
OnResolveFinish(_tables);
}
{{~else if x.is_map_table ~}}
{{~if x.is_map_table ~}}
private readonly Dictionary<{{cs_define_type key_type}}, {{cs_define_type value_type}}> _dataMap;
private readonly List<{{cs_define_type value_type}}> _dataList;

65
src/Luban.Job.Cfg/Source/Generate/GoCodeRender.cs
View File

@ -153,70 +153,7 @@ package {{package}}
import ""bright/serialization""
{{if x.is_two_key_map_table}}
type {{go_full_name}} struct {
_dataListMap map[{{go_define_type key_type1}}][]{{go_define_type value_type}}
_dataMapMap map[{{go_define_type key_type1}}]map[{{go_define_type key_type2}}]{{go_define_type value_type}}
_dataList []{{go_define_type value_type}}
}
func New{{go_full_name}}(_buf *serialization.ByteBuf) (*{{go_full_name}}, error) {
if size, err := _buf.ReadSize() ; err != nil {
return nil, err
} else {
_dataList := make([]{{go_define_type value_type}}, 0, size)
_dataListMap := make(map[{{go_define_type key_type1}}][]{{go_define_type value_type}})
_dataMapMap := make(map[{{go_define_type key_type1}}]map[{{go_define_type key_type2}}]{{go_define_type value_type}})
for i := 0 ; i < size ; i++ {
if _v, err2 := {{go_deserialize_type value_type '_buf'}}; err2 != nil {
return nil, err2
} else {
_dataList = append(_dataList, _v)
_dataMap := _dataMapMap[_v.{{index_field1.cs_style_name}}]
if _dataMap == nil {
_dataMap = make(map[{{go_define_type key_type2}}]{{go_define_type value_type}})
_dataMapMap[_v.{{index_field1.cs_style_name}}] = _dataMap
}
_dataMap[_v.{{index_field2.cs_style_name}}] = _v
_dataList := _dataListMap[_v.{{index_field1.cs_style_name}}]
if _dataList == nil {
_dataList = make([]{{go_define_type value_type}}, 0)
}
_dataList = append(_dataList, _v)
_dataListMap[_v.{{index_field1.cs_style_name}}] = _dataList
}
}
return &{{go_full_name}}{_dataList:_dataList, _dataMapMap:_dataMapMap, _dataListMap:_dataListMap}, nil
}
}
func (table *{{go_full_name}}) GetDataMapMap() map[{{go_define_type key_type1}}]map[{{go_define_type key_type2}}]{{go_define_type value_type}} {
return table._dataMapMap
}
func (table *{{go_full_name}}) GetDataListMap() map[{{go_define_type key_type1}}][]{{go_define_type value_type}} {
return table._dataListMap
}
func (table *{{go_full_name}}) GetDataList() []{{go_define_type value_type}} {
return table._dataList
}
func (table *{{go_full_name}}) Get(key1 {{go_define_type key_type1}}, key2 {{go_define_type key_type2}}) {{go_define_type value_type}} {
if v , ok := table._dataMapMap[key1] ; ok {
return v[key2]
} else {
return nil
}
}
{{else if x.is_map_table }}
{{~if x.is_map_table~}}
type {{go_full_name}} struct {
_dataMap map[{{go_define_type key_type}}]{{go_define_type value_type}}
_dataList []{{go_define_type value_type}}

43
src/Luban.Job.Cfg/Source/Generate/JavaBinCodeRender.cs
View File

@ -163,48 +163,7 @@ import bright.serialization.*;
public final class {{name}}
{
{{~ if x.is_two_key_map_table ~}}
private final java.util.HashMap<{{java_box_define_type key_type1}},java.util.ArrayList<{{java_box_define_type value_type}}>> _dataListMap;
private final java.util.HashMap<{{java_box_define_type key_type1}}, java.util.HashMap<{{java_box_define_type key_type2}}, {{java_box_define_type value_type}}>> _dataMapMap;
private final java.util.ArrayList<{{java_box_define_type value_type}}> _dataList;
public {{name}}(ByteBuf _buf)
{
_dataListMap = new java.util.HashMap<{{java_box_define_type key_type1}},java.util.ArrayList<{{java_box_define_type value_type}}>>();
_dataMapMap = new java.util.HashMap<{{java_box_define_type key_type1}}, java.util.HashMap<{{java_box_define_type key_type2}}, {{java_box_define_type value_type}}>>();
_dataList = new java.util.ArrayList<{{java_box_define_type value_type}}>();
for(int n = _buf.readSize() ; n > 0 ; --n)
{
{{java_box_define_type value_type}} _v;
{{java_deserialize '_buf' '_v' value_type}}
_dataList.add(_v);
var _key = _v.{{x.index_field1.java_style_name}};
var list = _dataListMap.computeIfAbsent(_key, k -> new java.util.ArrayList<>());
list.add(_v);
var map = _dataMapMap.computeIfAbsent(_key, k -> new java.util.HashMap<>());
map.put(_v.{{x.index_field2.java_style_name}}, _v);
}
}
public java.util.HashMap<{{java_box_define_type key_type1}},java.util.ArrayList<{{java_box_define_type value_type}}>> getDataListMap() { return _dataListMap; }
public java.util.HashMap<{{java_box_define_type key_type1}}, java.util.HashMap<{{java_box_define_type key_type2}}, {{java_box_define_type value_type}}>> getDataMapMap() {return _dataMapMap;}
public java.util.ArrayList<{{java_box_define_type value_type}}> getDataList() { return _dataList; }
{{if value_type.is_dynamic}}
@SuppressWarnings(""unchecked"")
public <T extends {{java_box_define_type value_type}}> T getAs({{java_define_type key_type1}} key1, {{java_define_type key_type2}} key2) { return (T)_dataMapMap.get(key1).get(key2); }
{{end}}
public {{java_box_define_type value_type}} get({{java_define_type key_type1}} key1, {{java_define_type key_type2}} key2) { return _dataMapMap.get(key1).get(key2);}
public void resolve(java.util.HashMap<String, Object> _tables)
{
for({{java_box_define_type value_type}} v : _dataList)
{
v.resolve(_tables);
}
}
{{~else if x.is_map_table ~}}
{{~if x.is_map_table ~}}
private final java.util.HashMap<{{java_box_define_type key_type}}, {{java_box_define_type value_type}}> _dataMap;
private final java.util.ArrayList<{{java_box_define_type value_type}}> _dataList;

8
src/Luban.Job.Cfg/Source/Generate/LuaRender.cs
View File

@ -172,9 +172,7 @@ local function InitTypes(methods)
local tables =
{
{{~for table in tables ~}}
{{~if table.is_two_key_map_table~}}
{ name='{{table.name}}', file='{{table.output_data_file}}', mode='bmap', index1='{{table.index1}}', index2='{{table.index2}}', value_type='{{table.value_ttype.bean.full_name}}' },
{{~else if table.is_map_table ~}}
{{~if table.is_map_table ~}}
{ name='{{table.name}}', file='{{table.output_data_file}}', mode='map', index='{{table.index}}', value_type='{{table.value_ttype.bean.full_name}}' },
{{~else~}}
{ name='{{table.name}}', file='{{table.output_data_file}}', mode='one', value_type='{{table.value_ttype.bean.full_name}}'},
@ -245,9 +243,7 @@ beans['{{bean.full_name}}'] =
local tables =
{
{{~for table in tables ~}}
{{~if table.is_two_key_map_table~}}
{ name='{{table.name}}', file='{{table.output_data_file}}', mode='bmap', index1='{{table.index1}}', index2='{{table.index2}}', value_type='{{table.value_ttype.bean.full_name}}' },
{{~else if table.is_map_table ~}}
{{~if table.is_map_table ~}}
{ name='{{table.name}}', file='{{table.output_data_file}}', mode='map', index='{{table.index}}', value_type='{{table.value_ttype.bean.full_name}}' },
{{~else~}}
{ name='{{table.name}}', file='{{table.output_data_file}}', mode='one', value_type='{{table.value_ttype.bean.full_name}}'},

32
src/Luban.Job.Cfg/Source/Generate/Python27JsonCodeRender.cs
View File

@ -125,37 +125,7 @@ class {{name}} {{if parent_def_type}}({{parent_def_type.py_full_name}}){{end}}:
}}
class {{name}}:
{{~ if x.is_two_key_map_table ~}}
def __init__(self, _json_):
self._dataListMap = {}
self._dataMapMap = {}
self._dataList = []
for _json2_ in _json_:
{{py27_deserialize '_v' '_json2_' value_type}}
self._dataList.append(_v)
_key = _v.{{x.index_field1.py_style_name}}
list = self._dataListMap.get(_key)
if not list:
list = []
self._dataListMap[_key] = list
list.append(_v)
map = self._dataMapMap.get(_key)
if not map:
map = {}
self._dataMapMap[_key] = map
map[_v.{{x.index_field2.py_style_name}}] = _v
def getDataListMap(self) : return self._dataListMap
def getDataMapMap(self) : return self._dataMapMap
def getDataList(self) : return self._dataList
def get(self, key1, key2) :
m1 = self._dataMapMap.get(key1)
return m1.get(key2) if m1 else None
{{~else if x.is_map_table ~}}
{{~if x.is_map_table ~}}
def __init__(self, _json_ ):
self._dataMap = {}

32
src/Luban.Job.Cfg/Source/Generate/Python3JsonCodeRender.cs
View File

@ -125,37 +125,7 @@ class {{name}} {{if parent_def_type}}({{parent_def_type.py_full_name}}){{else if
}}
class {{name}}:
{{~ if x.is_two_key_map_table ~}}
def __init__(self, _json_):
self._dataListMap = {}
self._dataMapMap = {}
self._dataList = []
for _json2_ in _json_:
{{py3_deserialize '_v' '_json2_' value_type}}
self._dataList.append(_v)
_key = _v.{{x.index_field1.py_style_name}}
list = self._dataListMap.get(_key)
if not list:
list = []
self._dataListMap[_key] = list
list.append(_v)
map = self._dataMapMap.get(_key)
if not map:
map = {}
self._dataMapMap[_key] = map
map[_v.{{x.index_field2.py_style_name}}] = _v
def getDataListMap(self) : return self._dataListMap
def getDataMapMap(self) : return self._dataMapMap
def getDataList(self) : return self._dataList
def get(self, key1, key2) :
m1 = self._dataMapMap.get(key1)
return m1.get(key2) if m1 else None
{{~else if x.is_map_table ~}}
{{~if x.is_map_table ~}}
def __init__(self, _json_ ):
self._dataMap = {}

44
src/Luban.Job.Cfg/Source/Generate/TypeScriptBinCodeRender.cs
View File

@ -99,49 +99,7 @@ export {{if x.is_abstract_type}} abstract {{end}} class {{name}} {{if parent_def
}}
{{x.typescript_namespace_begin}}
export class {{name}}{
{{~ if x.is_two_key_map_table ~}}
private _dataListMap: Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]>
private _dataMapMap: Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>>
private _dataList: {{ts_define_type value_type}}[]
constructor(_buf_: Bright.Serialization.ByteBuf) {
this._dataListMap = new Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]>()
this._dataMapMap = new Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>>()
this._dataList = []
for(let n = _buf_.ReadInt(); n > 0 ; n--) {
let _v: {{ts_define_type value_type}}
{{ts_bin_constructor '_v' '_buf_' value_type}}
this._dataList.push(_v)
var _key = _v.{{x.index_field1.ts_style_name}}
let list: {{ts_define_type value_type}}[] = this._dataListMap.get(_key)
if (list == null) {
list = []
this._dataListMap.set(_key, list)
}
list.push(_v)
let map: Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}> = this._dataMapMap.get(_key)
if (map == null) {
map = new Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>()
this._dataMapMap.set(_key, map)
}
map.set(_v.{{x.index_field2.ts_style_name}}, _v)
}
}
getDataListMap(): Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]> { return this._dataListMap }
getDataMapMap(): Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>> { return this._dataMapMap }
getDataList(): {{ts_define_type value_type}}[] { return this._dataList }
get(key1: {{ts_define_type key_type1}}, key2: {{ts_define_type key_type2}}): {{ts_define_type value_type}} { return this._dataMapMap.get(key1).get(key2) }
resolve(_tables: Map<string, any>) {
for(var v of this._dataList) {
v.resolve(_tables)
}
}
{{~else if x.is_map_table ~}}
{{~if x.is_map_table ~}}
private _dataMap: Map<{{ts_define_type key_type}}, {{ts_define_type value_type}}>
private _dataList: {{ts_define_type value_type}}[]

41
src/Luban.Job.Cfg/Source/Generate/TypeScriptJsonCodeRender.cs
View File

@ -101,46 +101,7 @@ export {{if x.is_abstract_type}} abstract {{end}} class {{name}} {{if parent_def
}}
{{x.typescript_namespace_begin}}
export class {{name}}{
{{~ if x.is_two_key_map_table ~}}
private _dataListMap: Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]>
private _dataMapMap: Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>>
private _dataList: {{ts_define_type value_type}}[]
constructor(_json_: any) {
this._dataListMap = new Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]>()
this._dataMapMap = new Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>>()
this._dataList = []
for(var _json2_ of _json_) {
let _v: {{ts_define_type value_type}}
{{ts_json_constructor '_v' '_json2_' value_type}}
this._dataList.push(_v)
var _key = _v.{{x.index_field1.ts_style_name}}
let list: {{ts_define_type value_type}}[] = this._dataListMap.get(_key)
if (list == null) {
list = []
this._dataListMap.set(_key, list)
}
list.push(_v)
let map: Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}> = this._dataMapMap.get(_key)
if (map == null) {
map = new Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>()
this._dataMapMap.set(_key, map)
}
map.set(_v.{{x.index_field2.ts_style_name}}, _v)
}
}
getDataListMap(): Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]> { return this._dataListMap; }
getDataMapMap(): Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>> { return this._dataMapMap; }
getDataList(): {{ts_define_type value_type}}[] { return this._dataList; }
get(key1: {{ts_define_type key_type1}}, key2: {{ts_define_type key_type2}}): {{ts_define_type value_type}} { return this._dataMapMap.get(key1).get(key2); }
resolve(_tables: Map<string, any>) {
for(var v of this._dataList) {
v.resolve(_tables)
}
}
{{~else if x.is_map_table ~}}
{{~if x.is_map_table ~}}
private _dataMap: Map<{{ts_define_type key_type}}, {{ts_define_type value_type}}>
private _dataList: {{ts_define_type value_type}}[]
constructor(_json_: any) {

1
src/Luban.Job.Cfg/Source/RawDefs/Table.cs
View File

@ -6,7 +6,6 @@ namespace Luban.Job.Cfg.RawDefs
{
ONE,
MAP,
BMAP, //双主键 map
}
public class CfgInputFile

5
src/Luban.Job.Cfg/Source/Utils/DataExporterUtil.cs
View File

@ -57,11 +57,6 @@ namespace Luban.Job.Cfg.Utils
LuaExportor.Ins.ExportTableOneKeyMap(table, records, content);
break;
}
case ETableMode.BMAP:
{
LuaExportor.Ins.ExportTableTwoKeyMap(table, records, content);
break;
}
default:
{
throw new NotSupportedException();

48
src/Luban.Job.Cfg/Source/ValidatorContext.cs
View File

@ -247,54 +247,6 @@ namespace Luban.Job.Cfg
mainRecordMap[key] = r;
}
}
break;
}
case ETableMode.BMAP:
{
var mainTwoKeyMap = new Dictionary<(DType, DType), Record>();
foreach (Record r in mainRecords)
{
DType key1 = r.Data.Fields[table.IndexFieldIdIndex1];
DType key2 = r.Data.Fields[table.IndexFieldIdIndex2];
if (!mainTwoKeyMap.TryAdd((key1, key2), r))
{
throw new Exception($@"配置表 {table.FullName} 主文件 主键字段:{table.Index} 主键值:({key1},{key2})重复.
记录1 来自文件:{r.Source}
记录2 来自文件:{mainTwoKeyMap[(key1, key2)].Source}
");
}
// 目前不支持 双key索引检查,但支持主key索引检查.
// 所以至少塞入一个,让ref检查能通过
mainRecordMap[key1] = r;
}
if (branchRecords != null)
{
var branchTwoKeyMap = new Dictionary<(DType, DType), Record>();
foreach (Record r in branchRecords)
{
DType key1 = r.Data.Fields[table.IndexFieldIdIndex1];
DType key2 = r.Data.Fields[table.IndexFieldIdIndex2];
if (!branchTwoKeyMap.TryAdd((key1, key2), r))
{
throw new Exception($@"配置表 {table.FullName} 分支文件 主键字段:{table.Index} 主键值:({key1},{key2})重复.
记录1 来自文件:{r.Source}
记录2 来自文件:{branchTwoKeyMap[(key1, key2)].Source}
");
}
if (mainTwoKeyMap.TryGetValue((key1, key2), out var old))
{
s_logger.Debug("配置表 {} 分支文件 主键:({},{}) 覆盖 主文件记录", table.FullName, key1, key2);
mainRecords[old.Index] = r;
}
mainTwoKeyMap[(key1, key2)] = r;
// 目前不支持 双key索引检查,但支持主key索引检查.
// 所以至少塞入一个,让ref检查能通过
mainRecordMap[key1] = r;
}
}
break;
}
}