# Business Logic — KKW00121SF01DBean.loadModelData() [229 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `eo.web.webview.KKW00121SF.KKW00121SF01DBean` |
| Layer | View Data Bean (Component / UI Framework Layer) |
| Module | `KKW00121SF` (Package: `eo.web.webview.KKW00121SF`) |

## 1. Role

### KKW00121SF01DBean.loadModelData()

This method is a **data routing and dispatch mechanism** for the X33 framework's view data bean layer. Its primary business role is to retrieve data values from structured list-based properties based on a composite key string, enabling the UI framework to dynamically access model data without hardcoding property references. The method implements a **dispatch pattern** where the `key` parameter encodes both the target list type (via a prefix) and an index within that list (via a suffix after a `/` separator). It supports 8 distinct list categories used throughout the screen: Template IDs, Statuses, Item Check Errors, Item IDs, Screen IDs, Message IDs, Replacement Strings, and Screen Item IDs. For wildcard queries (index `*`), it returns the count of elements in the target list, supporting UI constructs like dropdown count display. For indexed access, it validates the index bounds and delegates the actual data retrieval to the individual `X33VDataTypeStringBean` instance via its own `loadModelData(subkey)` method. This method is a core infrastructure piece in the X33 view-model binding system — it is called by the framework during view rendering and data binding phases, translating high-level property access patterns into concrete data retrievals.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["loadModelData(key, subkey)"])

    START --> CHECK_NULL["Check: key or subkey == null"]
    CHECK_NULL -->|Yes| RET_NULL1["Return null"]

    CHECK_NULL -->|No| FIND_SEP["Find '/' separator index in key"]
    FIND_SEP --> ROUTE{"Route by key prefix"}

    ROUTE --> LIST1["Template ID List (配列項目 テンプレートID)"]
    ROUTE --> LIST2["Status List (配列項目 ステータス)"]
    ROUTE --> LIST3["Item Check Error List (配列項目 項目チェックエラー)"]
    ROUTE --> LIST4["Item ID List (配列項目 項目ID)"]
    ROUTE --> LIST5["Screen ID List (配列項目 画面ID)"]
    ROUTE --> LIST6["Message ID List (配列項目 メッセージID)"]
    ROUTE --> LIST7["Replacement String List (配列項目 埋め込み文字列)"]
    ROUTE --> LIST8["Screen Item ID List (配列項目 画面項目ID)"]

    LIST1 --> EXTRACT1["Extract index from key"]
    LIST2 --> EXTRACT2["Extract index from key"]
    LIST3 --> EXTRACT3["Extract index from key"]
    LIST4 --> EXTRACT4["Extract index from key"]
    LIST5 --> EXTRACT5["Extract index from key"]
    LIST6 --> EXTRACT6["Extract index from key"]
    LIST7 --> EXTRACT7["Extract index from key"]
    LIST8 --> EXTRACT8["Extract index from key"]

    EXTRACT1 --> WILDCARD1{"Is index == '*'?"}
    EXTRACT2 --> WILDCARD2{"Is index == '*'?"}
    EXTRACT3 --> WILDCARD3{"Is index == '*'?"}
    EXTRACT4 --> WILDCARD4{"Is index == '*'?"}
    EXTRACT5 --> WILDCARD5{"Is index == '*'?"}
    EXTRACT6 --> WILDCARD6{"Is index == '*'?"}
    EXTRACT7 --> WILDCARD7{"Is index == '*'?"}
    EXTRACT8 --> WILDCARD8{"Is index == '*'?"}

    WILDCARD1 -->|Yes| COUNT1["Return template_id_list.size()"]
    WILDCARD2 -->|Yes| COUNT2["Return status_list.size()"]
    WILDCARD3 -->|Yes| COUNT3["Return item_check_err_list.size()"]
    WILDCARD4 -->|Yes| COUNT4["Return item_id_list.size()"]
    WILDCARD5 -->|Yes| COUNT5["Return gamen_id_list.size()"]
    WILDCARD6 -->|Yes| COUNT6["Return message_id_list.size()"]
    WILDCARD7 -->|Yes| COUNT7["Return replace_str_list.size()"]
    WILDCARD8 -->|Yes| COUNT8["Return screen_item_id_list.size()"]

    WILDCARD1 -->|No| PARSE1["Parse index to int"]
    WILDCARD2 -->|No| PARSE2["Parse index to int"]
    WILDCARD3 -->|No| PARSE3["Parse index to int"]
    WILDCARD4 -->|No| PARSE4["Parse index to int"]
    WILDCARD5 -->|No| PARSE5["Parse index to int"]
    WILDCARD6 -->|No| PARSE6["Parse index to int"]
    WILDCARD7 -->|No| PARSE7["Parse index to int"]
    WILDCARD8 -->|No| PARSE8["Parse index to int"]

    PARSE1 --> TRY1["Try: Integer.valueOf(key)"]
    PARSE2 --> TRY2["Try: Integer.valueOf(key)"]
    PARSE3 --> TRY3["Try: Integer.valueOf(key)"]
    PARSE4 --> TRY4["Try: Integer.valueOf(key)"]
    PARSE5 --> TRY5["Try: Integer.valueOf(key)"]
    PARSE6 --> TRY6["Try: Integer.valueOf(key)"]
    PARSE7 --> TRY7["Try: Integer.valueOf(key)"]
    PARSE8 --> TRY8["Try: Integer.valueOf(key)"]

    TRY1 -->|NumberFormatException| RET_PARSE1["Return null"]
    TRY2 -->|NumberFormatException| RET_PARSE2["Return null"]
    TRY3 -->|NumberFormatException| RET_PARSE3["Return null"]
    TRY4 -->|NumberFormatException| RET_PARSE4["Return null"]
    TRY5 -->|NumberFormatException| RET_PARSE5["Return null"]
    TRY6 -->|NumberFormatException| RET_PARSE6["Return null"]
    TRY7 -->|NumberFormatException| RET_PARSE7["Return null"]
    TRY8 -->|NumberFormatException| RET_PARSE8["Return null"]

    TRY1 --> CHECK_BOUNDS1["Validate: 0 <= index < list.size()"]
    TRY2 --> CHECK_BOUNDS2["Validate: 0 <= index < list.size()"]
    TRY3 --> CHECK_BOUNDS3["Validate: 0 <= index < list.size()"]
    TRY4 --> CHECK_BOUNDS4["Validate: 0 <= index < list.size()"]
    TRY5 --> CHECK_BOUNDS5["Validate: 0 <= index < list.size()"]
    TRY6 --> CHECK_BOUNDS6["Validate: 0 <= index < list.size()"]
    TRY7 --> CHECK_BOUNDS7["Validate: 0 <= index < list.size()"]
    TRY8 --> CHECK_BOUNDS8["Validate: 0 <= index < list.size()"]

    CHECK_BOUNDS1 -->|Valid| DELEGATE1["template_id_list[index].loadModelData(subkey)"]
    CHECK_BOUNDS2 -->|Valid| DELEGATE2["status_list[index].loadModelData(subkey)"]
    CHECK_BOUNDS3 -->|Valid| DELEGATE3["item_check_err_list[index].loadModelData(subkey)"]
    CHECK_BOUNDS4 -->|Valid| DELEGATE4["item_id_list[index].loadModelData(subkey)"]
    CHECK_BOUNDS5 -->|Valid| DELEGATE5["gamen_id_list[index].loadModelData(subkey)"]
    CHECK_BOUNDS6 -->|Valid| DELEGATE6["message_id_list[index].loadModelData(subkey)"]
    CHECK_BOUNDS7 -->|Valid| DELEGATE7["replace_str_list[index].loadModelData(subkey)"]
    CHECK_BOUNDS8 -->|Valid| DELEGATE8["screen_item_id_list[index].loadModelData(subkey)"]

    CHECK_BOUNDS1 -->|Invalid| RET_BOUNDS1["Return null"]
    CHECK_BOUNDS2 -->|Invalid| RET_BOUNDS2["Return null"]
    CHECK_BOUNDS3 -->|Invalid| RET_BOUNDS3["Return null"]
    CHECK_BOUNDS4 -->|Invalid| RET_BOUNDS4["Return null"]
    CHECK_BOUNDS5 -->|Invalid| RET_BOUNDS5["Return null"]
    CHECK_BOUNDS6 -->|Invalid| RET_BOUNDS6["Return null"]
    CHECK_BOUNDS7 -->|Invalid| RET_BOUNDS7["Return null"]
    CHECK_BOUNDS8 -->|Invalid| RET_BOUNDS8["Return null"]

    DELEGATE1 --> END_RETURN["Return data"]
    DELEGATE2 --> END_RETURN
    DELEGATE3 --> END_RETURN
    DELEGATE4 --> END_RETURN
    DELEGATE5 --> END_RETURN
    DELEGATE6 --> END_RETURN
    DELEGATE7 --> END_RETURN
    DELEGATE8 --> END_RETURN

    RET_NULL1 --> END_RETURN
    RET_PARSE1 --> END_RETURN
    RET_PARSE2 --> END_RETURN
    RET_PARSE3 --> END_RETURN
    RET_PARSE4 --> END_RETURN
    RET_PARSE5 --> END_RETURN
    RET_PARSE6 --> END_RETURN
    RET_PARSE7 --> END_RETURN
    RET_PARSE8 --> END_RETURN
    RET_BOUNDS1 --> END_RETURN
    RET_BOUNDS2 --> END_RETURN
    RET_BOUNDS3 --> END_RETURN
    RET_BOUNDS4 --> END_RETURN
    RET_BOUNDS5 --> END_RETURN
    RET_BOUNDS6 --> END_RETURN
    RET_BOUNDS7 --> END_RETURN
    RET_BOUNDS8 --> END_RETURN
