# Business Logic — KKW02701SFLogic.isRouterSpeedCheckResult() [109 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `eo.web.webview.KKW02701SF.KKW02701SFLogic` |
| Layer | Service Logic (Web View Logic) |
| Module | `KKW02701SF` (Package: `eo.web.webview.KKW02701SF`) |

## 1. Role

### KKW02701SFLogic.isRouterSpeedCheckResult()

This method performs a **router speed course validation check** as part of the service contract change flow (提供機器サービス情報の関連チェック, related check for provisioning service information). It validates that the combination of a customer's owned router type (保有ルーターコード) and the requested router speed subtype (ルーター速度種別コード) maps to an appropriate pricing course code (料金コースコード, pcrsCd). The method implements a **routing/dispatch pattern**: for each candidate service line item in the work list, it checks whether the router/speed combination has a valid pricing course match by delegating to three helper methods — `isRcrs10G()`, `isRcrsRouter10()`, and `isRcrsRouter20()` — each of which checks the current pricing course against a predefined set of valid course codes for that tier. The design follows a **guard-clause early-return pattern** for precondition validation (checking that all required data maps exist), followed by an **iterative validation loop** that scans the work list and short-circuits on the first valid match. If no valid combination is found across all work list items, the method returns `false`, which signals to the caller that an exception exists in the router speed course mapping. This is a **shared internal utility** called by `forwardRsvClCfm()` to gate whether the confirmation screen can proceed.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["isRouterSpeedCheckResult outputMap svcFormBean"])
    
    START --> CHECK1["Check: outputMap contains KKSV039504CC?"]
    
    CHECK1 -->|No| PASS1["Return true"]
    CHECK1 -->|Yes| GET1["Get idoRsvMsg = outputMap.KKSV039504CC"]
    
    GET1 --> CHECK2["Check: idoRsvMsg == null?"]
    
    CHECK2 -->|Yes| PASS2["Return true"]
    CHECK2 -->|No| CHECK3["Check: idoRsvMsg contains old_pcrs_cd?"]
    
    CHECK3 -->|No| PASS3["Return true"]
    CHECK3 -->|Yes| GET_PCRS["curPcrsCd = idoRsvMsg.old_pcrsCd.toString()"]
    
    GET_PCRS --> CHECK4["Check: outputMap contains KKSV039502CC?"]
    
    CHECK4 -->|No| PASS4["Return true"]
    CHECK4 -->|Yes| GET2["Get kktksvMsg = outputMap.KKSV039502CC"]
    
    GET2 --> CHECK5["Check: kktksvMsg == null?"]
    
    CHECK5 -->|Yes| PASS5["Return true"]
    CHECK5 -->|No| GET_LIST["workList = kktksvMsg.kktkSvKeiDelCCList"]
    
    GET_LIST --> INIT["checkFlg = false"]
    
    INIT --> LOOP["for each workMap in workList"]
    
    LOOP --> CHECK6["Check: workMap.hoyu_router_cd == null OR workMap.router_speed_cd == null?"]
    
    CHECK6 -->|Yes| SKIP["continue - skip to next iteration"]
    SKIP --> LOOP
    
    CHECK6 -->|No| EXTRACT["hoyuRouterCd = workMap.hoyu_routerCd.toString()"]
    
    EXTRACT --> BLOCK1["Check: hoyuRouterCd in Basic group?"]
    
    BLOCK1 -->|No| SKIP_NEXT["skip to next iteration"]
    
    BLOCK1 -->|Yes| CHECK10G["isRcrs10G(curPcrsCd)"]
    
    CHECK10G -->|Yes| SET_TRUE1["checkFlg = true, break"]
    SET_TRUE1 --> VALID_END["Valid match found - proceed to final check"]
    
    CHECK10G -->|No| SKIP_NEXT
    
    SKIP_NEXT --> BLOCK2["Check: hoyuRouterCd = TKCD043_BASIC = '01' AND routerSpeedSbtCd = ROUTER_SPEED_SBT_CD_10 = '10'?"]
    
    BLOCK2 -->|Yes| CHECK_ROUTER10["isRcrsRouter10(curPcrsCd)"]
    
    CHECK_ROUTER10 -->|Yes| SET_TRUE2["checkFlg = true, break"]
    SET_TRUE2 --> VALID_END
    
    CHECK_ROUTER10 -->|No| SKIP_NEXT2["skip to next iteration"]
    
    SKIP_NEXT2 --> BLOCK3["Check: hoyuRouterCd = TKCD043_BASICGIGA = '02' AND routerSpeedSbtCd = ROUTER_SPEED_SBT_CD_20 = '20'?"]
    
    BLOCK3 -->|Yes| CHECK_ROUTER20["isRcrsRouter20(curPcrsCd)"]
    
    CHECK_ROUTER20 -->|Yes| SET_TRUE3["checkFlg = true, break"]
    SET_TRUE3 --> VALID_END
    
    CHECK_ROUTER20 -->|No| SKIP_NEXT3["skip to next iteration"]
    
    SKIP_NEXT3 --> BLOCK4["Check: hoyuRouterCd = TKCD043_KYUMUSEN = '03' AND routerSpeedSbtCd = ROUTER_SPEED_SBT_CD_10 = '10'?"]
    
    BLOCK4 -->|Yes| CHECK_ROUTER10_3["isRcrsRouter10(curPcrsCd)"]
    
    CHECK_ROUTER10_3 -->|Yes| SET_TRUE4["checkFlg = true, break"]
    SET_TRUE4 --> VALID_END
    
    CHECK_ROUTER10_3 -->|No| SKIP_NEXT4["skip to next iteration"]
    
    SKIP_NEXT4 --> BLOCK5["Check: hoyuRouterCd = TKCD043_SHINMUSEN = '04' AND routerSpeedSbtCd = ROUTER_SPEED_SBT_CD_10 = '10'?"]
    
    BLOCK5 -->|Yes| CHECK_ROUTER10_4["isRcrsRouter10(curPcrsCd)"]
    
    CHECK_ROUTER10_4 -->|Yes| SET_TRUE5["checkFlg = true, break"]
    SET_TRUE5 --> VALID_END
    
    CHECK_ROUTER10_4 -->|No| BLOCK6["Check: hoyuRouterCd = TKCD043_SHINMUSENGIGA = '05' AND routerSpeedSbtCd = ROUTER_SPEED_SBT_CD_20 = '20'?"]
    
    BLOCK6 -->|Yes| NOOP["No-op - no route course check performed"]
    
    NOOP --> SKIP_NEXT5["skip to next iteration"]
    
    SKIP_NEXT5 --> LOOP_END["End of workList?"]
    
    LOOP_END -->|No| LOOP
    
    LOOP_END -->|Yes| FINAL["Check: checkFlg == false?"]
    
    FINAL -->|Yes| PASS6["Return true - no valid combination found"]
    
    FINAL -->|No| INVALID["Return false - invalid router speed course combination detected"]
    
    INVALID --> END(["END"])
    PASS6 --> END
    
    PASS1 --> END
    PASS2 --> END
    PASS3 --> END
    PASS4 --> END
    PASS5 --> END
    VALID_END --> FINAL
