# Getting Started

Welcome! If you're reading this, you're about to dive into a Java-based codebase that models business data structures through three interrelated classes. This repository implements a lightweight domain model for a workflow or processing system where patterns are organized into hierarchical categories.

## What This Project Does

This project is a small Java library that defines business processing entities -- specifically service identifiers, classification codes, and processing categories. The classes form a directed dependency graph, with `Mixed` acting as the central aggregation point that references both `PatternA` and `PatternB`. The domain appears to support a service interface layer where processing categories, service identifiers, and classification codes are managed.

## Recommended Reading Order

If you're new to this codebase, read in this order:

1. **[PatternB](src\main\java\PatternB.java)** -- The smallest class and the foundation. It defines the base data contract (service interface ID and identification code). Understanding this gives you the base vocabulary.

2. **[PatternA](src\main\java\PatternA.java)** -- Builds on `PatternB` and introduces the processing classification concept (`syoriDiv`, or "processing category"). This shows how the patterns compose.

3. **[Mixed](src\main\java\Mixed.java)** -- The central class that references both patterns, tying the full picture together at the application level.

4. **[Repository Overview](overview.md)** -- Read the full architecture doc for dependency diagrams, module descriptions, and technology stack details.

## Key Entry Points

The most important classes to understand first:

- **`Mixed`** -- The primary integration point. This aggregation class holds an `englishOnly` string and an unlabeled field, and it references both `PatternA` and `PatternB`. Start here once you understand the leaf patterns.

- **`PatternA`** -- Defines the processing classification field (`syoriDiv`). It depends on `PatternB`, suggesting processing logic builds on top of service-level identifiers.

- **`PatternB`** -- The leaf class with no outgoing dependencies. Holds `templateID` (service interface ID) and `identifyCD` (identification code). This is the foundational data contract.

## Project Structure

The codebase uses the default (unnamed) Java package -- no subpackages or multi-module layout:

```
root/
  src/main/java/
    Mixed.java        -- Central aggregation class
    PatternA.java     -- Processing classification class
    PatternB.java     -- Foundational service identifiers
  .codewiki/
    overview.md       -- Full architecture reference
```

All three classes sit flat under `src/main/java/`, so there's no package-level nesting to navigate. The code is intentionally lightweight -- each class contains only field declarations, making it straightforward to scan the full codebase in a single pass.

## Configuration

This project is deliberately minimal and does not include any configuration files (no `pom.xml`, `build.gradle`, `application.properties`, etc.) beyond what's tracked in version control. Key conventions:

- **Default package** -- All classes use the default (unnamed) package. No `package` declaration is used.
- **Field initialization** -- All fields are initialized to empty strings (`""`) by default.
- **No external dependencies** -- No frameworks (Spring, Hibernate, Jackson) or third-party libraries are used.
- **Comment markers** -- `PatternA.java` includes `// ANK-0001 ADD START / END` comment blocks around the `syoriDiv` field, indicating a changelist or ticket-based modification pattern.
- **Japanese comments** -- Several fields carry Japanese comment annotations (e.g., `syoriDiv` is annotated with `処理区分`, `templateID` with `サービスIF_ID`), suggesting this code interfaces with a Japanese-language business system.

## Common Patterns

The codebase follows these conventions throughout:

- **Plain POJOs** -- All classes are Plain Old Java Objects. No annotations, no interfaces, no abstract base classes. Just fields with default-initialized values.

- **Directed dependency chain** -- Dependencies flow in one direction: `Mixed` references both `PatternA` and `PatternB`, while `PatternA` references `PatternB`. `PatternB` is the leaf with no outgoing dependencies.

```mermaid
flowchart LR
    Mixed["Mixed"] --> PatternA["PatternA"]
    Mixed["Mixed"] --> PatternB["PatternB"]
    PatternA["PatternA"] --> PatternB["PatternB"]
```

- **String-based identifiers** -- All fields are typed as `String`. IDs, codes, and classification values are all represented as strings rather than custom types or enums.

- **Field-only classes** -- Each class contains only private field declarations. No methods, constructors, getters, or setters are defined in the current code.

## Quick Reference

| File | Purpose | Key Fields |
|------|---------|------------|
| [Mixed.java](src\main\java\Mixed.java) | Central aggregation | `englishOnly`, `unlabeled` |
| [PatternA.java](src\main\java\PatternA.java) | Processing classification | `syoriDiv` |
| [PatternB.java](src\main\java\PatternB.java) | Service identifiers | `templateID`, `identifyCD` |