```

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `key` | `String` | Composite property identifier that encodes both a **list category** and an **index**. Format: `"[Category Name]/[Index]"` where Category Name is one of eight Japanese-labeled list types (e.g., テンプレートID for Template ID, ステータス for Status, 項目チェックエラー for Item Check Error) and Index is either a numeric string for element access or `*` for a count query. The `/` separator is found via `indexOf('/')` and the portion after it is used for index resolution. |
| 2 | `subkey` | `String` | Secondary property selector passed verbatim to the target list item's own `loadModelData(subkey)` method. It allows nested data access within each list element, which are themselves `X33VDataTypeStringBean` instances with their own property model. |

**Instance fields read by this method:**

| Field | Type | Business Description |
|-------|------|---------------------|
| `template_id_list` | `X33VDataTypeList` | List of template ID data items (配列項目 テンプレートID) — holds template identifiers for the screen |
| `status_list` | `X33VDataTypeList` | List of status data items (配列項目 ステータス) — holds status values for the screen |
| `item_check_err_list` | `X33VDataTypeList` | List of item check error data items (配列項目 項目チェックエラー) — holds validation error flags |
| `item_id_list` | `X33VDataTypeList` | List of item ID data items (配列項目 項目ID) — holds item identifiers for the screen |
| `gamen_id_list` | `X33VDataTypeList` | List of screen ID data items (配列項目 画面ID) — holds screen-level identifiers |
| `message_id_list` | `X33VDataTypeList` | List of message ID data items (配列項目 メッセージID) — holds message identifiers for UI display |
| `replace_str_list` | `X33VDataTypeList` | List of replacement string data items (配列項目 埋め込み文字列) — holds text substitution values |
| `screen_item_id_list` | `X33VDataTypeList` | List of screen item ID data items (配列項目 画面項目ID) — holds screen-specific item identifiers |

## 4. CRUD Operations / Called Services

### Pre-computed evidence from code analysis graph:

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| - | `JKKAdEditCC.substring` | JKKAdEditCC | - | Calls `substring` in `JKKAdEditCC` |
| - | `JKKAdEdit.substring` | JKKAdEdit | - | Calls `substring` in `JKKAdEdit` |
| - | `JKKTelnoInfoAddMapperCC.substring` | JKKTelnoInfoAddMapperCC | - | Calls `substring` in `JKKTelnoInfoAddMapperCC` |
| - | `JDKejbStringEdit.substring` | JDKejbStringEdit | - | Calls `substring` in `JDKejbStringEdit` |
| R | `KKW00121SF01DBean.loadModelData` | KKW00121SF01DBean | - | Calls `loadModelData` in `KKW00121SF01DBean` |

### Method calls within `loadModelData`:

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `String.indexOf` | java.lang.String | - | Reads character position of the `/` separator in the key string |
| R | `String.substring` | java.lang.String | - | Extracts the index portion of the key string after the `/` separator |
| R | `String.equals` | java.lang.String | - | Compares the extracted index against `"*"` or performs key prefix matching |
| R | `X33VDataTypeList.size` | java.util.List | - | Reads the size of the target list for bounds checking or wildcard count queries |
| R | `X33VDataTypeList.get` | java.util.List | - | Retrieves the element at the specified index from the target list |
| R | `X33VDataTypeStringBean.loadModelData` | X33VDataTypeStringBean | - | Delegates data retrieval to the individual list element for nested property access |
| C | `Integer.valueOf` | java.lang | - | Creates an Integer wrapper from the parsed index string (used for bounds checking) |

**Classification rationale:**
- All operations are **Read (R)** — the method does not create, update, or delete any data. It only retrieves data from in-memory list structures and delegates reads to nested beans.
- The final `loadModelData(subkey)` call on `X33VDataTypeStringBean` is a **Read** operation within the X33 framework's data type bean hierarchy.
- There are **no database (CBS/SC) calls** — this method operates entirely in the view data bean layer with in-memory collections.

## 5. Dependency Trace

### Direct Callers

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Class:KKW00121SF01DBean | `KKW00121SF01DBean.loadModelData()` | `X33VDataTypeStringBean.loadModelData [R]` (nested delegate) |

**Notes:** This method is part of the X33 framework's view data bean interface (`X33VDataTypeBeanInterface`). It is invoked by the X33 framework runtime during view data loading/binding — typically triggered by the JSF component lifecycle or the X33 view rendering engine. The X33 framework generates calls to `loadModelData` dynamically based on EL (Expression Language) property paths bound to UI components. No explicit caller exists in the screen code; the framework itself calls this method as part of its data-binding infrastructure.

### Downstream calls from this method

| # | Called Method | Type | Description |
|---|--------------|------|-------------|
| 1 | `X33VDataTypeStringBean.loadModelData(subkey)` | R | Delegates to list element for nested property lookup |
| 2 | `X33VDataTypeList.size()` | R | Retrieves list element count |
| 3 | `X33VDataTypeList.get(index)` | R | Retrieves element at index from list |
| 4 | `String.indexOf("/")` | R | Finds separator position |
| 5 | `String.substring(pos)` | R | Extracts index portion of key |

## 6. Per-Branch Detail Blocks

### Block 1 — IF (null check) (L246)

> Early termination: if either `key` or `subkey` is null, return null immediately. This prevents NullPointerException in downstream parsing operations.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `separaterPoint = key.indexOf("/")` // Find separator position [java.lang.String.indexOf] |
| 2 | IF | `key == null || subkey == null` |
| 3 | RETURN | `return null;` // key, subkey is null — return null (key, subkeyがnullの場合、nullを返す) |

### Block 2 — IF-ELSE-IF (Template ID List) (L254)

> Route to Template ID list processing. Key prefix: "配列項目 テンプレートID" (Array Item: Template ID). Extracts the index portion after the separator and processes it.

| # | Type | Code |
|---|------|------|
| 1 | IF-ELSE | `key.equals("配列項目 テンプレートID")` [key equals "配列項目 テンプレートID" / "Array Item: Template ID"] |
| 2 | SET | `key = key.substring(separaterPoint + 1)` // Extract index portion from key [-> "配列項目 テンプレートID"] |
| 3 | IF-ELSE | `key.equals("*")` |
| 4 | RETURN | `return Integer.valueOf(template_id_list.size());` // Return element count for wildcard [-> "*"] |
| 5 | SET | `tmpIndexInt = Integer.valueOf(key)` // Parse index to integer [Try block] |
| 6 | CATCH | `NumberFormatException e` // Index is not a valid numeric string — return null [Index値が数値文字列でない場合は、ここでnullを返す] |
| 7 | IF-ELSE | `tmpIndexInt == null` |
| 8 | RETURN | `return null;` |
| 9 | SET | `tmpIndex = tmpIndexInt.intValue()` // Unwrap Integer to primitive int |
| 10 | IF-ELSE | `tmpIndex < 0 || tmpIndex >= template_id_list.size()` // Index out of bounds check |
| 11 | RETURN | `return null;` // Index exceeds list count — return null [Index値がリスト個数-1を超えた場合] |
| 12 | RETURN | `return ((X33VDataTypeStringBean)template_id_list.get(tmpIndex)).loadModelData(subkey);` // Delegate to list element [cast to X33VDataTypeStringBean] |

### Block 3 — IF-ELSE-IF (Status List) (L291)

> Route to Status list processing. Key prefix: "配列項目 ステータス" (Array Item: Status).

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("配列項目 ステータス")` [key equals "配列項目 ステータス" / "Array Item: Status"] |
| 2 | SET | `key = key.substring(separaterPoint + 1)` // Extract index portion from key |
| 3 | IF-ELSE | `key.equals("*")` |
| 4 | RETURN | `return Integer.valueOf(status_list.size());` // Return element count for wildcard |
| 5 | SET | `tmpIndexInt = Integer.valueOf(key)` // Parse index to integer [Try block] |
| 6 | CATCH | `NumberFormatException e` // Index is not a valid numeric string — return null |
| 7 | IF-ELSE | `tmpIndexInt == null` |
| 8 | RETURN | `return null;` |
| 9 | SET | `tmpIndex = tmpIndexInt.intValue()` // Unwrap Integer to primitive int |
| 10 | IF-ELSE | `tmpIndex < 0 || tmpIndex >= status_list.size()` // Index out of bounds check |
| 11 | RETURN | `return null;` // Index exceeds list count — return null |
| 12 | RETURN | `return ((X33VDataTypeStringBean)status_list.get(tmpIndex)).loadModelData(subkey);` // Delegate to list element |

