# Business Logic — JKKKikiIchiranKkUpdCC.editInArrayMsg() [93 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `com.fujitsu.futurity.bp.custom.common.JKKKikiIchiranKkUpdCC` |
| Layer | CC / Common Component (shared business logic helper within the custom common package) |
| Module | `common` (Package: `com.fujitsu.futurity.bp.custom.common`) |

## 1. Role

### JKKKikiIchiranKkUpdCC.editInArrayMsg()

This method assembles a parameter map that serves as the input payload for invoking a Service Component (SC) / CBS (Common Business Service) via the SC call framework. It is a data preparation utility that bridges screen-level request parameters with the message structures expected by backend CBS processes. Specifically, it extracts context identifiers (transaction ID, use case ID, operation ID, call type) and network/operational metadata (client hostname, client IP, screen ID, operator ID) from the `IRequestParameterReadWrite` object, then constructs a `CAANMsg` template hierarchy by merging header-level control data (including the service interface name and runtime operation date/time) with structured mapping data (`mappingData`) and an array of child list templates (`inList`). The mapping data loop populates or nullifies fields based on whether values are empty strings, while the child list loop iterates over a list of maps and builds individual `CAANMsg` instances per child row — defaulting to a per-item template bundle name pattern (`{svcIf}CBSMsg1List`) when no pre-existing child template is found. The resulting `paramMap` wraps a single-element `CAANMsg[]` template array under the `TEMPLATE_LIST_KEY`, which the caller (`callSCArray`) passes directly to the SC call invoker. In essence, this method implements a **routing/dispatch builder pattern**: it transforms heterogeneous request and control data into a structured CBS message envelope that the SC call framework can execute, without performing any direct database or SC invocation itself.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["editInArrayMsg(param, mappingData, inListMsgName, inList)"])
    
    START --> CREATE_PARAM["Create paramMap = new HashMap<String, Object>()"]
    
    CREATE_PARAM --> EXTRACT_TELEGRAM["Extract telegram context from param"]
    EXTRACT_TELEGRAM --> EXTRACT_TELEGRAM_1["paramMap.put(TRANZACTION_ID_KEY, param.getTelegramID())"]
    EXTRACT_TELEGRAM_1 --> EXTRACT_TELEGRAM_2["paramMap.put(USECASE_ID_KEY, param.getUsecaseID())"]
    EXTRACT_TELEGRAM_2 --> EXTRACT_TELEGRAM_3["paramMap.put(OPERATION_ID_KEY, param.getOperationID())"]
    EXTRACT_TELEGRAM_3 --> EXTRACT_TELEGRAM_4["paramMap.put(CALL_TYPE_KEY, param.getCallType())"]
    
    EXTRACT_TELEGRAM_4 --> EXTRACT_CONTROL["Extract control context from param"]
    EXTRACT_CONTROL --> EXTRACT_CONTROL_1["paramMap.put(CLIENT_HOST_NAME_KEY, param.getControlMapData(REQ_HOSTNAME))"]
    EXTRACT_CONTROL_1 --> EXTRACT_CONTROL_2["paramMap.put(CLIENT_IP_ADDRESS_KEY, param.getControlMapData(REQ_HOSTIP))"]
    EXTRACT_CONTROL_2 --> EXTRACT_CONTROL_3["paramMap.put(INVOKE_GAMEN_ID_KEY, param.getControlMapData(REQ_VIEWID))"]
    EXTRACT_CONTROL_3 --> EXTRACT_CONTROL_4["paramMap.put(OPERATOR_ID_KEY, param.getControlMapData(OPERATOR_ID))"]
    
    EXTRACT_CONTROL_4 --> EXTRACT_SVC_IF["Extract svcIf = mappingData[0][1]"]
    EXTRACT_SVC_IF --> CREATE_TEMPLATE["Create CAANMsg template with bundle eo.ejb.cbs.cbsmsg.{svcIf}CBSMsg"]
    
    CREATE_TEMPLATE --> SET_OPERATOR_DATE["template.set(OPERATOR_ID_KEY, param.getControlMapData(OPERATOR_ID))"]
    SET_OPERATOR_DATE --> SET_OPE_DATE["template.set(OPERATE_DATE_KEY, param.getControlMapData(OPE_DATE))"]
    SET_OPE_DATE --> SET_OPE_DATETIME["template.set(OPERATE_DATETIME_KEY, param.getControlMapData(OPE_TIME))"]
    
    SET_OPE_DATETIME --> LOOP_MAPPING_START["For loop: i from 0 to mappingData.length - 1"]
    
    LOOP_MAPPING_START --> CHECK_MAPPING_EMPTY{"Is mappingData[i][1] empty string?"}
    
    CHECK_MAPPING_EMPTY -->|Yes| SET_NULL_MAPPING["template.setNull(mappingData[i][0])"]
    CHECK_MAPPING_EMPTY -->|No| SET_MAPPING["template.set(mappingData[i][0], mappingData[i][1])"]
    
    SET_NULL_MAPPING --> LOOP_MAPPING_END{More mappingData items?}
    SET_MAPPING --> LOOP_MAPPING_END
    LOOP_MAPPING_END -->|Yes| LOOP_MAPPING_START
    LOOP_MAPPING_END -->|No| GET_CHILD_TEMPLATES["Get child templates: template.getCAANMsgList(inListMsgName)"]
    
    GET_CHILD_TEMPLATES --> CHECK_TEMPLATE_NULL{"Is templateArray == null?"}
    CHECK_TEMPLATE_NULL -->|Yes| INIT_ARRAY["templateArray = new CAANMsg[inList.size()]"]
    CHECK_TEMPLATE_NULL -->|No| LOOP_CHILD_START
    INIT_ARRAY --> LOOP_CHILD_START["For loop: i from 0 to inList.size() - 1"]
    
    LOOP_CHILD_START --> EXTRACT_CHILD_MAP["childMap = inList.get(i) as HashMap"]
    EXTRACT_CHILD_MAP --> EXTRACT_CHILD_TEMPLATE["childTemplate = templateArray[i]"]
    EXTRACT_CHILD_TEMPLATE --> CHECK_CHILD_TEMPLATE_NULL{"Is childTemplate == null?"}
    CHECK_CHILD_TEMPLATE_NULL -->|Yes| CREATE_CHILD_TEMPLATE["childTemplate = new CAANMsg(...{svcIf}CBSMsg1List)"]
    CHECK_CHILD_TEMPLATE_NULL -->|No| LOOP_KEYS_START
    CREATE_CHILD_TEMPLATE --> LOOP_KEYS_START["Iterator: iterate childMap.keySet()"]
    
    LOOP_KEYS_START --> CHECK_KEY_EMPTY{"Is childMap.get(key) empty string?"}
    
    CHECK_KEY_EMPTY -->|Yes| SET_NULL_CHILD["childTemplate.setNull(key)"]
    CHECK_KEY_EMPTY -->|No| SET_CHILD["childTemplate.set(key, childMap.get(key))"]
    
    SET_NULL_CHILD --> LOOP_KEYS_END{More keys?}
    SET_CHILD --> LOOP_KEYS_END
    LOOP_KEYS_END -->|Yes| LOOP_KEYS_START
    LOOP_KEYS_END -->|No| ASSIGN_CHILD["templateArray[i] = childTemplate"]
    
    ASSIGN_CHILD --> LOOP_CHILD_END{More inList items?}
    LOOP_CHILD_END -->|Yes| LOOP_CHILD_START
    LOOP_CHILD_END -->|No| SET_ARRAY_IN_TEMPLATE["template.set(inListMsgName, templateArray)"]
    
    SET_ARRAY_IN_TEMPLATE --> WRAP_TEMPLATE["Create CAANMsg[] templates = new CAANMsg[1]; templates[0] = template"]
    WRAP_TEMPLATE --> PUT_TEMPLATE_LIST["paramMap.put(TEMPLATE_LIST_KEY, templates)"]
    
    PUT_TEMPLATE_LIST --> RETURN["Return paramMap"]
    RETURN --> END(["End"])
