Luban

https://luban.doc.code-philosophy.com/docs/basic
Admin
Luban is a powerful configuration tool designed for game projects. It features a complete type...
Tokens:22,392
Snippets:100
Trust Score:6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Generate Unity C# Binaries with Luban

Source: https://luban.doc.code-philosophy.com/docs/basic/manual/commandtools

Example command to generate C# code and binary data for a Unity project using the Luban tool. This script configures workspace paths, output directories for generated code and data, and localization settings.

```Batch
set WORKSPACE=..\..

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=Assets/Gen ^
    -x outputDataDir=..\GenerateDatas\bytes ^
    -x pathValidator.rootDir=%WORKSPACE%\Projects\Csharp_Unity_bin ^
    -x l10n.textProviderFile=*@%WORKSPACE%\DataTables\Datas\l10n\texts.json
```

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

### Generate DotNet C# Binaries with Luban

Source: https://luban.doc.code-philosophy.com/docs/basic/manual/commandtools

Example command to generate C# code and binary data for a .NET project using the Luban tool. This script configures workspace paths, output directories for generated code and data, and localization settings for a .NET environment.

```Batch
set WORKSPACE=..\..

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# JSON with Luban

Source: https://luban.doc.code-philosophy.com/docs/basic/manual/commandtools

Example command to generate C# code and JSON data for a Unity project using the Luban tool. This script sets up workspace paths, output directories for generated code and JSON data, and localization settings.

```Batch
set WORKSPACE=..\..

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
```

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

### Generate Unity C# Binaries with Luban

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

Example command to generate C# code and binary data for a Unity project using Luban. It configures output directories, a path validator, and localization settings.

```Batch
set WORKSPACE=..\..

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=Assets/Gen ^
    -x outputDataDir=..\GenerateDatas\bytes ^
    -x pathValidator.rootDir=%WORKSPACE%\Projects\Csharp_Unity_bin ^
    -x l10n.textProviderFile=*@%WORKSPACE%\DataTables\Datas\l10n\texts.json
```

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

### Generate DotNet C# Binaries with Luban

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

Example command to generate C# code and binary data for a .NET project using Luban. It sets up output directories, a path validator, and localization for .NET specific generation.

```Batch
set WORKSPACE=..\..

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
```

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

### Luban Lite Data Format Examples

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

Explains the proprietary Lite text-based data format unique to Luban, emphasizing its conciseness due to the absence of field names. Provides examples for various data types and notes on parsing rules like whitespace trimming and string escaping.

```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}}
}
```

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

### Lua Data Source Example Configuration

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

This Lua snippet demonstrates a data file structure for Luban, showing how data is returned as a Lua table. It includes examples of various data types like booleans, numbers, strings, nested tables, polymorphic beans (using '_type_'), sets, and maps (tables with arbitrary keys).

```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} },
}
```

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

### XML Data Source Example Configuration

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

This XML snippet provides an example of a data file loaded by Luban. It illustrates the representation of various data types such as booleans, numbers, strings, nested elements, polymorphic beans (using 'type' attribute), and collections (items within tags).

```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>
```

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

### Generate Unity C# JSON with Luban

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

Example command to generate C# code and JSON data for a Unity project using Luban. It specifies output directories, a path validator, and localization settings for JSON output.

```Batch
set WORKSPACE=..\..

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
```

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

### Luban Single Record Data Example in Lua Format

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

This Lua example illustrates how to represent a single record for `DemoType2`. It highlights Lua-specific conventions such as the `return` keyword, table syntax for sets and maps, and the `_type_` property for polymorphic bean types, contrasting with JSON's map key limitations.

```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} }
}
```

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

### Generate Protobuf3 Data (Binary and JSON)

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

This section outlines the command-line options for generating Protobuf3 data in both binary and JSON formats. Use `--gen_types code_protobuf3,data_protobuf_bin` for binary output and `--gen_types code_protobuf3,data_protobuf_json` for JSON output.

```Shell
--gen_types code_protobuf3,data_protobuf_bin
--gen_types code_protobuf3,data_protobuf_json
```

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

### Generate Code Only or Data Only

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

This section explains how to generate only code or only data using specific command-line arguments. For example, `--gen_types code_cs_unity_json` generates only C# code for Unity JSON, while `--gen_types data_json` generates only JSON data.

```Shell
--gen_types code_cs_unity_json
```

```Shell
--gen_types data_json
```

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

### Luban Single Record Data Example in JSON Format

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

This JSON example demonstrates how to represent a single record for `DemoType2`. It shows specific JSON formatting for Luban, including arrays for set types, arrays of key-value pairs for map types, and the use of the `$type` property for polymorphic bean types.

```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}]
}
```

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

### Configure C# Vector Types for Unity

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

To change the generated C# vector types from `System.Numerics.Vector` to `UnityEngine.Vector` for Unity compatibility, add the `--cs:use_unity_vector` option to your command line.

```Shell
--cs:use_unity_vector
```

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

### Tag Format in YAML

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/tag

Provides an example of how to declare a tag in YAML format using the __tag__ key-value pair. This approach maintains YAML's readability while incorporating tag information.

```YAML
__tag__ : dev
id : 1
name : xxx
```

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

### YAML Data Format Example

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

This section describes YAML format characteristics, noting its similarities to JSON. It explains how set types correspond to JSON lists, how map types are represented as key-value lists due to JSON's string-only keys, and how polymorphic bean types are specified using the $type attribute. The accompanying code provides an example of these features.

```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
```

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

### Generate C# Code for JSON Data Loading with Luban CLI

Source: https://luban.doc.code-philosophy.com/docs/basic/beginner/generatecodeanddata

This example shows how to generate C# code for loading JSON configuration data using Luban's command-line tool. It defines the paths for `Luban.dll` and data tables, specifies the code target as `cs-simple-json` (C# using SimpleJson for JSON data), and sets the output directory for the generated code.

```batch
set GEN_CLIENT={Luban.dll的路径}
set CONF_ROOT={DataTables目录的路径}