### Block 4 — IF-ELSE-IF (Item Check Error List) (L328)

> Route to Item Check Error list processing. Key prefix: "配列項目 項目チェックエラー" (Array Item: Item Check Error).

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("配列項目 項目チェックエラー")` [key equals "配列項目 項目チェックエラー" / "Array Item: Item Check Error"] |
| 2 | SET | `key = key.substring(separaterPoint + 1)` // Extract index portion from key |
| 3 | IF-ELSE | `key.equals("*")` |
| 4 | RETURN | `return Integer.valueOf(item_check_err_list.size());` // Return element count for wildcard |
| 5 | SET | `tmpIndexInt = Integer.valueOf(key)` // Parse index to integer [Try block] |
| 6 | CATCH | `NumberFormatException e` // Index is not a valid numeric string — return null |
| 7 | IF-ELSE | `tmpIndexInt == null` |
| 8 | RETURN | `return null;` |
| 9 | SET | `tmpIndex = tmpIndexInt.intValue()` // Unwrap Integer to primitive int |
| 10 | IF-ELSE | `tmpIndex < 0 || tmpIndex >= item_check_err_list.size()` // Index out of bounds check |
| 11 | RETURN | `return null;` // Index exceeds list count — return null |
| 12 | RETURN | `return ((X33VDataTypeStringBean)item_check_err_list.get(tmpIndex)).loadModelData(subkey);` // Delegate to list element |

### Block 5 — IF-ELSE-IF (Item ID List) (L365)

> Route to Item ID list processing. Key prefix: "配列項目 項目ID" (Array Item: Item ID).

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("配列項目 項目ID")` [key equals "配列項目 項目ID" / "Array Item: Item ID"] |
| 2 | SET | `key = key.substring(separaterPoint + 1)` // Extract index portion from key |
| 3 | IF-ELSE | `key.equals("*")` |
| 4 | RETURN | `return Integer.valueOf(item_id_list.size());` // Return element count for wildcard |
| 5 | SET | `tmpIndexInt = Integer.valueOf(key)` // Parse index to integer [Try block] |
| 6 | CATCH | `NumberFormatException e` // Index is not a valid numeric string — return null |
| 7 | IF-ELSE | `tmpIndexInt == null` |
| 8 | RETURN | `return null;` |
| 9 | SET | `tmpIndex = tmpIndexInt.intValue()` // Unwrap Integer to primitive int |
| 10 | IF-ELSE | `tmpIndex < 0 || tmpIndex >= item_id_list.size()` // Index out of bounds check |
| 11 | RETURN | `return null;` // Index exceeds list count — return null |
| 12 | RETURN | `return ((X33VDataTypeStringBean)item_id_list.get(tmpIndex)).loadModelData(subkey);` // Delegate to list element |

