### Example XML Data Structure

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/manual/otherdatasource

Demonstrates a sample XML structure representing various data types such as booleans, integers, floats, strings, nested elements, and collections (lists and key-value pairs). It illustrates how different data structures are serialized into XML.

```XML
<data>
  <x1>true</x1>
  <x2>4</x2>
  <x3>128</x3>
  <x4>1</x4>
  <x5>112233445566</x5>
  <x6>1.3</x6>
  <x7>1112232.43123</x7>
  <x10>yf</x10>
  <x12> <x1>1</x1> </x12>
  <x13>C</x13>
  <x14 type="DemoD2">  <x1>1</x1>  <x2>2</x2> </x14>
  <k1> <item>1</item> <item>2</item> </k1>
  <k2> <item>1</item> <item>2</item> </k2>
  <k8>
      <item> <key>2</key><value>10</value></item>
      <item> <key>3</key><value>30</value></item>
  </k8>
  <k9>
      <item> <y1>1</y1> <y2>true</y2> </item>
      <item> <y1>2</y1> <y2>false</y2> </item>
  </k9>
  <k15>
      <item type="DemoD2"> <x1>1</x1> <x2>2</x2> </item>
  </k15>
</data>
```

--------------------------------

### Example YAML Data Structure

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/manual/otherdatasource

Illustrates a sample YAML structure, highlighting its similarity to JSON and specific features like set, map, and polymorphic bean types using the '$type' attribute. It shows how various data types and complex structures are represented in YAML.

```YAML
x1: true
x2: 3
x3: 128
x4: 40
x5: 11223344
x6: 1.2
x7: 1.23432
x10: hq
x12:
  x1: 10
x13: B
x14:
  $type: DemoD2
  x1: 1
  x2: 2
t1: '1970-01-01 00:00:00'
k1:
- 1
- 2
k2:
- 2
- 3
k8:
- - 2
  - 2
- - 4
  - 10
k9:
- y1: 1
  y2: true
- y1: 2
  y2: false
k15:
- $type: DemoD2
  x1: 1
  x2: 2
```

--------------------------------

### Lite Data Format Examples for Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/manual/otherdatasource

Demonstrates Luban's unique Lite text-based data format, which is more concise than JSON as it omits field names. It shows both single-line and multi-line representations, along with notes on whitespace handling, string escaping, and container/bean syntax.

```lite
{ 1122, false, 2, 128, 112233445566, 1.3, 1122, yf, {1}, D, {DemoD2,1,3}, 1970-01-01 00:00:00, {1,2}, {2,3}, {{2,10},{3,12}}, {{1,true},{2,false}}, {{DemoD2,1,3}}}
```

```lite
{
  1122,
  false,
  2,
  128,
  112233445566,
  1.3,
  1122,
  yf,
  {1},
  D,
  {DemoD2,1,3},
  1970-01-01 00:00:00,
  {1,2},
  {2,3},
  {{2,10},{3,12}},
  {{1,true},{2,false}},
  {{DemoD2,1,3}}
}
```

--------------------------------

### Example Lua Data Source Configuration for Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/datasource

Shows a Lua file structure for Luban data sources. It highlights Lua-specific syntax for tables, including set and map representations, and polymorphic beans using the '_type_' property. Note the 'return' keyword at the beginning, as Lua files are loaded as scripts.

```Lua
return
{
  x1 = false,
  x2 = 2,
  x3 = 128,
  x4 = 1122,
  x5 = 112233445566,
  x6 = 1.3,
  x7 = 1122,
  x10 = "yf",
  t1 = {key="/key/ab1", text="apple"},
  x12 = {x1=1},
  x13 = "D",
  x14 = { _type_="DemoD2", x1 = 1, x2=3},
  v2 = {x= 1,y = 2},
  v3 = {x=0.1, y= 0.2,z=0.3},
  v4 = {x=1,y=2,z=3.5,w=4},
  t1 = "1970-01-01 00:00:00",
  k1 = {1,2},
  k2 = {2,3},
  k8 = {[2]=10,[3]=12},
  k9 = { {y1=1,y2=true}, {y1=10,y2=false} },
  k15 = { { _type_="DemoD2", x1 = 1, x2=3} },
}
```

--------------------------------

### Access and Use Specific Luban Configuration Table in C#

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/beginner/loadinruntime

After loading 'cfg.Tables', this C# example shows how to access a specific configuration table (e.g., 'TbReward') and retrieve an entry by its ID. It then prints the retrieved reward information to the console. Note that field names are automatically converted to C# style (e.g., boo_bar to BooBar).