```

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `outputMap` | `HashMap<String, Object>` | A map aggregating service processing results from preceding components. It is keyed by component IDs (`KKSV039504CC`, `KKSV039502CC`) that carry the old pricing course code (`old_pcrs_cd`) and the list of target service line items (`kktkSvKeiDelCCList`) containing owned router codes and router speed subtype codes for each line item being validated. |
| 2 | `svcFormBean` | `X31SDataBeanAccess` | The screen bean carrying form data for the KKW02701SF screen. It is passed as a parameter but **is not actively read** within this method — it is preserved for API compatibility with the caller and potential future use. |

**External state read:**
- `KKKCommonConst.TKCD043_*` constants (owned router type codes: Basic, Basic Giga, Old Wireless, New Wireless, New Wireless Giga)
- `KKW02701SFConst.ROUTER_SPEED_SBT_CD_10/20` constants (router speed subtype codes: 100M, 1G)
- Private static constants `PCRS_CD_A**` (pricing course codes for various subscription types)
- Internal helper methods: `isRcrs10G()`, `isRcrsRouter10()`, `isRcrsRouter20()` — each checks whether a pricing course code falls within a valid tier for 10G/100M/1G router speeds

## 4. CRUD Operations / Called Services

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

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `isRcrs10G` | KKW02701SFLogic | - | Reads pricing course codes against the 10G tier list — checks if the current pricing course code matches any valid 10G course (A74, A83, A84, A89, A90, A93, A94, A95, A96, A97, A99) |
| R | `isRcrsRouter10` | KKW02701SFLogic | - | Reads pricing course codes against the 100M tier list — checks if the current pricing course code matches any valid 100M course (A05, A07, A10, A91, A92, A11, A55, A57) |
| R | `isRcrsRouter20` | KKW02701SFLogic | - | Reads pricing course codes against the 1G tier list — checks if the current pricing course code matches any valid 1G course (A03, A04, A06, A08, A09, A47, A48, A49, A50, A51, A52, A53, A54, A56) |

This method performs **Read-only** operations. No data is created, updated, or deleted. It validates data against a static lookup of pricing course codes, delegating the actual comparison to three internal helper methods that each perform a pure comparison against predefined constant sets.

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Screen:KKW02701SF | `forwardRsvClCfm()` -> `isRouterSpeedCheckResult(outputMap, svcFormBean)` | `isRcrs10G` [-], `isRcrsRouter10` [-], `isRcrsRouter20` [-] |

**Caller: `KKW02701SFLogic.forwardRsvClCfm()`** — This is the screen confirmation handler for the KKW02701SF screen (router speed course change confirmation). It calls `isRouterSpeedCheckResult()` to validate that the router speed and pricing course combination is correct before proceeding with the confirmation. If the method returns `false`, an error is triggered (the caller checks `!isRouterSpeedCheckResult(...)` at line 375, implying an error dialog or rejection).

**Terminal operations from this method:**
- `isRcrs10G()` — Reads against constant set (no DB)
- `isRcrsRouter10()` — Reads against constant set (no DB)
- `isRcrsRouter20()` — Reads against constant set (no DB)

All terminal operations are **pure constant lookups** — no database or external service calls are made.

## 6. Per-Branch Detail Blocks

**Block 1** — IF `(outputMap does not contain "KKSV039504CC")` (L1211)

> Guard clause: If the output map does not contain the component data key for the routing/reservation message, there is no service information to validate, so the check passes.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return true` — No service information, pass validation |