### Block 6 — IF-ELSE-IF (Screen ID List) (L402)

> Route to Screen ID list processing. Key prefix: "配列項目 画面ID" (Array Item: Screen ID).

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("配列項目 画面ID")` [key equals "配列項目 画面ID" / "Array Item: Screen ID"] |
| 2 | SET | `key = key.substring(separaterPoint + 1)` // Extract index portion from key |
| 3 | IF-ELSE | `key.equals("*")` |
| 4 | RETURN | `return Integer.valueOf(gamen_id_list.size());` // Return element count for wildcard |
| 5 | SET | `tmpIndexInt = Integer.valueOf(key)` // Parse index to integer [Try block] |
| 6 | CATCH | `NumberFormatException e` // Index is not a valid numeric string — return null |
| 7 | IF-ELSE | `tmpIndexInt == null` |
| 8 | RETURN | `return null;` |
| 9 | SET | `tmpIndex = tmpIndexInt.intValue()` // Unwrap Integer to primitive int |
| 10 | IF-ELSE | `tmpIndex < 0 || tmpIndex >= gamen_id_list.size()` // Index out of bounds check |
| 11 | RETURN | `return null;` // Index exceeds list count — return null |
| 12 | RETURN | `return ((X33VDataTypeStringBean)gamen_id_list.get(tmpIndex)).loadModelData(subkey);` // Delegate to list element |

### Block 7 — IF-ELSE-IF (Message ID List) (L439)

> Route to Message ID list processing. Key prefix: "配列項目 メッセージID" (Array Item: Message ID).

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("配列項目 メッセージID")` [key equals "配列項目 メッセージID" / "Array Item: Message ID"] |
| 2 | SET | `key = key.substring(separaterPoint + 1)` // Extract index portion from key |
| 3 | IF-ELSE | `key.equals("*")` |
| 4 | RETURN | `return Integer.valueOf(message_id_list.size());` // Return element count for wildcard |
| 5 | SET | `tmpIndexInt = Integer.valueOf(key)` // Parse index to integer [Try block] |
| 6 | CATCH | `NumberFormatException e` // Index is not a valid numeric string — return null |
| 7 | IF-ELSE | `tmpIndexInt == null` |
| 8 | RETURN | `return null;` |
| 9 | SET | `tmpIndex = tmpIndexInt.intValue()` // Unwrap Integer to primitive int |
| 10 | IF-ELSE | `tmpIndex < 0 || tmpIndex >= message_id_list.size()` // Index out of bounds check |
| 11 | RETURN | `return null;` // Index exceeds list count — return null |
| 12 | RETURN | `return ((X33VDataTypeStringBean)message_id_list.get(tmpIndex)).loadModelData(subkey);` // Delegate to list element |