```C#
cfg.demo.Reward reward = tables.TbReward.Get(1001);
Console.WriteLine("reward:{0}", reward);
```

--------------------------------

### Generate Unity C# JSON Data with Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/manual/commandtools

This Batch script illustrates using Luban to generate C# code and JSON data for a Unity project. It sets up the Luban DLL, configuration root, output directories, and path validation, similar to the binary generation example, but targets JSON output.

```Batch
set WORKSPACE=..\..\n
set GEN_CLIENT=%WORKSPACE%\Tools\Luban\Luban.dll
set CONF_ROOT=%WORKSPACE%\DataTables

dotnet %GEN_CLIENT% ^
    -t all ^
    -c cs-simple-json ^
    -d json  ^^
    --conf %CONF_ROOT%\luban.conf ^
    -x outputCodeDir=Assets/Gen ^
    -x outputDataDir=..\GenerateDatas\json ^
    -x pathValidator.rootDir=D:\workspace2\luban_examples\Projects\Csharp_Unity_bin ^
    -x l10n.textProviderFile=*@D:\workspace2\luban_examples\DataTables\Datas\l10n\texts.json
```

--------------------------------

### YAML Data Format Example for Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/manual/otherdatasource

Illustrates the YAML data structure as used in Luban, highlighting its similarity to JSON and specific features like set, map, and polymorphic bean types. It also notes that both `.yaml` and `.yml` file extensions are recognized.

```yaml
x1: true
x2: 3
x3: 128
x4: 40
x5: 11223344
x6: 1.2
x7: 1.23432
x10: hq
x12:
  x1: 10
x13: B
x14:
  $type: DemoD2
  x1: 1
  x2: 2
t1: '1970-01-01 00:00:00'
k1:
- 1
- 2
k2:
- 2
- 3
k8:
- - 2
  - 2
- - 4
  - 10
k9:
- y1: 1
  y2: true
- y1: 2
  y2: false
k15:
- $type: DemoD2
  x1: 1
  x2: 2
```

--------------------------------

### XML Sub-definition File Structure

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/define

Illustrates the basic structure of an XML sub-definition file, which can contain module, bean, enum, and table definitions. This snippet provides a typical example of how these elements are nested within a module.

```XML
<module name="item">
   <enum name="xxx">

   </enum>

   <bean name="yyyy">

   </bean>

   <table name="Tbzzz" value="xxx" input="abc.xlsx"/>
</module>
```

--------------------------------

### Example YAML Data Source Configuration for Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/datasource

Provides a YAML file structure for Luban data sources. It showcases the YAML syntax for different data types, including scalars, nested objects, and lists, and how polymorphic beans are defined using the '$type' property, similar to JSON.

```YAML
x1: true
x2: 3
x3: 128
x4: 40
x5: 11223344
x6: 1.2
x7: 1.23432
x10: hq
x12:
  x1: 10
x13: B
x14:
  $type: DemoD2
  x1: 1
  x2: 2
s1:
  key: "/key32"
  text: aabbcc22
v2:
  x: 1
  y: 2
v3:
  x: 1.1
  y: 2.2
  z: 3.4
v4:
  x: 10.1
  y: 11.2
  z: 12.3
  w: 13.4
t1: '1970-01-01 00:00:00'
k1:
- 1
- 2
k2:
- 2
- 3
k8:
- - 2
  - 2
- - 4
  - 10
k9:
- y1: 1
  y2: true
- y1: 2
  y2: false
k15:
- $type: DemoD2
  x1: 1
  x2: 2
```

--------------------------------

### XML Data Format Example for Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/manual/otherdatasource

Demonstrates the structure of data in XML format, including various data types like booleans, numbers, strings, nested elements, and collections (lists and maps) as used in Luban configurations.

```xml
<data>
  <x1>true</x1>
  <x2>4</x2>
  <x3>128</x3>
  <x4>1</x4>
  <x5>112233445566</x5>
  <x6>1.3</x6>
  <x7>1112232.43123</x7>
  <x10>yf</x10>
  <x12> <x1>1</x1> </x12>
  <x13>C</x13>
  <x14 type="DemoD2">  <x1>1</x1>  <x2>2</x2> </x14>
  <k1> <item>1</item> <item>2</item> </k1>
  <k2> <item>1</item> <item>2</item> </k2>
  <k8>
      <item> <key>2</key><value>10</value></item>
      <item> <key>3</key><value>30</value></item>
  </k8>
  <k9>
      <item> <y1>1</y1> <y2>true</y2> </item>
      <item> <y1>2</y1> <y2>false</y2> </item>
  </k9>
  <k15>
      <item type="DemoD2"> <x1>1</x1> <x2>2</x2> </item>
  </k15>
</data>
```