**Block 2** — IF / SET `(outputMap contains KKSV039504CC, extract idoRsvMsg)` (L1217)

> Extract the routing/reservation message map from the output map.

| # | Type | Code |
|---|------|------|
| 1 | SET | `idoRsvMsg = (HashMap)outputMap.get("KKSV039504CC")` |

**Block 2.1** — IF `(idoRsvMsg == null)` (L1218)

> Guard clause: If the extracted map is null, there is no service data.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return true` — Empty service info, pass validation |

**Block 3** — IF `(!idoRsvMsg.containsKey("old_pcrs_cd"))` (L1224)

> Guard clause: If the old pricing course code is absent, nothing to validate.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return true` — No PCR code, pass validation |

**Block 4** — SET `(extract curPcrsCd)` (L1227)

> Extract the current pricing course code from the old pricing course field.

| # | Type | Code |
|---|------|------|
| 1 | SET | `curPcrsCd = idoRsvMsg.get("old_pcrs_cd").toString()` |

**Block 5** — IF `(outputMap does not contain "KKSV039502CC")` (L1230)

> Guard clause: If the kktkSvKeiDelCC component is absent, no service line items to check.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return true` — No kktkSvKeiDelCC, pass validation |

**Block 6** — IF / SET `(extract kktksvMsg)` (L1233)

> Extract the service line item map from the output map.

| # | Type | Code |
|---|------|------|
| 1 | SET | `kktksvMsg = (HashMap)outputMap.get("KKSV039502CC")` |

**Block 6.1** — IF `(kktksvMsg == null)` (L1234)

> Guard clause: If the extracted map is null.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return true` — Empty kktkSvKeiDelCC, pass validation |