### Block 8 — IF-ELSE-IF (Replacement String List) (L476)

> Route to Replacement String list processing. Key prefix: "配列項目 埋め込み文字列" (Array Item: Embedded String / Replacement String).

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("配列項目 埋め込み文字列")` [key equals "配列項目 埋め込み文字列" / "Array Item: Embedded String"] |
| 2 | SET | `key = key.substring(separaterPoint + 1)` // Extract index portion from key |
| 3 | IF-ELSE | `key.equals("*")` |
| 4 | RETURN | `return Integer.valueOf(replace_str_list.size());` // Return element count for wildcard |
| 5 | SET | `tmpIndexInt = Integer.valueOf(key)` // Parse index to integer [Try block] |
| 6 | CATCH | `NumberFormatException e` // Index is not a valid numeric string — return null |
| 7 | IF-ELSE | `tmpIndexInt == null` |
| 8 | RETURN | `return null;` |
| 9 | SET | `tmpIndex = tmpIndexInt.intValue()` // Unwrap Integer to primitive int |
| 10 | IF-ELSE | `tmpIndex < 0 || tmpIndex >= replace_str_list.size()` // Index out of bounds check |
| 11 | RETURN | `return null;` // Index exceeds list count — return null |
| 12 | RETURN | `return ((X33VDataTypeStringBean)replace_str_list.get(tmpIndex)).loadModelData(subkey);` // Delegate to list element |

### Block 9 — IF-ELSE-IF (Screen Item ID List) (L513)

> Route to Screen Item ID list processing. Key prefix: "配列項目 画面項目ID" (Array Item: Screen Item ID).

| # | Type | Code |
|---|------|------|
| 1 | ELSE-IF | `key.equals("配列項目 画面項目ID")` [key equals "配列項目 画面項目ID" / "Array Item: Screen Item ID"] |
| 2 | SET | `key = key.substring(separaterPoint + 1)` // Extract index portion from key |
| 3 | IF-ELSE | `key.equals("*")` |
| 4 | RETURN | `return Integer.valueOf(screen_item_id_list.size());` // Return element count for wildcard |
| 5 | SET | `tmpIndexInt = Integer.valueOf(key)` // Parse index to integer [Try block] |
| 6 | CATCH | `NumberFormatException e` // Index is not a valid numeric string — return null |
| 7 | IF-ELSE | `tmpIndexInt == null` |
| 8 | RETURN | `return null;` |
| 9 | SET | `tmpIndex = tmpIndexInt.intValue()` // Unwrap Integer to primitive int |
| 10 | IF-ELSE | `tmpIndex < 0 || tmpIndex >= screen_item_id_list.size()` // Index out of bounds check |
| 11 | RETURN | `return null;` // Index exceeds list count — return null |
| 12 | RETURN | `return ((X33VDataTypeStringBean)screen_item_id_list.get(tmpIndex)).loadModelData(subkey);` // Delegate to list element |

### Block 10 — ELSE (No matching route) (L550)

> Fallback: no property matches any of the 8 known list categories. Return null gracefully.

| # | Type | Code |
|---|------|------|
| 1 | ELSE (implicit) | No matching condition — falls through all 8 IF-ELSE-IF branches |
| 2 | RETURN | `return null;` // Property matching the condition does not exist — return null (条件に一致するプロパティが存在しない場合は、nullを返す) |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `配列項目 テンプレートID` | Japanese key | Array Item: Template ID — list category for template identifiers used in the screen |
| `配列項目 ステータス` | Japanese key | Array Item: Status — list category for status values displayed or managed on the screen |
| `配列項目 項目チェックエラー` | Japanese key | Array Item: Item Check Error — list category for validation error flags per item |
| `配列項目 項目ID` | Japanese key | Array Item: Item ID — list category for item identifiers in the screen's data model |
| `配列項目 画面ID` | Japanese key | Array Item: Screen ID — list category for screen-level identifiers |
| `配列項目 メッセージID` | Japanese key | Array Item: Message ID — list category for UI message identifiers |
| `配列項目 埋め込み文字列` | Japanese key | Array Item: Embedded String — list category for text replacement/substitution values |
| `配列項目 画面項目ID` | Japanese key | Array Item: Screen Item ID — list category for screen-specific item identifiers |
| `X33VDataTypeList` | Class | X33 framework data type list — a typed list container managed by the X33 view framework for holding list-based UI data |
| `X33VDataTypeStringBean` | Class | X33 framework string data type bean — a data type holder that stores a string value and supports nested property loading via `loadModelData(subkey)` |
| `X33VViewBaseBean` | Class | X33 framework base view bean — the foundation class for all X33 view data beans |
| `X33VListedBeanInterface` | Interface | X33 framework interface indicating this bean contains list-based data types |
| `X33VDataTypeBeanInterface` | Interface | X33 framework interface requiring implementation of `loadModelData` and `storeModelData` methods |
| `X31CBaseBean` | Class | X31 framework base bean — parent class providing common data binding functionality |
| `key` | Parameter | Composite property name encoding list category and index (format: "Category/Index") |
| `subkey` | Parameter | Secondary property selector for nested data access within a list element |
| `template_id_list` | Field | Template ID list — holds template identifier data items |
| `status_list` | Field | Status list — holds status value data items |
| `item_check_err_list` | Field | Item check error list — holds validation error flag data items |
| `item_id_list` | Field | Item ID list — holds item identifier data items |
| `gamen_id_list` | Field | Screen ID list — holds screen identifier data items |
| `message_id_list` | Field | Message ID list — holds message identifier data items |
| `replace_str_list` | Field | Replacement string list — holds text substitution value data items |
| `screen_item_id_list` | Field | Screen item ID list — holds screen item identifier data items |
| `separaterPoint` | Local var | Index position of the "/" character in the key string, used as delimiter between list category and index |
| `tmpIndexInt` | Local var | Temporarily parsed integer value of the index portion of the key |
| `tmpIndex` | Local var | Primitive int representation of the parsed index, used for bounds checking |
| `*` | Value | Wildcard marker — when used as the index in the key, triggers a count query returning the list element count |