# Der generierte Code

Alle Dateien eines `aura_add_ui` ergeben `aura_gen/aura_ui.h` und je Datei eine `.cpp` im Build-Verzeichnis. `aurac` schreibt nur geänderte Dateien neu. Jedes Element steht mit `Datei:Zeile:Spalte` als Kommentar im Code.

```cpp
namespace views {
struct CartLine {
	std::string description{};
	double quantity{};
	...
};
aura::ui::Value toValue(const CartLine& r);     // dynamischer Modus
aura::ui::Value toValue(const std::vector<CartLine>& list);

struct ShoppingCartArgs {
	std::vector<CartLine> lines{};
	std::string total{};
	bool canOrder{};
};
struct ShoppingCart {
	aura::ui::RectNode* root = nullptr;
	std::vector<CartLine> lines{};
	void setLines(const std::vector<CartLine>& v);  // Zustand
	...
	std::weak_ptr<aura::Bindings> bindings;
	aura::ui::ScrollNode* list = nullptr;            // IDs
	std::vector<std::shared_ptr<CartRow>> row;      // in einer Wiederholung
	std::function<void()> more;                     // Signale
	std::function<void(double)> edit;
	static std::shared_ptr<ShoppingCart> build(aura::ui::RectNode& frame,
		const aura::ui::BasicContext<>& ctx, const ShoppingCartArgs& args = {});
};
}
```

- **Dialoge und Screens** haben `static size()` (nur Dialoge) und `static build()`; **Komponenten** ein `NameArgs` und `build<Name>(parent, ctx, args, instance)`, wobei `instance` die Wurzel nach den eigenen Properties und vor den Kindern bekommt (wie Instanz-Properties).
- **Felder:** Zustand (mit Setter), IDs (Node-Zeiger, für Komponenten `std::shared_ptr<Komponente>`, in Wiederholungen Vektoren) und Signale (`std::function`).
- **Lebensdauer:** Das Struct hängt an seinem Wurzel-Node (`Node::attach`: Rahmen bzw. Komponentenwurzel) und lebt, solange der lebt. Die App muss es nicht aufbewahren.
- **Signale** werden erst beim Auslösen gelesen und dürfen deshalb nach `build()` gesetzt werden.
- **Dynamischer Modus:** `build()` fragt zuerst den Loader (Argumente als `aura::ui::Value`, Datensätze über `toValue()`). Hat der die Datei geladen, füllt `load<Name>()` das Struct: IDs, die Structs der Komponenten-Instanzen (einmal pro Instanz, auch verschachtelt), Signale und nach jedem Neuaufbau eines Blocks wieder die IDs. Sonst läuft der kompilierte Aufbau.