--------------------------------

### Example XML Data Source Configuration for Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/datasource

Presents an XML file structure for Luban data sources. It demonstrates how various data types, including primitive types, nested elements, arrays, and polymorphic beans (using the 'type' attribute), are represented in XML for Luban.

```XML
<data>
  <x1>true</x1>
  <x2>4</x2>
  <x3>128</x3>
  <x4>1</x4>
  <x5>112233445566</x5>
  <x6>1.3</x6>
  <x7>1112232.43123</x7>
  <x10>yf</x10>
  <x12> <x1>1</x1> </x12>
  <x13>C</x13>
  <x14 type="DemoD2">  <x1>1</x1>  <x2>2</x2> </x14>
  <v2>1,2</v2>
  <v3>1.2,2.3,3.4</v3>
  <v4>1.2,2.2,3.2,4.3</v4>
  <t1>1970-01-01 00:00:00</t1>
  <k1> <item>1</item> <item>2</item> </k1>
  <k2> <item>1</item> <item>2</item> </k2>
  <k8>
      <item> <key>2</key><value>10</value></item>
      <item> <key>3</key><value>30</value></item>
  </k8>
  <k9>
      <item> <y1>1</y1> <y2>true</y2> </item>
      <item> <y1>2</y1> <y2>false</y2> </item>
  </k9>
  <k15>
      <item type="DemoD2"> <x1>1</x1> <x2>2</x2> </item>
  </k15>
</data>
```

--------------------------------

### XML Enum Definition with Attributes

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/define

Provides examples of defining enumerations in XML, including basic enum members and advanced attributes. It illustrates how to specify enum names, aliases, values, and flags for bitwise operations, along with tags and comments for code generation.

```XML
<enum name="Color">
    <var name="RED" alias="红" value="1"/>
    <var name="GREEN" alias="绿" value="2"/>
   <var name="BLUE" alias="蓝" value="3"/>
</enum>

<enum name="AccessMode" flags="1" tags="key1=value1#key2=value2" comment="访问方式" unique="1">
    <var name="READ" value="1" tags="key1=value1#k2=v2" comment="读"/>
    <var name="WRITE" value="2"/>
    <var name="READ_WRITE" value="READ|WRITE"/>
</enum>
```

```APIDOC
enum Attributes:
  name: string (Required)
    Description: The enumeration name. Its namespace is the full namespace of the current module (including parent modules).
  flags: boolean (Optional)
    Description: Whether it is a bit flag type. Defaults to false. If set to 1 or true, configuration data allows syntax like 'READ|WRITE'.
  tags: string (Optional)
    Description: Tags in "key1=value2#key2=value2#..." format. Primarily used with custom template generation.
  unique: boolean (Optional)
    Description: Whether enum values must be unique. Defaults to true.
  comment: string (Optional)
    Description: Comment for the enum. If non-empty, it will be included in the generated code.

enum.var Attributes:
  name: string (Required)
    Description: The enumeration member name.
  alias: string (Optional)
    Description: An alias for the enum member. Planners can use aliases for convenience.
  value: string (Optional)
    Description: The enum value. If not specified, it defaults to the previous enum item's value + 1. For the first item, it defaults to 0.
  tags: string (Optional)
    Description: Tags for the enum member. Primarily used with custom template generation.
  comment: string (Optional)
    Description: Comment for the enum member. If non-empty, it will be included when generating enum items. If empty and an alias is defined, the alias will be used as the comment.
```

--------------------------------

### Typical XML Definition File Structure

Source: https://luban.doc.code-philosophy.com/docs/intro/manual/defaultschemacollector

This XML snippet illustrates the typical structure of a Luban definition file, showcasing the use of `module`, `enum`, `bean`, `table`, and `refgroup` elements to define data structures, enumerations, and table configurations. It includes examples of nested modules, type mappings, and various attribute usages.