**Block 7** — SET `(extract workList and init checkFlg)` (L1238)

> Extract the list of service line item maps and initialize the validation flag.

| # | Type | Code |
|---|------|------|
| 1 | SET | `workList = (ArrayList)kktksvMsg.get("kktkSvKeiDelCCList")` |
| 2 | SET | `checkFlg = false` |

**Block 8** — FOR-EACH `(for each workMap in workList)` (L1240)

> Iterate through each service line item in the target list. For each, extract the owned router code and router speed subtype code, then check if the pricing course code matches the expected tier for that combination.

**Block 8.1** — IF `(workMap.hoyu_router_cd == null OR workMap.router_speed_cd == null)` (L1242)

> Skip items that have incomplete data. A null router code or speed code means the line item is not actionable for this check.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `continue` — Skip this workMap, process next iteration |

**Block 8.2** — SET `(extract hoyuRouterCd and routerSpeedSbtCd)` (L1247)

> Extract the owned router code and router speed subtype code from the current workMap.

| # | Type | Code |
|---|------|------|
| 1 | SET | `hoyuRouterCd = workMap.get("hoyu_router_cd").toString()` |
| 2 | SET | `routerSpeedSbtCd = workMap.get("router_speed_cd").toString()` |

**Block 8.3** — IF (IT2-2016-0000004 ADD: Basic group 10G check) `(TKCD043_BASIC OR TKCD043_BASICGIGA OR TKCD043_KYUMUSEN OR TKCD043_SHINMUSEN OR TKCD043_SHINMUSENGIGA)` (L1254)

> IT2-2016-0000004 (2016/02/22 ADD): For owned router types in the "Basic" group (Basic 01, Basic Giga 02, Old Wireless 03, New Wireless 04, New Wireless Giga 05), check if the pricing course code is a 10G course. This covers the scenario where 10G courses apply regardless of the specific basic router type.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `isRcrs10G(curPcrsCd)` — Checks if pricing course matches 10G tier |
| 2 | IF | Result of isRcrs10G |

**Block 8.3.1** — IF `isRcrs10G(curPcrsCd) == true` (L1256)

> The pricing course code is valid for a 10G router speed tier.

| # | Type | Code |
|---|------|------|
| 1 | SET | `checkFlg = true` — Valid 10G combination found |
| 2 | EXEC | `break` — Exit the loop early |

**Block 8.4** — IF / ELSE-IF `(TKCD043_BASIC = "01" AND ROUTER_SPEED_SBT_CD_10 = "10")` (L1265)

> Owned Router: 01 (Basic) + Router Speed Subtype: 10 (100M) — Check if the pricing course code is valid for a 100M router.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `isRcrsRouter10(curPcrsCd)` — Checks if pricing course matches 100M tier |
| 2 | IF | Result of isRcrsRouter10 |

**Block 8.4.1** — IF `isRcrsRouter10(curPcrsCd) == true` (L1267)

> The pricing course code is valid for a 100M Basic router.

| # | Type | Code |
|---|------|------|
| 1 | SET | `checkFlg = true` |
| 2 | EXEC | `break` |

**Block 8.5** — ELSE-IF `(TKCD043_BASICGIGA = "02" AND ROUTER_SPEED_SBT_CD_20 = "20")` (L1274)

> Owned Router: 02 (Basic Giga) + Router Speed Subtype: 20 (1G) — Check if the pricing course code is valid for a 1G router.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `isRcrsRouter20(curPcrsCd)` — Checks if pricing course matches 1G tier |
| 2 | IF | Result of isRcrsRouter20 |

**Block 8.5.1** — IF `isRcrsRouter20(curPcrsCd) == true` (L1276)

> The pricing course code is valid for a 1G Basic Giga router.