dotnet %GEN_CLIENT% ^
    -t client ^
    -c cs-simple-json ^
    --conf %CONF_ROOT%\luban.conf ^
    -x outputCodeDir=Assets/Gen

pause
```

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

### Typical XML Definition File Structure

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

This XML snippet illustrates the fundamental structure of a definition file, showcasing how to define modules, enums, beans, tables, and refgroups. It includes examples of nested modules, type mappings for client-side code (C#), and various data types.

```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>
```

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

### Load Protobuf2 Binary Data in C#

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

This snippet demonstrates how to load Protobuf2 binary data into a C# application. It uses the `ParseFrom` method of the generated `ItemTbItem` class to deserialize data from a file stream. Ensure the `pb_datas` directory exists and contains the serialized data.

```C#
var tbItem = ItemTbItem.Parser.ParseFrom(File.OpenRead("pb_datas/item_tbitem.bytes"));
```

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

### XML Data Format Example

Source: https://luban.doc.code-philosophy.com/docs/basic/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).

```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>
```

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

### Performance Benchmarks for Data Export Formats

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

This API documentation table presents performance test results for different data export formats (bin, json, lua). It includes metrics such as first-time cost, cumulative cost, single output file size, and total output file size, based on a dataset of 500 large Excel tables.

```APIDOC
Format | First Time Cost | Cumulative Cost | Single Output File Size | Total Output File Size
--- | --- | --- | --- | ---
bin | 15.652 s | 797 ms | 164 K | 59.5 M
json | 17.746 s | 796 ms | 1.11 M | 555 M
lua | 17.323 s | 739 ms | 433 K | 212 M
```

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

### YAML Data Format Example

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

Illustrates the YAML data structure, highlighting its similarities to JSON, and specific features like set, map, and polymorphic bean types using the '$type' attribute. Notes that both '.yaml' and '.yml' 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
```

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

### Generate Multiple Code and Data Formats Simultaneously with Luban CLI (Advanced)

Source: https://luban.doc.code-philosophy.com/docs/basic/beginner/generatecodeanddata