```XML
<module name="item">

<enum name="Quality">
  <var name="WHITE" alias="白"/>
  <var name="RED" alias="红"/>
  <var name="GREEN" alias="绿"/>
</enum>

<bean name="Item">
  <var name="id" type="int"/>
  <var name="count" type="int"/>
</bean>

<bean name="Item2">
  <var name="id" type="int"/>
  <var name="count" type="int"/>
  <var name="desc" type="string"/>
</bean>

<table name="TbItem" value="Item" input="item.xlsx"/>
<table name="TbItem2" value="Item2" input="item2.xlsx"/>

<refgroup name="item.TbItem,item.TbItem2"/>

<enum name="AudioType">
    <var name="UNKNOWN" value="0"/>
    <var name="ACC" value="1"/>
    <var name="AIFF" value="2"/>
    <mapper target="client" codeTarget="cs-bin">
        <option name="type" value="UnityEngine.AudioType"/>
    </mapper>
</enum>
<bean name="vector2" valueType="1" sep=",">
    <var name="x" type="float"/>
    <var name="y" type="float"/>
    <mapper target="client" codeTarget="cs-bin">
        <option name="type" value="UnityEngine.Vector2"/>
        <option name="constructor" value="ExternalTypeUtil.NewVector2"/>
    </mapper>
</bean>

<module name="subModule">
  <bean name="SubModuleType">
    <var name="id" type="int"/>
    <var name="count" type="int"/>
  </bean>
  <table name="TbSubItem" value="SubModuleType" input="submodule.xlsx"/>
</module>

</module>
```

--------------------------------

### XML Bean Definition - Normal Structure

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/define

Defines a standard structure type (bean) in XML, which must contain at least one field. This example shows how to define fields with various attributes such as type, reference to other tables, resource paths, and custom tags.

```XML
<bean name="Item" sep="," parent="">
   <var name="item_id" type="int" ref="item.TbItem"/>
   <var name="num" type="int" group="s"/>
   <var name="icon" type="string" path="unity"/>
   <var name="desc" type="string" tag="a=1#b=2"/>
</bean>
```

```APIDOC
bean Attributes:
  name: string (Required)
    Description: The structure name. Cannot contain namespaces (e.g., 'abc.Item' is not allowed).
  parent: string (Optional)
    Description: The inherited parent class name. Defaults to empty. Can inherit types from other modules, in which case the parent must be specified with its full name.
  sep: string (Optional)
    Description: Specifies that the structure is filled in composite mode from an Excel data source. For example, if 'MyIntVector3' has x, y, z fields, 'sep=","' means the input string will be split by ',' into three integers.

bean.var Attributes:
  name: string (Required)
    Description: The field name. Recommended format is 'xx_yy_zz'. Some names are reserved keywords in certain languages (e.g., 'base', 'end', 'if') and should be avoided to prevent compilation errors.
  type: string (Required)
    Description: The type name of the field. Refer to the 'Type Definition' section for details.
  group: string (Optional)
    Description: The group(s) the field belongs to. Can be multiple, comma-separated. Each value must be one of the groups defined in 'root.xml'. If empty, the field belongs to all groups. Refer to the 'Group Export' section for details.
  ref: string (Optional)
    Description: A table reference. Points to a full table name or a 'refgroup'. Used to validate if this field is a valid ID for a specific table, preventing data entry errors. Refer to the 'processor' section for details.
  path: string (Optional)
    Description: A resource reference. Points to a resource name. Used to validate if this field points to a valid resource, preventing runtime errors. Refer to the 'processor' section for details.
  tag: string (Optional)
    Description: Field tags in 'tag="tag1=xxx#tag2=bb#tag3=ccc"' format. Used to add custom tags to fields, primarily for special handling during custom code generation. Refer to the 'Defining Tags' section for details.
```

--------------------------------

### Example JSON Data Source Configuration for Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/datasource

Illustrates a typical JSON file structure used as a data source for Luban. It demonstrates various data types including booleans, numbers, strings, nested objects, arrays, and polymorphic beans using the '$type' property, as well as specific formats for text and map types.

```JSON
{
  "x1":true,
  "x2":3,
  "x3":128,
  "x4":1,
  "x5":11223344,
  "x6":1.2,
  "x7":1.23432,
  "x10":"hq",
  "t1": {"key":"/key/xx1","text":"apple"},
  "x12": { "x1":10},
  "x13":"B",
  "x14":{"$type": "DemoD2", "x1":1, "x2":2},
  "v2":{"x":1, "y":2},
  "v3":{"x":1.1, "y":2.2, "z":3.4},
  "v4":{"x":10.1, "y":11.2, "z":12.3, "w":13.4},
  "t1":"1970-01-01 00:00:00",
  "k1":[1,2],
  "k2":[2,3],
  "k7":[2,3],
  "k8":[[2,2],[4,10]],
  "k9":[{"y1":1, "y2":true},{"y1":2, "y2":false}],
  "k15":[{"$type": "DemoD2", "x1":1, "x2":2}]
}
```