| # | Type | Code |
|---|------|------|
| 1 | SET | `checkFlg = true` |
| 2 | EXEC | `break` |

**Block 8.6** — ELSE-IF `(TKCD043_KYUMUSEN = "03" AND ROUTER_SPEED_SBT_CD_10 = "10")` (L1283)

> Owned Router: 03 (Old Wireless) + Router Speed Subtype: 10 (100M) — Check if the pricing course code is valid for a 100M Old Wireless router.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `isRcrsRouter10(curPcrsCd)` — Checks if pricing course matches 100M tier |
| 2 | IF | Result of isRcrsRouter10 |

**Block 8.6.1** — IF `isRcrsRouter10(curPcrsCd) == true` (L1285)

> The pricing course code is valid for a 100M Old Wireless router.

| # | Type | Code |
|---|------|------|
| 1 | SET | `checkFlg = true` |
| 2 | EXEC | `break` |

**Block 8.7** — ELSE-IF `(TKCD043_SHINMUSEN = "04" AND ROUTER_SPEED_SBT_CD_10 = "10")` (L1292)

> Owned Router: 04 (New Wireless) + Router Speed Subtype: 10 (100M) — Check if the pricing course code is valid for a 100M New Wireless router.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `isRcrsRouter10(curPcrsCd)` — Checks if pricing course matches 100M tier |
| 2 | IF | Result of isRcrsRouter10 |

**Block 8.7.1** — IF `isRcrsRouter10(curPcrsCd) == true` (L1294)

> The pricing course code is valid for a 100M New Wireless router.

| # | Type | Code |
|---|------|------|
| 1 | SET | `checkFlg = true` |
| 2 | EXEC | `break` |

**Block 8.8** — ELSE-IF `(TKCD043_SHINMUSENGIGA = "05" AND ROUTER_SPEED_SBT_CD_20 = "20")` (L1301)

> Owned Router: 05 (New Wireless Giga) + Router Speed Subtype: 20 (1G) — No-op branch.

> Comment: 判定なし (No judgment performed). This combination is explicitly listed but performs no validation — it falls through without setting `checkFlg`, effectively treating it as an invalid combination (the loop continues to the next item).

| # | Type | Code |
|---|------|------|
| 1 | EXEC | No-op — No route course check is performed for this combination |

**Block 9** — IF `(checkFlg == false)` (L1308)