```

**Processing flow summary:**
1. Create an empty `paramMap` to hold the final SC invocation payload.
2. Extract six telegram-context fields from the request parameter object (transaction ID, use case ID, operation ID, call type) and four control-map fields (client hostname, client IP, screen ID, operator ID), placing each into `paramMap` under its respective JCM constant key.
3. Extract the service interface name (`svcIf`) from `mappingData[0][1]` and instantiate the parent `CAANMsg` template with the bundle `eo.ejb.cbs.cbsmsg.{svcIf}CBSMsg`.
4. Set three additional fields on the parent template: operator ID, operation date, and operation datetime — all sourced from the control map.
5. Iterate over `mappingData` rows (index 1 onward). For each row, if the value (column index 1) is an empty string, nullify the field name (column index 0) in the template; otherwise, set the field to the value.
6. Retrieve any pre-existing child templates via `template.getCAANMsgList(inListMsgName)`. If null, allocate a new array sized to `inList.size()`.
7. Iterate over the `inList` list of child maps. For each child: if no pre-existing child template exists at that index, create a new `CAANMsg` with the per-item bundle `eo.ejb.cbs.cbsmsg.{svcIf}CBSMsg1List`; then iterate over each key in the child map, setting or nullifying the child template field based on whether the value is an empty string. Store the child template back into the array.
8. Attach the child template array to the parent template under the `inListMsgName` key.
9. Wrap the parent template in a single-element `CAANMsg[]` array, place it into `paramMap` under `TEMPLATE_LIST_KEY`, and return.

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `param` | `IRequestParameterReadWrite` | The request parameter object carrying the full request context: telegram identifiers (transaction ID, use case ID, operation ID), the SC call type discriminator, and a control map containing runtime metadata (client hostname, client IP address, source screen ID, operator ID, operation date/time, error info). This is the primary source of all contextual data used to build the SC invocation payload. |
| 2 | `mappingData` | `Object[][]` | A 2D mapping structure where each row represents a field-value pair for the CBS header template. Column 0 is the field name (key) and column 1 is the field value. An empty string value at column 1 signals that the field should be nullified in the template rather than set to an empty string. Row 0, column 1 is additionally used to derive the service interface name (`svcIf`) for template bundle selection. |
| 3 | `inListMsgName` | `String` | The key name under which the child template array will be stored in the parent `CAANMsg`. This acts as a reference identifier for the child-list segment of the CBS message envelope (e.g., "EKK1091D010CBSMsg1List" as seen in the caller). |
| 4 | `inList` | `ArrayList<HashMap<String, Object>>` | A list of child records, where each record is a map of field name to field value. Each map corresponds to one row of child/array data in the CBS message. The size of this list determines the size of the child template array. Empty string values in the maps trigger `setNull` on the corresponding child template fields. |

**External state / instance fields accessed:** None. This method is purely functional — it reads only from its parameters and does not access any instance variables of `JKKKikiIchiranKkUpdCC`.

## 4. CRUD Operations / Called Services

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| - | `CAANMsg.<constructor>` | - | - | Instantiates a parent CAANMsg template using the bundle name `eo.ejb.cbs.cbsmsg.{svcIf}CBSMsg` (Java object construction, no DB access) |
| - | `CAANMsg.set()` | - | - | Sets individual fields on the parent template (operator ID, operation date, operation datetime, mapping data fields, child template array) |
| - | `CAANMsg.setNull()` | - | - | Nullifies individual fields on the parent template when mapping data values are empty strings |
| - | `CAANMsg.getCAANMsgList()` | - | - | Retrieves pre-existing child templates from the parent template under the given list message name key |
| - | `CAANMsg.<constructor>` | - | - | Instantiates per-child-row CAANMsg templates using the bundle name `eo.ejb.cbs.cbsmsg.{svcIf}CBSMsg1List` |
| - | `CAANMsg.set()` | - | - | Sets individual fields on child templates by iterating over child map entries |
| - | `CAANMsg.setNull()` | - | - | Nullifies child template fields when child map values are empty strings |
| - | `CAANMsg.setInt()` (via `get`) | - | - | Called externally by `callSCArray` on the result to retrieve status code |

**Note:** This method itself does not invoke any Service Component (SC) code, read or write any database tables, or trigger external CBS processes. It is a pure data-assembler — a message builder that transforms request context and mapping data into a `paramMap` containing `CAANMsg` template structures. The actual SC invocation, database CRUD operations, and CBS execution occur in the caller `callSCArray()`, which passes the returned `paramMap` to `scCall.run()`. The method only manipulates in-memory Java objects (`HashMap`, `CAANMsg`) and does not perform any C/R/U/D operations on persistent storage.

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | JKKKikiIchiranKkUpdCC.callSCArray() | `JKKKikiIchiranKkUpdCC.callSCArray()` -> `JKKKikiIchiranKkUpdCC.editInArrayMsg()` | No terminal CRUD (paramMap returned to callSCArray, which then calls scCall.run() and editErrorInfoComArray) |

**Caller analysis:**
- **`callSCArray()`** (private method in the same class, JKKKikiIchiranKkUpdCC) — This is the sole direct caller. It is a reusable helper that: (1) calls `editInArrayMsg()` to build the parameter map, (2) invokes the SC call invoker (`scCall.run(paramMap, handle)`) with that map, (3) extracts the result template array and return code, (4) delegates error processing to `editErrorInfoComArray()`, and (5) throws `SCCallException` if the return code is non-zero or status is non-zero (with a v4.03.00 addition that suppresses the exception for warning status = 4). The caller uses this method to prepare message structures for CBS invocations — notably seen in the caller context at line 2275 where `callSCArray()` is invoked with `"EKK1091D010CBSMsg1List"` as the `inListMsgName`, indicating an SC code path related to the `EKK1091D010SC` service component.

No screen/batch entry points are directly visible in this method's call chain. Entry points would be screens that invoke `callSCArray()` or methods that ultimately call into this class, which would be further upstream in the call hierarchy (e.g., CBS methods or screen business processors).

## 6. Per-Branch Detail Blocks

### Block 1 — HashMap Creation (L2893)

Creates the parameter map that will be returned and passed to the SC call framework.

| # | Type | Code |
|---|------|------|
| 1 | SET | `paramMap = new HashMap<String, Object>()` |

### Block 2 — Extract Telegram Context from param (L2895-2899)

Extracts core message identifiers from the request parameter object. These are standard fields in every CBS message envelope.

> Source: 電文ヘッド(ヘッド) — Telegram Header (Header)

| # | Type | Code |
|---|------|------|
| 1 | SET | `paramMap.put(TRANZACTION_ID_KEY, param.getTelegramID())` // 電文ID — Transaction ID |
| 2 | SET | `paramMap.put(USECASE_ID_KEY, param.getUsecaseID())` // ユーケースID — Use Case ID |
| 3 | SET | `paramMap.put(OPERATION_ID_KEY, param.getOperationID())` // オペレーションID — Operation ID |
| 4 | SET | `paramMap.put(CALL_TYPE_KEY, param.getCallType())` // サービス呼び出し区分 — Service Call Type Discriminator |

### Block 3 — Extract Control Context from param (L2901-2909)

Extracts network and operational metadata from the control map.

> Source: ユーザエリア(コントロールマップ) — User Area (Control Map)

| # | Type | Code |
|---|------|------|
| 1 | SET | `paramMap.put(CLIENT_HOST_NAME_KEY, param.getControlMapData(REQ_HOSTNAME))` // 依頼先ホスト名 — Request Destination Hostname |
| 2 | SET | `paramMap.put(CLIENT_IP_ADDRESS_KEY, param.getControlMapData(REQ_HOSTIP))` // 依頼元IPアドレス — Request Source IP Address |
| 3 | SET | `paramMap.put(INVOKE_GAMEN_ID_KEY, param.getControlMapData(REQ_VIEWID))` // 依頼元画面ID — Request Source Screen ID |
| 4 | SET | `paramMap.put(OPERATOR_ID_KEY, param.getControlMapData(OPERATOR_ID))` // オペレータID — Operator ID |

### Block 4 — Extract Service Interface and Build Parent Template (L2911-2919)

Derives the service interface name from the mapping data and constructs the parent `CAANMsg` template with its bundle name. Then sets operator date/time fields on the template.

| # | Type | Code |
|---|------|------|
| 1 | SET | `svcIf = (String)mappingData[0][1]` // Service interface name from first mapping row |
| 2 | SET | `template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf))` // Bundle: eo.ejb.cbs.cbsmsg.{svcIf}CBSMsg |
| 3 | SET | `template.set(OPERATOR_ID_KEY, param.getControlMapData(OPERATOR_ID))` // オペレータID — Operator ID |
| 4 | SET | `template.set(OPERATE_DATE_KEY, param.getControlMapData(OPE_DATE))` // 運用日付 — Operation Date |
| 5 | SET | `template.set(OPERATE_DATETIME_KEY, param.getControlMapData(OPE_TIME))` // 運用日時 — Operation Date/Time |

### Block 5 — For Loop: Populate Parent Template from mappingData (L2921-2932)

Iterates over `mappingData` rows. Each row defines a field-value pair. Empty values at column 1 trigger field nullification.

| # | Type | Code |
|---|------|------|
| 1 | FOR | `for (int i = 0; i < mappingData.length; i++)` |

#### Block 5.1 — IF: Empty Value Check (L2922-2930)

| # | Type | Code |
|---|------|------|
| 1 | IF | `"".equals(mappingData[i][1])` — Branch: value is an empty string |

##### Block 5.1.1 — ELSE-IF: Non-Empty Value (L2926-2928)

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `template.setNull((String)mappingData[i][0])` // Nullify the field — フィールドをnull化 |
| 2 | ELSEIF | `mappingData[i][1]` is not empty |
| 3 | EXEC | `template.set((String)mappingData[i][0], mappingData[i][1])` // Set the field value — フィールド値を設定 |

### Block 6 — Retrieve and Build Child Template Array (L2934-2935)

Attempts to get pre-existing child templates from the parent template. If none exist, allocates a new array sized to the number of child records.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateArray = template.getCAANMsgList(inListMsgName)` // Retrieve child templates — 子テンプレートの取得 |
| 2 | IF | `templateArray == null` — No pre-existing child templates |