--------------------------------

### Example Lua Data for DemoType2 Single Record

Source: https://luban.doc.code-philosophy.com/docs/intro/manual/otherdatasource

This Lua snippet shows how to represent a single record of 'DemoType2' data. It illustrates Lua-specific features like the 'return' keyword, set format, map format (supporting non-string keys directly), and polymorphic bean types (using '_type_' property).

```Lua
return
{
  x1 = false,
  x2 = 2,
  x3 = 128,
  x4 = 1122,
  x5 = 112233445566,
  x6 = 1.3,
  x7 = 1122,
  x10 = "yf",
  x12 = {x1=1},
  x13 = "D",
  x14 = { _type_="DemoD2", x1 = 1, x2=3},
  t1 = "1970-01-01 00:00:00",
  k1 = {1,2},
  k2 = {2,3},
  k8 = {[2]=10,[3]=12},
  k9 = { {y1=1,y2=true}, {y1=10,y2=false} },
  k15 = { { _type_="DemoD2", x1 = 1, x2=3} },
}
```

--------------------------------

### Luban Composite File Configuration Example (XML)

Source: https://luban.doc.code-philosophy.com/docs/intro/manual/otherdatasource

Illustrates how to define bean structures and table mappings in XML for Luban's composite file format. This allows reading multiple records or specific fields from a single JSON file, similar to how Excel data sources are handled.

```xml
<bean name="CompositeJsonTable1">
    <var name="id" type="int"/>
    <var name="x" type="string"/>
</bean>
<bean name="CompositeJsonTable2">
    <var name="id" type="int"/>
    <var name="y" type="int"/>
</bean>
<bean name="CompositeJsonTable3">
    <var name="a" type="int"/>
    <var name="b" type="int"/>
</bean>

<table name="TbCompositeJsonTable1" value="CompositeJsonTable1" input="*table1@composite_tables.json,*@composite_tables2.json,one_record.json"/>
<table name="TbCompositeJsonTable2" value="CompositeJsonTable2" input="*table2@composite_tables.json"/>
<table name="TbCompositeJsonTable3" value="CompositeJsonTable3" mode="one" input="table3@composite_tables.json"/>
```

--------------------------------

### Example JSON Data for DemoType2 Single Record

Source: https://luban.doc.code-philosophy.com/docs/intro/manual/otherdatasource

This JSON snippet demonstrates how to represent a single record of 'DemoType2' data. It highlights the specific JSON formats for set, map (using array of key-value pairs), and polymorphic bean types (using '$type' property to specify the concrete type).

```JSON
{
  "x1":true,
  "x2":3,
  "x3":128,
  "x4":1,
  "x5":11223344,
  "x6":1.2,
  "x7":1.23432,
  "x10":"hq",
  "x12": { "x1":10},
  "x13":"B",
  "x14":{"$type": "DemoD2", "x1":1, "x2":2},
  "t1":"1970-01-01 00:00:00",
  "k1":[1,2],
  "k2":[2,3],
  "k7":[2,3],
  "k8":[[2,2],[4,10]],
  "k9":[{"y1":1, "y2":true},{"y1":2, "y2":false}],
  "k15":[{"$type": "DemoD2", "x1":1, "x2":2}]
}
```

--------------------------------

### Luban.Client.dll Command-Line Parameters

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/commandtools

This snippet demonstrates the general command-line syntax for `Luban.Client.dll` and provides a detailed explanation of each parameter, including host, port, job type, log level, cache meta file, watch directories, and help options.

```Shell
dotnet Luban.Client.dll [-h <host>] [-p <port>] [-l <log level>] [-c <cache meta file>] [-w <watch dirs>] [-h ] -j cfg -- <job options>

参数介绍：
-h,--host <host>                可选参数。 luban-server的地址。默认为 127.0.0.1
-p,--port <port>                可选参数。 luban-server的端口。默认为 8899
-j,--job <job>                  必选参数。 生成类型。目前支持的生成类型有: cfg,proto,db。 生成配置请取cfg。
-l,--loglevel <log level>       可选参数。 日志级别。默认为INFO。有效值有: TRACE,DEBUG,INFO,WARN,ERROR,FATAL,OFF
-c,--cachemetafile <meta file>  可选参数。 meta缓存文件名。 默认为 .cache.meta
-w,--watch <dir1;dir2...>       可选参数。 监测目录或者目录列表，以逗号';'分隔。当开启此选项后，生成结束后不会退出程序，而是进入自动生成模式。
                                          监听到目标目录发生变化后，自动重新运行生成。省去改动后手动运行生成脚本的麻烦。
--generateonly                  可选参数。 仅生成。不从服务器下载生成结果。可以用于检查服务器是否能成功生成。
-h,--help                       可选参数。 显示帮助信息
--  <job options>               必选参数。 从此参数起，便是 不同job的特有选项
```