> After iterating through all work list items, if no valid router speed course combination was found (`checkFlg` remains `false`), the method returns `true`. This means: if none of the service line items have a valid combination, the check is considered passed (the mismatch is not treated as an error).

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return true` — No valid combination found, pass validation |

**Block 10** — RETURN `(default)` (L1312)

> If `checkFlg` is `true` (a valid combination was found in the work list), return `false`.

> Business interpretation: The method name `isRouterSpeedCheckResult` returns `false` when a valid router speed course combination IS detected. This inverted return semantics suggests the caller interprets `false` as "error found — the course combination needs attention." The caller (`forwardRsvClCfm()`) checks `!isRouterSpeedCheckResult(...)` — so `false` triggers the error path.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return false` — Valid combination found, flag error condition |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `hoyu_router_cd` | Field | Owned router code (保有ルーターコード) — Identifies the type of router owned by the customer (Basic, Basic Giga, Old Wireless, New Wireless, New Wireless Giga) |
| `router_speed_cd` | Field | Router speed subtype code (ルーター速度種別コード) — Indicates the speed tier of the router (10 = 100M, 20 = 1G) |
| `old_pcrs_cd` | Field | Old pricing course code (変更前料金コースコード) — The pricing course code before the service change. Used as the baseline for validation against expected course mappings. |
| `kktkSvKeiDelCCList` | Field | Service line item deletion check list (サービス契約削除チェックリスト) — List of service contract line items being processed for validation. Each entry contains owned router and speed information. |
| `KKSV039504CC` | Key | Component ID for routing/reservation message data in outputMap — carries the old pricing course code (`old_pcrs_cd`) |
| `KKSV039502CC` | Key | Component ID for service line item deletion check data in outputMap — carries the `kktkSvKeiDelCCList` work list |
| TKCD043_BASIC | Constant | Owned router code = "01" (Basic router) |
| TKCD043_BASICGIGA | Constant | Owned router code = "02" (Basic Giga router) |
| TKCD043_KYUMUSEN | Constant | Owned router code = "03" (Old Wireless router) |
| TKCD043_SHINMUSEN | Constant | Owned router code = "04" (New Wireless router) |
| TKCD043_SHINMUSENGIGA | Constant | Owned router code = "05" (New Wireless Giga router) |
| ROUTER_SPEED_SBT_CD_10 | Constant | Router speed subtype = "10" (100M bandwidth tier) |
| ROUTER_SPEED_SBT_CD_20 | Constant | Router speed subtype = "20" (1G bandwidth tier) |
| PCRS_CD_A03 | Constant | Pricing course code A03 — 3G 7.2M standard type (variable) |
| PCRS_CD_A04 | Constant | Pricing course code A04 — 3G 7.2M standard type (variable) |
| PCRS_CD_A05 | Constant | Pricing course code A05 — FTTH standard type (100M tier) |
| PCRS_CD_A06 | Constant | Pricing course code A06 — 3G 7.2M standard type (variable) |
| PCRS_CD_A07 | Constant | Pricing course code A07 — FTTH standard type (100M tier) |
| PCRS_CD_A08 | Constant | Pricing course code A08 — 3G 7.2M standard type (variable) |
| PCRS_CD_A09 | Constant | Pricing course code A09 — 3G 7.2M standard type (variable) |
| PCRS_CD_A10 | Constant | Pricing course code A10 — FTTH standard type (100M tier) |
| PCRS_CD_A11 | Constant | Pricing course code A11 — FTTH standard type (100M tier, mansion type) |
| PCRS_CD_A26 | Constant | Pricing course code A26 — 3G 7.2M standard type |
| PCRS_CD_A47-A57 | Constant | Pricing course codes for mansion-type plans: A47 (100M VDSL1), A48 (100M VDSL2), A49 (100M ISA Net), A50 (100M VDSL2 Global), A51 (100M VDSL3 Global), A52 (100M VDSL4 Global), A53 (100M VDSL5 Global), A54 (100M ISA Net Global), A55 (1G ISA Net Global), A56 (100M optical line Global), A57 (1G optical line Global) |
| PCRS_CD_A59 | Constant | Pricing course code A59 — 3G 7.2M optical hybrid type |
| PCRS_CD_A74 | Constant | Pricing course code A74 — eo Light Net & Mansion optical line 10G course |
| PCRS_CD_A83, A84 | Constant | Pricing course codes for 10G courses |
| PCRS_CD_A89, A90, A93-A97, A99 | Constant | Pricing course codes for 10G and 10G Netflix pack courses |
| isRcrs10G | Method | Checks if a pricing course code belongs to the 10G (10-gigabit) speed tier |
| isRcrsRouter10 | Method | Checks if a pricing course code belongs to the 100M router speed tier |
| isRcrsRouter20 | Method | Checks if a pricing course code belongs to the 1G router speed tier |
| pcrsCd | Field | Pricing course code (料金コースコード) — Internal code identifying a specific subscription pricing plan |
| svc_kei_no | Field | Service contract number (サービス契約番号) — Unique identifier for a service contract line item |
| KKW02701SF | Module | Screen module for router speed course change confirmation — processes service contract changes involving router speed tiers |
| 保有ルーター | Business term | Owned router — The router equipment owned or leased by the customer |
| ルーター速度種別 | Business term | Router speed subtype — Classification of router speed (100M or 1G) |
| 料金コース | Business term | Pricing course — The subscription billing plan a customer is enrolled in |
| 提供機器サービス情報 | Business term | Provisioning service information — Data about the equipment and services being provided to the customer |
| 関連チェック | Business term | Related check — A validation step that verifies consistency across related data fields |
| checkFlg | Field | Check flag (チェックフラグ) — Internal flag indicating whether a valid router speed course combination was found during iteration |