#### Block 6.1 — Null Array Initialization (L2937-2938)

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateArray = new CAANMsg[inList.size()]` // Allocate child template array — 子テンプレート配列の割り当て |

### Block 7 — For Loop: Build Child Templates from inList (L2941-2962)

Iterates over each child record in `inList`, builds or populates its corresponding `CAANMsg` template, and iterates over all key-value pairs within each child map.

| # | Type | Code |
|---|------|------|
| 1 | FOR | `for (int i = 0; i < inList.size(); i++)` |

#### Block 7.1 — Extract Child Map and Template (L2943-2944)

| # | Type | Code |
|---|------|------|
| 1 | SET | `childMap = (HashMap)inList.get(i)` // 子レコードマップ — Child record map |
| 2 | SET | `childTemplate = templateArray[i]` // Existing child template at index i — 該当インデックスの既存子テンプレート |

#### Block 7.2 — IF: No Pre-existing Child Template (L2945-2948)

If this is the first time processing a child at this index (no template was passed in from the parent template), create a new one using the per-item bundle name pattern.

| # | Type | Code |
|---|------|------|
| 1 | IF | `childTemplate == null` — No pre-existing child template for this index |

##### Block 7.2.1 — Create New Child Template (L2947)

| # | Type | Code |
|---|------|------|
| 1 | SET | `childTemplate = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg1List", svcIf))` // Bundle: eo.ejb.cbs.cbsmsg.{svcIf}CBSMsg1List — 個体テンプレートバンドル名 |