--------------------------------

### Load All Luban Configuration Tables in C#

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/beginner/loadinruntime

This C# snippet demonstrates how to load all configuration tables using a single line of code. It expects a 'gameConfDir' pointing to the output data directory and uses 'JSON.Parse' to read and parse JSON files. This operation is typically performed once during game initialization.

```C#
string gameConfDir = "<outputDataDir>"; // 替换为gen.bat中outputDataDir指向的目录
var tables = new cfg.Tables(file => JSON.Parse(File.ReadAllText($"{gameConfDir}/{file}.json")));
```

--------------------------------

### Luban.Client.dll cfg Job-Specific Options

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/commandtools

This section outlines the specific command-line options available when running `Luban.Client.dll` with the `cfg` job type. It covers essential parameters like define file, input/output directories, various `gen_types` for code and data generation, validation, data export settings, custom templates, naming conventions, localization parameters, and language-specific configurations for TypeScript, C#, and Go.

```APIDOC
cfg的<job options>介绍：

-d,--define_file <root file>            必选参数。 根定义文件名。
--input_data_dir  <input data dir>      必选参数。 配置数据文件根目录。
--input:convert:dir <dir>               可选参数。 执行json、lua、xlsx之类数据格式转换时，提供的数据源，覆盖table中默认的input参数。
-c,--output_code_dir <output code dir>  可选参数。 生成代码文件的目录。
-s,--service                            必选参数。生成分组目标。一般来说，会定义client,server,editor等好几个目标，不同目标的生成内容不同。

--gen_types <type1,type2,,,>  必选参数。生成任务类型。既可以是生成代码也可以是生成数据或者其他。
                              目前支持的有 code_cs_bin,code_cs_unity_bin,code_cs_dotnet_json,code_cs_unity_json,
                                  code_cs_unity_editor_json,code_lua_bin,code_java_bin,code_go_bin,
                                  code_go_json,code_cpp_bin,code_cpp_ue_editor_json,code_python27_json,
                                  code_python3_json, code_gdscript_json, code_typescript_bin,code_typescript_json,code_rust_json,
                                  code_protobuf2,code_protobuf3,code_template,code_flatbuffers,
                                  data_bin,data_bidx,data_lua,data_json,data_json_monolithic,data_bson,data_yaml,
                                  data_template,data_protobuf_bin,data_protobuf_json,data_flatbuffers_json,
                                  convert_json,convert_lua,convert_xlsx,convert_template

--validate_root_dir <path validate root dir>. 可选参数。 配置path检查的根目录。

--output_data_dir <output data dir>     可选参数。 导出的数据文件的目录。只生成代码时可不指定。

--output:data:compact_json                   可选参数。默认导出的json格式为对齐后的优雅格式，使用此参数后导出紧凑的不带空格和换行的格式。
--output:data:file_extension  <output data file extension>     可选参数。 导出数据文件的后缀。默认按照生成类型自动选择。
--output:exclude_tags <tag1,tag2>           可选参数。导出时排除包含这些tag的数据
--output:tables <table1,table2...>          可选参数。手动指定导出哪些表。覆盖group中设置
--output:include_tables <table1,table2...>  可选参数。除了group中设置外，额外新增表。
--output:exclude_tables <table1,table2...>  可选参数。排除group中指定的表。

--output:convert:file_extension <extension> 可选参数。 convert数据文件的后缀。默认按照模板名猜测。

--template:code:dir <dir name>              可选参数。自定义额外代码模板的目录名
--template:data:file  <template name>       可选参数。数据模板的名称（不包含后缀），当gen_types包含 data_template时必须指定。
--template:convert:file <template name>     可选参数。convert模板的名称（不包含后缀），当gen_types包含convert_template时必须指定。

--naming_convention:module <convention>     可选参数。生成代码中模板名的命名约定，可用值为 language_recommend,none,camelCase,PascalCase,under_scores。 默认为language_recommend，即选择与相应语言推荐的命名约定风格。 此选项目前未生效。
--naming_convention:bean_member <convention> 可选参数。生成代码中bean类型字段名的命名约定，可用值为 language_recommend,none,camelCase,PascalCase,under_scores。 默认为language_recommend。
--naming_convention:enum_member <convention> 可选参数。生成代码中enum类型名的命名约定，可用值为 language_recommend,none,camelCase,PascalCase,under_scores。 默认为language_recommend。此选项目前未生效。
--access_bean_member <access mode>  可选参数。 bean属性的访问方式。可用值为language_recommend,variable,getter_setter,property。默认为 language_recommend。此字段目前未生效。

--l10n:timezone <timezone>           可选参数。 指定所在时区。影响datetime类型转换为utc时间。 默认为中国北京时间。
--l10n:input_text_files <file1,file2..> 可选参数。 本地化的文本映射表。可以有多个。
--l10n:text_field_name <field name>     可选参数。 文本映射表中，目标映射列的列名，默认为text
--l10n:output_not_translated_text_file <file> 可选参数。 未被本地化映射的text key和value的输出文件。不提供该参数则不生成
--l10n:patch <patch name>                  可选参数。当前需要生成的分支名称。
--l10n:patch_input_data_dir <patch data root dir> 可选参数。分支数据的根目录。

--typescript:bright_require_path <path>    可选参数。生成typescript代码引用的bright模块的路径
--typescript:bright_package_name <packet>  可选参数。生成typescript代码以包形式引用bright库的路径
--typescript:use_puerts_bytebuf            可选参数。生成typescript代码中使用puerts中导入的c# Bytebuf类。
--cs:use_unity_vector                      可选参数。生成c#代码中，使用UnityEngine.Vector{2,3,4}作为Vector数据类型。
--go:bright_module_name <module path>      可选参数。生成go代码时，bright module的import目录。

--external:selectors  <selector1,selector2 ...>       可选参数。 外部类选择器，可以多个。selector必须是root.xml中externalselector中定义的选择器之一。
```