This advanced example demonstrates generating multiple code targets (e.g., C# for SimpleJson, C# for binary) and multiple data targets (JSON, binary) in a single command. It utilizes Luban's hierarchical parameter mechanism to specify distinct output directories for each generated code and data type, preventing overwrites.

```batch
set GEN_CLIENT={Luban.dll的路径}
set CONF_ROOT={DataTables目录的路径}

dotnet %GEN_CLIENT% ^
    -t client ^
    -c cs-simple-json ^
    -c cs-bin ^
    -d json ^
    -d bin ^
    --conf %CONF_ROOT%\luban.conf ^
    -x cs-simple-json.outputCodeDir=Assets/Gen/Json ^
    -x cs-bin.outputCodeDir=Assets/Gen/Bin ^
    -x json.outputDataDir=..\GenerateDatas\json ^
    -x bin.outputDataDir=..\GenerateDatas\bin
```

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

### Generate MsgPack Data

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

To generate data in MsgPack format, use the `--gen_types data_msgpack` command-line option. This will produce MsgPack serialized data files.

```Shell
--gen_types data_msgpack
```

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

### Luban Composite File Configuration Example

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

Shows how to configure Luban to read multiple records or specific fields from a single JSON file or multiple files. Explains different input file prefixes like `*@`, `field@`, and `*field@` for handling lists, specific fields, and nested lists within JSON data sources.

```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"/>
```

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

### Define and Extract Resource Addresses

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

This snippet demonstrates how to define string fields as resource addresses using the `#res=xxx` tag in a bean definition. It also shows the command-line options to extract these tagged resources into a specified file, such as `resources.txt`.

```XML
  <bean name="TestRes">
    <var name="icon" type="string#res=item"/>
  </bean>
```

```Shell
--gen_types data_resources --output:data:resource_list_file resources.txt
```

```Text
item,/ui/icon1.jpg
item,/ui/icon2.jpg
```

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

### Luban xargs Command-Line Parameters Reference

Source: https://luban.doc.code-philosophy.com/docs/basic/manual/commandtools

Details the various customizable parameters available via the `-x --xargs` command-line option for the Luban tool. These parameters control aspects like output directories, code styles, naming conventions, data exporters, post-processors, output savers, localization settings, path validators, line endings, JSON compactness, and file extensions.

```APIDOC
Parameter: {codeTarget}.outputCodeDir
  Description: Code target output directory
  Available Values: (None specified)
  Example: -x outputCodeDir=/my/output/dir

Parameter: {dataTarget}.outputDataDir
  Description: Data target output directory
  Available Values: (None specified)
  Example: -x outputDataDir=/my/output/dir

Parameter: codeStyle
  Description: Code target naming style. Built-in Code Targets automatically set the appropriate codeStyle for the target language, no explicit specification is needed.
  Available Values: none, csharp-default, java-default, go-default, lua-default, typescript-default, cpp-default, python-default, dart-default
  Example: -x codeStyle=csharp-default

Parameter: namingConvention.{codeTarget}.{location}
  Description: `codeTarget` is the target name specified in the `--codeTarget` parameter. `location` is the style position, optional values are namespace, type, method, property, field, enumItem (see Code Style for details). This parameter is hierarchical; if `{codeTarget}` is not specified, it applies to all targets.
  Available Values: none, pascal, camel, upper, snake
  Example: -x namingConvention.cs-bin.field=pascal

Parameter: dataExporter
  Description: Data exporter
  Available Values: null, default
  Example: -x dataExporter=default

Parameter: codePostprocess
  Description: Code post-processor, can be multiple.
  Available Values: No built-in post-processes implemented.
  Example: -x codePostProcess=a,b,c

Parameter: dataPostprocess
  Description: Data post-processor, can be multiple.
  Available Values: No built-in post-processes implemented.
  Example: -x dataPostProcess=a,b

Parameter: outputSaver
  Description: Data saver. Defaults to 'local' (output to local directory). Use 'null' if no files should be output.
  Available Values: null, local
  Example: -x outputSaver=local

Parameter: outputSaver.{codeTarget|dataTarget}.cleanUpOutputDir
  Description: Whether to clean up redundant files in outputCodeDir or outputDataDir before outputting files. Defaults to true.
  Available Values: (None specified)
  Example: -x outputSaver.cs-bin.cleanUpOutputDir=0

Parameter: l10n.provider
  Description: Localization text Provider. If not set, no localization-related operations will be performed, including text validation and static conversion.
  Available Values: default
  Example: -x l10n.provider=default

Parameter: l10n.textFile.path
  Description: Localization text data file. Required when l10n.provider is set.
  Available Values: (None specified)
  Example: -x l10n.textFile.path=xxxx

Parameter: l10n.textFile.keyFieldName
  Description: Field name for the key field in the localization text data file.
  Available Values: (None specified)
  Example: -x l10n.textFile.keyFieldName=key

Parameter: l10n.textFile.languageFieldName
  Description: Field name for the text value field corresponding to the language in the localization text data file.
  Available Values: (None specified)
  Example: -x l10n.languageFieldName=en

Parameter: l10n.convertTextKeyToValue
  Description: Perform static localization, replacing keys with corresponding language text values.
  Available Values: (None specified)
  Example: -x l10n.convertTextKeyToValue=1

Parameter: l10n.textListFile
  Description: File for the list of all text keys in the output configuration, used with DataTarget text-list.
  Available Values: (None specified)
  Example: (None specified)

Parameter: pathValidator.rootDir
  Description: Root directory used by the path validator to search for files.
  Available Values: (None specified)
  Example: -x pathValidator.rootDir=/xx/yy

Parameter: {code|data}.lineEnding
  Description: Line ending for generated code and data files. This option is only valid for text-type output files, not for binary formats like bin, bson.
  Available Values: CR, LF, CRLF. If not specified, Environment.NewLine is used.
  Example: -x lineEnding=LF, -x code.LineEnding=LF, -x data.lineEnding=LF

Parameter: json.compact
  Description: Whether to output compact, unindented JSON data, used with json or json2 dataTarget. Defaults to 0.
  Available Values: 0, 1, true, false
  Example: -x compact=1

Parameter: {dataTarget}.fileExt
  Description: File name suffix for output data files.
  Available Values: (None specified)
  Example: -x bin.fileExt=bin

Parameter: ~~{dataTarget}.outputDataExtension~~
  Description: File name suffix for output data files. Removed in v2.12.0, renamed to fileExt.
  Available Values: (None specified)
  Example: -x bin.outputDataExtension=bin

Parameter: {codeTarget|dataTarget}.fileEncoding
  Description: Character encoding for output files.
  Available Values: (None specified)
  Example: -x lua.fileEncoding=gb2313
```

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

### Generate Flatbuffers Data (JSON) and Convert to Binary

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

This snippet shows how to generate Flatbuffers data in JSON format and provides information on converting it to binary. Use `--gen_types code_flatbuffers,data_flatbuffers_json` for JSON output. Conversion to binary can be done using `flatc` with provided batch scripts (`convert_json_2_binary.bat`, `convert_json_2_binary.sh`). Note current limitations with union types in containers.

```Shell
--gen_types code_flatbuffers,data_flatbuffers_json
```

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

### JSON Data Source Example Configuration

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

This JSON snippet illustrates the structure of a data file loaded by Luban, showcasing various data types including booleans, numbers, strings, nested objects, polymorphic beans (using '$type'), arrays (sets), and maps (arrays of key-value pairs).

```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}]
}
```

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

### YAML Data Source Example Configuration

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

This YAML snippet demonstrates a data file structure for Luban, showcasing various data types including booleans, numbers, strings, nested objects, polymorphic beans (using '$type'), arrays (lists), and maps.

```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
```

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

### Data Format Default File Extensions

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

This API documentation table lists the default file extensions for various data formats generated by Luban. Users can override these defaults using the `--data_file_extension xxx` command-line option.

```APIDOC
data_bin: bin
data_json: json
data_json2: json
data_lua: lua
data_xml: xml
data_yaml: yml
data_protobuf: bp
```

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

### Luban Composite File Configuration Example

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

This XML configuration defines data beans and tables for Luban, demonstrating how to load data from composite JSON files. It shows different input patterns for reading single records, lists of records, or specific fields from JSON files, including deep-nested fields.

```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"/>
```

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

### XML Sub-definition File Structure

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

This snippet illustrates the basic structure of an XML sub-definition file, which can contain various data definitions such as modules, beans, enumerations, and tables. It shows a typical example of a table definition 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>
```

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

### Customize Code Naming Conventions

Source: https://luban.doc.code-philosophy.com/docs/basic/1.x/manual/generatecodedata

This section details how to customize the naming style of generated code fields. The `--naming_convention_bean_member` option allows setting styles like `none`, `language_recommend` (default), `camelCase`, `PascalCase`, or `under_scores`.

```Shell
--naming_convention_bean_member none
```

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

### XML Data Format Example

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

This snippet demonstrates the structure of an XML data file, showcasing various data types such as boolean, integer, long, float, string, nested objects, lists of items, key-value maps, and polymorphic bean types using the 'type' attribute.

```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>
```

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

### Luban Table Definition: Singleton Mode

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

Defines a singleton table, which contains only a single record. This mode does not allow an `index` attribute. `mode="one"` can also be used as an alias. This example shows a table named `TbSingleton` sourcing data from `singleton.xlsx`.

```XML
<table name="TbSingleton" value="Singleton" mode="singleton" input="singleton.xlsx"/>
```

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

### Composite File Input Configuration for Tables

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

This section explains how to configure composite file inputs when a single file contains multiple records. It details various input file formats for tables, using JSON as an example: reading a single record (xxx.json), a list of records (*@xxx.json), a specific field as a single record (field@xxx.json), or a specific field as a list of records (*field@xxx.json). It also notes the ability to include multiple tables within a single JSON file, similar to XLSX data sources. The provided XML configuration demonstrates how to define data beans and link them to tables with different composite input settings.

```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"/>
```

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

### C# Code Generation for Ref Fields

Source: https://luban.doc.code-philosophy.com/docs/basic/manual/validator

Example C# code demonstrating how fields with `ref` attributes are generated. For each `int` or array/list of `int` field, a corresponding `_Ref` field is generated with the type of the referenced table record. This automatic resolution simplifies usage. Note: No code is generated if a field references multiple tables.

```C#
public int X1 { get; private set; }
public test.TestBeRef X1_Ref { get; private set; }
public int X12 { get; private set; }
public int X2 { get; private set; }
public int X3 { get; private set; }
public int[] A1 { get; private set; }
public test.TestBeRef[] A1_Ref { get; private set; }
public int[] A2 { get; private set; }
public test.TestBeRef[] A2_Ref { get; private set; }
public System.Collections.Generic.List<int> B1 { get; private set; }
public System.Collections.Generic.List<test.TestBeRef> B1_Ref { get; private set; }
public System.Collections.Generic.List<int> B2 { get; private set; }
public System.Collections.Generic.List<test.TestBeRef> B2_Ref { get; private set; }
public System.Collections.Generic.HashSet<int> C1 { get; private set; }
public System.Collections.Generic.HashSet<test.TestBeRef> C1_Ref { get; private set; }
public System.Collections.Generic.HashSet<int> C2 { get; private set; }
public System.Collections.Generic.HashSet<test.TestBeRef> C2_Ref { get; private set; }
public System.Collections.Generic.Dictionary<int, int> D1 { get; private set; }
public System.Collections.Generic.Dictionary<int, test.TestBeRef> D1_Ref { get; private set; }
public System.Collections.Generic.Dictionary<int, int> D2 { get; private set; }
public System.Collections.Generic.Dictionary<int, test.TestBeRef> D2_Ref { get; private set; }
```

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

### Defining Enumerations (enum) in XML

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

This section describes how to define an enumeration, including its name, optional flags for bitwise operations, tags, uniqueness constraint, and comments. It also details the attributes for individual enum variables ('var'), such as 'name', 'alias' (for easier data entry), 'value' (auto-incrementing if not specified), 'tags', and 'comment'. It provides two examples: a simple color enum and a more complex access mode enum with flags and tags.

```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>
```
Tokens:
Raw