#### Block 7.3 — Iterate Child Map Keys (L2950-2960)

For each field in the child record map, set or nullify the corresponding field on the child template.

| # | Type | Code |
|---|------|------|
| 1 | SET | `it = childMap.keySet().iterator()` // 子マップのキーイテレータ — Iterator over child map keys |
| 2 | WHILE | `it.hasNext()` — More keys to process |

##### Block 7.3.1 — Extract Key (L2953)

| # | Type | Code |
|---|------|------|
| 1 | SET | `key = (String)it.next()` // フィールドキー — Field key |

##### Block 7.3.2 — IF: Empty Value Check (L2955-2960)

| # | Type | Code |
|---|------|------|
| 1 | IF | `"".equals(childMap.get(key))` — Branch: child value is an empty string |

###### Block 7.3.2.1 — ELSE-IF: Non-Empty Value (L2959)

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `childTemplate.setNull(key)` // Nullify child field — 子テンプレートフィールドをnull化 |
| 2 | ELSEIF | `childMap.get(key)` is not empty |
| 3 | EXEC | `childTemplate.set(key, (String)childMap.get(key))` // Set child field value — 子テンプレートフィールド値を設定 |

##### Block 7.3.3 — Assign Child Template (L2962)

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateArray[i] = childTemplate` // Store built child template back into array — 構築した子テンプレートを配列に保存 |

### Block 8 — Attach Child Templates to Parent (L2964)

Places the fully populated child template array into the parent template under the key specified by `inListMsgName`.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `template.set(inListMsgName, templateArray)` // Set child template array — 子テンプレート配列を設定 |

### Block 9 — Wrap and Return (L2966-2972)

Wraps the single parent template in a `CAANMsg[]` array, places it into the parameter map under `TEMPLATE_LIST_KEY`, and returns the map.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templates = new CAANMsg[1]` // Create single-element array — 1要素の配列を作成 |
| 2 | SET | `templates[0] = template` // Assign parent template — 親テンプレートを設定 |
| 3 | SET | `paramMap.put(TEMPLATE_LIST_KEY, templates)` // テンプレートリストキー — Template list key |
| 4 | RETURN | `return paramMap` // 引数マップを返す — Return parameter map |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `TRANZACTION_ID_KEY` | Constant | Transaction ID key — identifies the specific transaction/interaction in the system |
| `USECASE_ID_KEY` | Constant | Use Case ID key — identifies the business use case being executed |
| `OPERATION_ID_KEY` | Constant | Operation ID key — identifies the specific operation within a use case |
| `CALL_TYPE_KEY` | Constant | Call Type key — discriminator for the type of service call (e.g., CBS, SC) |
| `CLIENT_HOST_NAME_KEY` | Constant | Client Hostname key — the hostname of the requesting client |
| `CLIENT_IP_ADDRESS_KEY` | Constant | Client IP Address key — the IP address of the requesting client |
| `INVOKE_GAMEN_ID_KEY` | Constant | Invoke Screen ID key — the source screen that initiated the request |
| `OPERATOR_ID_KEY` | Constant | Operator ID key — the ID of the operator performing the action |
| `TEMPLATE_LIST_KEY` | Constant | Template List key — the key under which the `CAANMsg[]` template array is stored in the parameter map |
| `STATUS_INT_KEY` | Constant | Status integer key — used to retrieve the execution status code from SC response |
| `RET_CD_INT_KEY` | Constant | Return Code integer key — used to retrieve the return code from SC response |
| `REQ_HOSTNAME` | Constant | Request Hostname — control map key for the client hostname |
| `REQ_HOSTIP` | Constant | Request Host IP — control map key for the client IP address |
| `REQ_VIEWID` | Constant | Request View ID — control map key for the source screen ID |
| `OPERATOR_ID` | Constant | Operator ID — control map key for the operator ID |
| `OPE_DATE` | Constant | Operation Date — control map key for the operation date |
| `OPE_TIME` | Constant | Operation Time — control map key for the operation time |
| `CAANMsg` | Class | CBS Message object — a message structure used to carry CBS input/output parameters as key-value fields; supports `set()`, `setNull()`, `getInt()`, and `getCAANMsgList()` |
| `eo.ejb.cbs.cbsmsg.*CBSMsg` | Bundle | CBS message bundle naming pattern for the parent/header message template |
| `eo.ejb.cbs.cbsmsg.*CBSMsg1List` | Bundle | CBS message bundle naming pattern for per-child-row list templates |
| `IRequestParameterReadWrite` | Interface | Request parameter interface — provides access to telegram identifiers, call type, and control map data across the SC call framework |
| `SCControlMapKeys` | Class | Control map key constants — defines standard keys for runtime metadata like hostname, IP, screen ID, operator ID, operation date/time |
| `JCMConstants` | Class | JCM (Java Call Mechanism) constants — defines standard keys for transaction context, template lists, status codes, and return codes in SC call payloads |
| `SCCallException` | Class | SC Call Exception — thrown when the SC invocation returns a non-zero return code or non-zero status (except warning status = 4) |
| `svcIf` | Variable | Service Interface — the service interface name extracted from mappingData[0][1], used to construct CBS message bundle names |
| `mappingData` | Parameter | 2D mapping array — field-value pairs for the CBS header template; row 0 column 1 also provides the service interface name |
| `inListMsgName` | Parameter | Child list message name — the key under which the child template array is stored in the parent template |
| `inList` | Parameter | Child list — list of child record maps, each representing one row of array data in the CBS message |
| `templateArray` | Variable | Child template array — `CAANMsg[]` holding per-row child message templates |
| **電文ヘッド** | Japanese | Telegram Header — the header section of a CBS message containing transaction context |
| **ヘッダ** | Japanese | Header — same as above, the top-level message envelope |
| **電文ID** | Japanese | Transaction/Message ID — identifier for the specific message/transaction |
| **ユーケースID** | Japanese | Use Case ID — identifier for the business use case |
| **オペレーションID** | Japanese | Operation ID — identifier for the specific operation |
| **サービス呼び出し区分** | Japanese | Service Call Type — discriminator for the type of service call |
| **ユーザエリア** | Japanese | User Area — custom user-defined area in the request parameter |
| **コントロールマップ** | Japanese | Control Map — a map of runtime metadata (hostname, IP, screen ID, operator, date/time) |
| **依頼先ホスト名** | Japanese | Request Destination Hostname — the hostname of the target/destination client |
| **依頼元IPアドレス** | Japanese | Request Source IP Address — the IP address of the request source |
| **依頼元画面ID** | Japanese | Request Source Screen ID — the ID of the screen that initiated the request |
| **オペレータID** | Japanese | Operator ID — the ID of the operator performing the action |
| **運用日付** | Japanese | Operation Date — the business date for the operation |
| **運用日時** | Japanese | Operation Date/Time — the full timestamp for the operation |
| **フィールドをnull化** | Japanese | Nullify field — set a field to null in the message template (indicates absence rather than empty string) |
| **フィールド値を設定** | Japanese | Set field value — assign a value to a field in the message template |
| **子レコードマップ** | Japanese | Child record map — a single row of child/array data from the inList |
| **該当インデックスの既存子テンプレート** | Japanese | Existing child template at the corresponding index |
| **個体テンプレートバンドル名** | Japanese | Individual template bundle name — per-child-row message bundle |
| **子テンプレート配列の取得** | Japanese | Retrieve child template array — get pre-existing child templates from the parent |
| **子テンプレート配列を設定** | Japanese | Set child template array — attach the built child templates to the parent |
| **1要素の配列を作成** | Japanese | Create single-element array — wrap the parent template in a one-element CAANMsg array |
| **親テンプレートを設定** | Japanese | Set parent template — assign the parent template as the sole element |
| **テンプレートリストキー** | Japanese | Template list key — the key used to store the template array in the parameter map |
| **引数マップを返す** | Japanese | Return parameter map — return the assembled paramMap to the caller |
| **構築した子テンプレートを配列に保存** | Japanese | Save constructed child template to array — store the built child template back into the template array |
| **子テンプレートフィールドをnull化** | Japanese | Nullify child template field |
| **子テンプレートフィールド値を設定** | Japanese | Set child template field value |
| **子マップのキーイテレータ** | Japanese | Iterator over child map keys |
| **フィールドキー** | Japanese | Field key — the name of a field in the CBS message template |
| **CSBMsg** | Abbreviation | CBS Message — a message structure used in the Fujitsu Futurity SC framework for CBS (Common Business Service) communication |
| **SC** | Abbreviation | Service Component — the service component layer that executes CBS processes |
| **CBS** | Abbreviation | Common Business Service — the shared service layer for business logic execution |
| **CAANMsg** | Abbreviation | CBS Message Object — the message structure used to carry parameters to and from CBS processes |
| **SCControlMapKeys** | Abbreviation | SC Control Map Keys — standard keys for runtime metadata in the SC framework |
| **JCMConstants** | Abbreviation | JCM (Java Call Mechanism) Constants — standard keys for SC call payloads |