--------------------------------

### Generate DotNet C# Binaries with Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/manual/commandtools

This Batch script demonstrates generating C# code and binary data for a standard DotNet project using Luban. It configures the workspace, Luban DLL, configuration, and output paths, including localization settings, for a non-Unity C# environment.

```Batch
set WORKSPACE=..\..\n
set LUBAN_DLL=%WORKSPACE%\Tools\Luban\Luban.dll
set CONF_ROOT=%WORKSPACE%\DataTables

dotnet %LUBAN_DLL% ^
    -t all ^
    -c cs-bin ^
    -d bin  ^^
    --conf %CONF_ROOT%\luban.conf ^
    -x outputCodeDir=Gen ^
    -x outputDataDir=..\GenerateDatas\bytes ^
    -x pathValidator.rootDir=%WORKSPACE%\Projects\Csharp_Unity_bin ^
    -x l10n.textProviderFile=*@%WORKSPACE%\DataTables\Datas\l10n\texts.json
```

--------------------------------

### Generate Unity C# Binaries with Luban

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/manual/commandtools

This Batch script demonstrates how to use Luban to generate C# code and binary data for a Unity project. It configures output directories for generated assets, sets up path validation for source files, and specifies localization text provider files.

```Batch
set WORKSPACE=..\..\n\nset LUBAN_DLL=%WORKSPACE%\Tools\Luban\Luban.dll
set CONF_ROOT=%WORKSPACE%\DataTables

dotnet %LUBAN_DLL% ^
    -t all ^
    -c cs-bin ^
    -d bin  ^^
    --conf %CONF_ROOT%\luban.conf ^
    -x outputCodeDir=Assets/Gen ^
    -x outputDataDir=..\GenerateDatas\bytes ^
    -x pathValidator.rootDir=%WORKSPACE%\Projects\Csharp_Unity_bin ^
    -x l10n.textProviderFile=*@%WORKSPACE%\DataTables\Datas\l10n\texts.json
```

--------------------------------

### Luban Supported Code Targets and File Formats

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/manual/commandtools

This section lists the various programming languages and their corresponding file formats (e.g., bin, JSON, Protobuf) that Luban can generate code for, enabling data reading. It includes notes on specific library usage (SimpleJSON, System.Text.Json, Newtonsoft.Json, Gson) and special cases like editor-specific targets or schema generation (Protobuf, Flatbuffers).

```APIDOC
Code Target:
  cs-bin: C#, reads bin format files
  cs-simple-json: C#, reads JSON files using SimpleJSON, recommended for Unity clients
  cs-dotnet-json: C#, reads JSON files using System.Text.Json library, recommended for .NET Core servers
  cs-newtonsoft-json: C#, reads JSON files using Newtonsoft.Json library
  cs-editor-json: C#, reads and saves records as a single JSON file, suitable for custom editors to save and load raw configuration files
  cs-protobuf2: Generates code to load all protobuf bin and JSON format data, only includes Tables class
  cs-protobuf3: Generates code to load all protobuf bin and JSON format data, only includes Tables class
  lua-lua: Lua, reads Lua format files
  lua-bin: Lua, reads bin format files
  java-bin: Java, reads bin format files
  java-json: Java, reads JSON format files using Gson library
  cpp-bin: C++, reads bin format files. Removed since v2.3.0
  cpp-sharedptr-bin: C++, uses smart pointers to save dynamically allocated objects, reads bin format files
  cpp-rawptr-bin: C++, uses raw pointers to save dynamically allocated objects, reads bin format files
  go-bin: Go, reads bin format files
  go-json: Go, reads JSON format files
  python-json: Python, reads JSON format files
  gdscript-json: GDScript, reads JSON format files. Note: If you are developing in C#, it is recommended to use the more efficient cs-bin format.
  typescript-bin: TypeScript, reads bin format files
  typescript-json: TypeScript, reads JSON format files
  typescript-protobuf: TypeScript, generates code to read protobuf format data, only includes Tables class
  rust-bin: Generates Rust code, reads bin format files
  rust-json: Generates Rust code, reads JSON format files
  php-json: PHP, reads JSON format files
  dart-json: Generates Dart code, reads JSON format files
  protobuf2: Generates proto2 syntax schema files
  protobuf3: Generates proto3 syntax schema files
  flatbuffers: Generates flatbuffers schema files
```

--------------------------------

### Luban Supported Data Targets and Export Formats

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/manual/commandtools

This section details the various data formats (e.g., Luban binary, JSON, Lua, XML, YAML, BSON, MsgPack, Protobuf binary/JSON, Flatbuffers JSON, text-list) that Luban can export data into. It highlights the efficiency of the 'bin' format for release and notes on lazy loading.

```APIDOC
Data Target:
  bin: Luban's unique binary format, compact and efficient, recommended for official release
  bin-offset: Records the index position of each record in data files exported in bin format, can be used for record-level lazy loading
  json: JSON format, maps output as [[key, value]] format
  json2: Similar to JSON format, but maps output as {"key":"value"} format
  lua: Lua format
  xml: XML format
  yml: YAML format
  bson: BSON format
  msgpack: MsgPack binary format
  protobuf2-bin: Protobuf2 binary format
  protobuf3-bin: Protobuf3 binary format
  protobuf2-json: Protobuf2 supported JSON format
  protobuf3-json: Protobuf3 and later supported JSON format
  flatbuffers-json: Flatbuffers supported JSON format
  text-list: Outputs all text keys appearing in the configuration, sorted in ascending order
```

--------------------------------

### XML Table Definition

Source: https://luban.doc.code-philosophy.com/docs/intro/1.x/manual/define

Shows how to define a table in XML, specifying its name, the structure type of its records, and whether its definition is external. It also covers different table modes (map, list, singleton), input data sources, and grouping for export.

```XML
<table name="TbTableName" value="value_type" define_from_file="0" mode="map" input="file
```

--------------------------------

### Luban Configuration for Composite Data Files

Source: https://luban.doc.code-philosophy.com/docs/intro/3.x/manual/otherdatasource

Defines 'bean' structures and 'table' configurations for reading data from composite JSON files. It demonstrates how to specify input files to read single records, lists of records ('*@'), or specific fields ('field@') as records/record lists ('*field@') from JSON files, including handling multiple sources for a single table.

```XML Configuration
<bean name="CompositeJsonTable1">
    <var name="id" type="int"/>
    <var name="x" type="string"/>
</bean>
<bean name="CompositeJsonTable2">
    <var name="id" type="int"/>
    <var name="y" type="int"/>
</bean>
<bean name="CompositeJsonTable3">
    <var name="a" type="int"/>
    <var name="b" type="int"/>
</bean>

<table name="TbCompositeJsonTable1" value="CompositeJsonTable1" input="*table1@composite_tables.json,*@composite_tables2.json,one_record.json"/>
<table name="TbCompositeJsonTable2" value="CompositeJsonTable2" input="*table2@composite_tables.json"/>
<table name="TbCompositeJsonTable3" value="CompositeJsonTable3" mode="one" input="table3@composite_tables.json"/>
```