Welche Unit brauche ich?
Task-orientierter Wegweiser durch die Standardbibliothek. Ausgangspunkt ist immer die konkrete Aufgabe — nicht der Namespace. Jede Zeile verweist auf die präziseste Unit; Links direkt zur Detailseite.
→ Alle Units alphabetisch · Erste Schritte
Netzwerk & Kommunikation
| Ich will … | Unit |
|---|---|
| TCP-Verbindung aufbauen (Client) | std.net.socket |
| TCP-Server bauen (wenige Verbindungen) | std.net.socket |
| TCP-Server bauen (1 000+ gleichzeitige Verbindungen) | std.net.epoll + std.net.socket |
| HTTP-Request (GET/POST) absetzen | std.net.http |
| HTTPS-Request absetzen | std.net.https |
| REST-API aufrufen (Base-URL, Auth, JSON) | std.net.rest (RestClientInit + RestGet / RestJsonPost) |
| Bearer-Token für REST-Session setzen | std.net.rest (RestClientSetBearerToken) |
| API-Key-Header für REST-Session setzen | std.net.rest (RestClientSetApiKey) |
| Query-Parameter percent-kodiert anhängen | std.net.rest (RestQueryAppend) |
| HTTP-Statuscode-Klasse prüfen (2xx / 4xx / 5xx) | std.net.rest (RestIsSuccess / RestIsClientError / RestIsServerError) |
| TLS-Verbindung manuell aufbauen | std.net.tls |
| Domain-Name auflösen (DNS) | std.net.dns |
| E-Mail versenden (SMTP) | std.net.smtp |
| E-Mails abrufen (IMAP) | std.net.imap |
| SSH-Befehl remote ausführen | std.net.ssh |
| IoT-Gerät via MQTT anbinden | std.net.mqtt |
| Zeit per NTP synchronisieren | std.net.ntp |
| IP-Adresse per DHCP beziehen (vollständiger Lease) | std.net.dhcp (DhcpLease) |
| MAC-Adresse für eine IP auflösen (ARP-Cache lesen) | std.net.arp (ArpResolve) — kein root, kein Raw-Socket |
| ARP-Request-Frame bauen (Layer-2-Broadcast) | std.net.arp (ArpBuildRequest) — Senden erfordert Raw-Socket |
| ARP-Reply-Frame bauen (MAC mitteilen) | std.net.arp (ArpBuildReply) |
| Empfangenen ARP-Frame parsen | std.net.arp (ArpParse) — prüft EtherType 0x0806, hlen=6, plen=4 |
| Ethernet-, IPv4- oder UDP-Header von Hand bauen | std.net.eth / ipv4 / udp — ohne Syscalls, ohne Allokation |
| ARP/DHCP-Pakete im Kernel oder ohne libc bauen | std.net.arp.frame / dhcp.frame — nicht zusammen mit std.net.arp/dhcp importieren (Namenskollision) |
| DHCPDISCOVER-Paket bauen und manuell senden | std.net.dhcp (DhcpBuildDiscover) |
| DHCPREQUEST nach OFFER senden | std.net.dhcp (DhcpRequest) — liest offeredIP und serverIP aus Result-Struct |
| DHCP-Server-Antwort (OFFER/ACK) parsen | std.net.dhcp (DhcpParseReply) — setzt DHCP_RESULT_OK=1 bei OFFER oder ACK |
| WHOIS-Abfrage für Domain oder IP | std.net.whois |
| LDAP / Active Directory abfragen | std.net.ldap |
| Netzwerk-Gerät per SNMP auslesen | std.net.snmp |
| VoIP / SIP-Signaling | std.net.sip |
| UDP-Socket direkt verwenden | std.net.socket |
| Ereignis-fd für Thread-Wakeup | std.net.epoll (EventFdCreate) |
| Android-Netzwerk-Syscalls | std.net.internal.syscalls_android |
Datenbanken
| Ich will … | Unit |
|---|---|
| MySQL oder MariaDB abfragen | std.db.mysql |
| PostgreSQL abfragen (ohne libpq) | std.db.postgres |
| Embedded-DB / Single-File / Mobile | std.db.sqlite |
| In-Memory-Datenbank (SQLite) | std.db.sqlite (SQLiteOpen(„:memory:“)) |
| Sessions oder Caching speichern | std.db.redis |
| Pub/Sub zwischen Prozessen | std.db.redis |
| Redis ohne std.string-Abhängigkeit | std.db.redis_simple |
| JSON-Dokumente speichern | std.net.mongo |
| PostgreSQL Connection Pooling | std.db.postgres (PGPoolCreate) |
| Bulk-Import (tausende Rows schnell) | std.db.postgres (COPY) · std.db.sqlite (Transaktion) |
PDF erstellen
| Ich will … | Unit |
|---|---|
| Einfaches PDF mit Text und Linien | std.pdf.builder + std.pdf.graphics |
| Schriftart auswählen (Helvetica, Times …) | std.pdf.fonts |
| Umlaute / Unicode-Text einbetten | std.pdf.ttfont (TrueType + Subsetting) |
| Rasterbilder einfügen (JPEG/PNG) | std.pdf.image |
| Farbverlauf (linear oder radial) | std.pdf.shading |
| PANTONE / Sonderfarbe verwenden | std.pdf.spot |
| Grafik-Block mehrfach wiederverwenden | std.pdf.xobject |
| Interaktives Formular erstellen | std.pdf.forms |
| Formular-Felder einfrieren (flatten) | std.pdf.forms (PdfFlattenForms) |
| Lesezeichen (Outline/Bookmarks) | std.pdf.outline |
| Hyperlinks und Annotationen | std.pdf.annot |
| Dokument-Metadaten (Titel, Autor) | std.pdf.meta |
| XMP-Metadaten einbetten | std.pdf.xmp |
| PDF/A (Langzeitarchivierung) | std.pdf.pdfa + std.pdf.xmp |
| ZUGFeRD / Factur-X Rechnung | std.pdf.pdfa (A-3b) + std.pdf.attach |
| Layer (ein-/ausblendbare Ebenen) | std.pdf.layer |
| Seitenübergänge (Präsentation) | std.pdf.transition |
| Vorhandenes PDF öffnen / analysieren | std.pdf.reader |
Dateisystem & I/O
| Ich will … | Unit |
|---|---|
| Datei öffnen, lesen, schreiben, schließen | std.fs |
| Datei-Metadaten lesen (fstat, Größe) | std.fs_ext |
| Scatter/Gather-I/O (readv/writev) | std.fs_ext |
| Positional-I/O (pread/pwrite) | std.fs_ext |
| Datei direkt zu Socket senden (sendfile) | std.fs_ext |
| Verzeichnisinhalt auflisten (DirList) | std.fs (DirList / DirEntryName / DirEntryTypeAt) |
| Verzeichnis rekursiv traversieren | std.fs (DirWalk) |
| Dateien nach Wildcard suchen (*.log) | std.fs (FileGlob) |
| Einmalige Temp-Datei anlegen | std.fs (TmpFile()) |
| Erweitertes Attribut (xattr) lesen/schreiben | std.xattr |
| Freien Speicher eines Dateisystems abfragen | std.xattr (StatFsFreeBytes) |
| Speicherplatz für Datei vorab reservieren | std.xattr (FileAllocate) |
| Asynchrones I/O (viele gleichzeitige Ops) | std.io_uring |
| Dateisystem-Änderungen überwachen | std.inotify |
| Pipe zwischen Prozessen | std.pipe |
| Dateideskriptor duplizieren (dup/dup2) | std.pipe |
| Anonyme In-Memory-Datei (memfd) | std.mmap_ext |
| Shared Memory (mmap + ftruncate) | std.mmap_ext |
| Mapping wachsen lassen (mremap) | std.mmap_ext |
| Seiten im RAM fixieren (mlock) | std.mmap_ext |
| IPC Message Queues (POSIX mq) | std.mqueue |
Archiv & Kompression
| Ich will … | Unit |
|---|---|
| ZIP-Archiv lesen (stored + deflated) | std.zip (ZipOpen, ZipRead) |
| ZIP-Archiv erstellen | std.zip (ZipWriterNew, ZipWriterAdd, ZipWriterSave) |
| Einzelne Datei in ZIP suchen | std.zip (ZipFind) |
| TAR-Archiv lesen (POSIX ustar) | std.tar (TarOpen, TarRead) |
| TAR-Archiv erstellen | std.tar (TarWriterNew, TarWriterAdd, TarWriterSave) |
| .tar.gz erzeugen | std.tar + std.gzip (TarWriterSave → GzipCompress) |
| JWT für einen Google-Service-Account signieren (RSA) | std.crypto.rsa — benötigt OpenSSL 3 |
| RAR5-Archiv lesen (nur stored) | std.rar (RarOpen, RarRead) |
| RAR-Archiv erstellen | nicht möglich — RARLAB-Lizenz nötig; stattdessen std.zip verwenden |
| ISO 9660-Image lesen (CD/DVD-Inhalt extrahieren) | std.iso (IsoOpen, IsoRead) |
| ISO 9660-Image erstellen | std.iso (IsoWriterNew, IsoWriterAdd, IsoWriterSave) |
| ISO 9660 vollständiger Guide | → ISO Guide |
| Rohe DEFLATE-Kompression / -Dekompression | std.zlib |
Brotli-Stream dekomprimieren (HTTP Content-Encoding: br) | std.brotli (BrotliDecompress) |
| Brotli-Stream komprimieren (Store-Modus, gültig aber unkomprimiert) | std.brotli (BrotliCompress) |
| Zstd-Stream (.zst, Kafka, Docker-Layer) dekomprimieren | std.zstd (ZstdDecompress) |
| Zstd-Stream komprimieren (Store-Modus, gültig aber unkomprimiert) | std.zstd (ZstdCompress) |
| .gz-Datei erzeugen oder lesen | std.gzip (GzipCompress / GzipDecompress) — prüft CRC-32 und ISIZE |
Strings & Datenformate
| Ich will … | Unit |
|---|---|
| Strings suchen, ersetzen, trimmen | std.string |
| String mit Platzhaltern formatieren (%s/%d/%x) | std.string (StrFormat) |
| Zeichenkette mit bekannter Länge, NUL-Bytes erlaubt | std.strtype (String) |
| Umlaute/Emoji zählen und schneiden, ohne sie zu zerhacken | std.text (Text, Codepoints) |
| Prüfen, ob „é„ und „é“ derselbe Text sind | std.unicode (TextEqualsNormalized) |
| Groß-/Kleinschreibung jenseits von Latin-1 (Griechisch, Kyrillisch) | std.unicode_case |
| Vergleichen ohne Rücksicht auf Groß-/Kleinschreibung | std.unicode_case (TextEqualsFold) |
| Zeichen zählen, wie der Nutzer sie sieht (Emoji, Flaggen) | std.grapheme |
| UTF-16-Datei oder Windows-API-Zeichenkette lesen | std.text (TextFromUtf16) |
| Regex-Matching und -Suche | std.regex |
| JSON lesen oder schreiben | std.json |
| XML parsen oder erzeugen | std.xml |
| YAML-Konfiguration laden | std.yaml |
| INI-Konfigurationsdatei einlesen | std.ini |
| URL parsen (Schema, Host, Query) | std.url |
| URL aus Teilen zusammenbauen | std.url (URLBuild) |
| Query-Parameter lesen oder setzen | std.url (URLQueryGet / URLQuerySet) |
| Relativen URL gegen Basis auflösen | std.url (URLResolve) |
| Percent-Encoding / -Decoding (RFC 3986) | std.url (URLPercentEncode / URLPercentDecode) |
| Base64 kodieren/dekodieren | std.base64 |
| HTML escapen / Tags entfernen | std.html |
| Binär serialisieren (VarInt, Pack) | std.pack |
| Struct-Feld auf exaktes Byte-Offset legen (Protokoll-Header) | @at(N) |
| Mehrbyte-Feld als Big-Endian / Network Byte Order markieren | @big_endian |
| Daten komprimieren (zlib/DEFLATE) | std.zlib |
| Hex/Binär/Oktal-Konvertierung | std.conv |
Kryptografie & Sicherheit
→ Kryptographie-Guide: Vergleich aller Units, Empfehlungen, Entscheidungsguide
| Ich will … | Unit |
|---|---|
| Daten mit AES-128/256 verschlüsseln | std.crypto.aes |
| MD5-Hash (Checksum / Protokoll) | std.crypto.md5 |
| SHA-1-Hash (Git-Objekte, MySQL-Auth) | std.crypto.sha1 |
| SHA-256-Hash (FIPS 180-4, one-shot) | std.crypto.sha256 |
| HMAC-SHA256 (Nachrichten-Authentifizierung) | std.crypto.hmac |
| ECDSA-Signatur erzeugen / prüfen (secp256k1) | std.crypto.ecc |
| Kryptografisch sichere Zufallsbytes | std.crypto.rand (RandBytesExact) |
| Sicheren Zufalls-int64 erzeugen | std.crypto.rand (RandInt64 — 0 bei Fehler; für sicherheitskritischen Code RandBytesExact bevorzugen) |
| Passwort sicher hashen (bcrypt/Argon2) | std.hash |
| TLS/HTTPS-Verbindung aufbauen | std.net.tls |
| Binary-Integrität zur Laufzeit prüfen | std.meta_safe |
| UUID zufällig oder zeitbasiert erzeugen | std.uuid |
| Symmetrisch authentifiziert verschlüsseln (Latin-Square, 128-Bit Quantensicherheit) | std.crypto.pqc.dadq → dadqFOEnc / dadqFODec (FO-Modus empfohlen) |
| DADQ-Schlüssel für PKE kapseln (Hybrid) | std.crypto.pqc.dadq + std.crypto.pqc.mlkem: ML-KEM kapselt den 32-Byte master_seed |
| Post-Quantum-Schlüsselaustausch (ersetzt ECDH) | std.crypto.pqc.pqc → PQCKeyGen(PQC_ALG_MLKEM_768) |
| Post-Quantum-Schlüsselaustausch + klassisch (Signal/Apple-Schema) | std.crypto.pqc.pqc → PQCKeyGen(PQC_ALG_HYBRID_768) |
| Post-Quantum-Signatur (ersetzt ECDSA) | std.crypto.pqc.pqc → PQCKeyGen(PQC_ALG_MLDSA_65) |
| Post-Quantum-Signatur (nur SHA-256-Annahmen, kleiner PK) | std.crypto.pqc.pqc → PQCKeyGen(PQC_ALG_SLHDSA_128S) |
| PGP-ASCII-Armor (.asc) dekodieren | std.pgp.armor (PgpArmorDecode) |
| PGP-ASCII-Armor erzeugen | std.pgp.armor (PgpArmorEncode) |
| Armor-Typ erkennen (Public Key / Signature …) | std.pgp.armor (PgpArmorType) |
| PGP-Pakete aus Binärdaten iterieren | std.pgp.packet (PgpPacketFirst / PgpPacketNext) |
| Key-ID eines öffentlichen Schlüssels lesen | std.pgp.key (PgpKeyId) — letzten 8 Bytes des Fingerprints |
| Fingerprint eines v4-Schlüssels berechnen | std.pgp.key (PgpKeyFingerprint) — 20-Byte SHA-1 |
| Algorithmus eines PGP-Schlüssels prüfen | std.pgp.key (PgpKeyAlgo) — gibt PGP_ALG_* zurück |
| CRC-24 nach RFC 4880 berechnen | std.pgp.core (PgpCrc24) |
Prozesse, Threads & IPC
| Ich will … | Unit |
|---|---|
| Neuen Prozess starten (fork/exec) | std.process |
| Shell-Befehl ausführen + Ausgabe lesen | std.process (Shell) |
| POSIX-Threads anlegen | std.thread |
| Mutex / Bedingungsvariablen | std.thread |
| Signale abfangen (SIGTERM, SIGUSR1 …) | std.signals |
| Signal als fd lesen (signalfd) | std.signals |
| CPU-Affinität setzen (CPU-Pinning) | std.sched |
| Nice-Wert / Prozess-Priorität ändern | std.sched |
| UID/GID lesen, Root prüfen | std.process_ext |
| Session / Prozessgruppe wechseln | std.process_ext |
| Systeminformationen (/proc) auslesen | std.systeminfo |
| IPC über POSIX Message Queues | std.mqueue |
| IPC über Pipes | std.pipe |
| SysV Shared Memory (shmget/shmat) | std.ipc_sysv (ShmCreate / ShmAttach) |
| SysV Semaphore (P/V-Operationen) | std.ipc_sysv (SemCreate / SemWait / SemPost) |
| SysV Message Queue | std.ipc_sysv (MsgQueueCreate / MsgSend / MsgRecv) |
| Signal race-frei an Prozess senden (pidfd) | std.ns (PidFdOpen / PidFdSendSignal) |
System & Kernel
| Ich will … | Unit |
|---|---|
| Asynchrones I/O (io_uring, Kernel 5.1+) | std.io_uring |
| SysV IPC (Shared Memory, Semaphore, Queues) | std.ipc_sysv |
| eBPF-Programm laden und Maps verwalten | std.bpf (braucht CAP_BPF oder CAP_SYS_ADMIN) |
| Prozess per ptrace debuggen / tracen | std.debug (PtraceAttach / PtraceGetRegs) |
| Hardware-Performance-Counter auslesen | std.debug (PerfEventOpen / PerfCount) |
| Linux-Namespaces wechseln / trennen | std.ns (NamespaceUnshare / NamespaceJoin) |
| Process-Capabilities lesen / abgeben | std.security_ext (CapGet / CapDrop) |
| PR_SET_NO_NEW_PRIVS setzen (irreversibel) | std.security_ext (ProcessSetNoNewPrivs) |
| Prozessname setzen (prctl PR_SET_NAME) | std.security_ext (ProcessSetName) |
| Dateisystem mounten / unmounten | std.sysadmin (Mount / Umount) |
| Root-Verzeichnis wechseln (chroot) | std.sysadmin (Chroot) |
| Hostnamen setzen | std.sysadmin (SetHostname) |
| System-Reboot / Poweroff auslösen | std.sysadmin (Reboot) |
Ausgabe & Benutzeroberflächen
| Ich will … | Unit |
|---|---|
| Text und Zahlen ausgeben | std.io |
| Terminal mit ANSI-Farben und Cursor | std.crt |
| Einzelne Zeichen non-blocking lesen | std.crt_raw |
| Vollständige TUI (Fenster, Dialoge, Menüs) | LyxVision |
| LyxVision vollständiger Guide | → LyxVision-Guide |
| Desktop-GUI-Fenster mit Qt5 | std.qt5_app |
| OpenGL in Qt5-Fenster | std.qt5_gl |
| Strukturiertes Logging (5 Level) | std.log |
| JSON-Logzeile mit Key-Value (log_info_kv) | std.log (log_info_kv) |
| SVG-Grafik programmatisch erzeugen | std.svg |
| SVG vollständiger Guide | → SVG-Guide |
Mathematik & Algorithmen
| Ich will … | Unit |
|---|---|
| sin, cos, sqrt, pow, floor, round … | std.math |
| Arcustangens (atan / atan2) | std.math (AtanF64 / Atan2F64) |
| Arcussinus / Arcuskosinus | std.math (AsinF64 / AcosF64) |
| Binärer Logarithmus (log₂) | std.math (Log2F64) |
| Geometrische 2D-Vektoren (Vec2) | std.vector |
| Array sortieren | std.sort |
| Statistik über ganze Zahlen | std.stats |
| Statistik in f64, Verteilungen, t-/Chi²-Test | std.prob |
| GPS-Distanz / Haversine | std.geo |
| Farben (RGBA, HSL, Blend) | std.color |
| Lineare Regression, KNN, K-Means | std.ml |
| Wort-Embeddings (FastText) | std.fasttext |
Rechnen — die 27 Mathematik-Units
→ Vollständig mit Schichtengraph: Rechnen — die Mathematik-Units
| Ich will … | Unit |
|---|---|
| exp/log/sin genau statt auf ~1e−6 | std.mathx |
| Überlauf gemeldet bekommen statt umschlagen | std.sat |
Zwischenergebnis über 64 Bit ((a·b)/c) | std.i128 |
| Zahlen beliebiger Größe, RSA-Bausteine | std.bignum |
Primzahltest jenseits von int64 | std.prime |
| Restklassen, CRT, modulares Inverses | std.modmath |
| Exakte Brüche ohne Rundung | std.rat |
| Geldbeträge, MwSt, Aufteilen ohne Centverlust | std.money |
| Fließkomma vergleichen, ULP, Rundungsarten | std.feq |
| Summieren ohne Auslöschung | std.sum |
| Bitmengen mit Rank/Select, Rotation beliebiger Breite | std.bits |
| Komplexe Zahlen als Wert | std.complex |
| Nullstellen, Integration, ODE, Splines | std.numeric |
| Ableitungen ohne Handrechnung | std.autodiff |
| Matrizen lösen, LU/QR/Cholesky, Eigenwerte | std.linalg |
| SVD, Pseudoinverse, Rang-k-Näherung | std.decomp |
| Dünnbesetzte Vektoren, Ähnlichkeitssuche | std.sparse |
| Abstandsmaße, überlaufsicherer Betrag | std.dist |
| FFT, Spektren, Fensterfunktionen | std.fft |
| Filter, Weichzeichnen, Kantenerkennung | std.convolve |
| Wavelets, Entrauschen | std.wavelet |
| Dijkstra, Topo-Sort, Max-Flow auf Graphen | std.graph |
| Pfadfindung auf Gittern (A*, BFS) | std.grid |
| Drehungen im Raum (Quaternionen) | std.quat |
| Tensoren, Quantenzustände | std.tensor |
| P-256/secp256k1, ECDSA, ECDH | std.crypto.ec |
Zeit & Datum
→ ausführlich: Guide Zeit & Datum
| Ich will … | Unit |
|---|---|
| aktuelle Zeit holen (Unix-Sekunden) | std.time (Now) |
| eine Dauer messen / Frist prüfen | std.time (GetTimeMs — monotone Uhr, nicht Now) |
| Kalenderdatum bauen, Wochentag, Schaltjahr | std.time (DateFromYmd, DayOfWeekFromDate, IsLeapYear) |
| Zeitzonenversatz anwenden | std.time (ApplyTimeZone) — mitgeliefert nur UTC/CET/CEST, weitere Zonen als TimeZone-Struct selbst bauen |
| Versatz einer bestimmten Zone nachschlagen | Zeitzonen-Tabelle — 117 Zonen, Versatz in Sekunden |
Zonenversatz aus der Umgebung (TZ) lesen | std.datetime (GetTimezoneOffset) — Standardversatz, Sommerzeitregel wird nicht ausgewertet |
| warten / periodisch aufwachen | std.time (Sleep, SleepUntil, TimerFdCreate) |
| Datum als Text ausgeben | std.datetime (FormatIso, Format, FormatRfc2822) |
Dauer lesbar ausgeben (26h 03m 04s) | std.datetime (FormatDuration) |
| Zeitstempel aus Text einlesen | std.datetime (ParseIso, ParseFlexible — nur ISO-mit-Zeit und RFC 2822) |
| Tage/Monate/Jahre addieren | std.datetime (AddDays, AddMonths — klemmt auf Monatsende) |
| Differenz zweier Zeitpunkte | std.datetime (DiffSeconds — rechnet b - a, DiffDays) |
| Datums- oder Zeiteingabe validieren | std.datetime (IsValidDate, IsValidTime) |
std.time und std.datetime kollidieren (beide exportieren DaysInMonth) — auch transitiv über std.cloud.s3. Eine der beiden wählen.
CPU & SIMD
| Ich will … | Unit |
|---|---|
| CPU-Fähigkeiten erkennen (SSE2, SSE4.1, AVX2) | std.cpu.features (CpuHasSSE2, CpuHasAVX2) |
| Besten SIMD-Pfad zur Laufzeit wählen | std.cpu.dispatch (CpuDispatchLevel) |
| 16-Byte-ausgerichtetes f32-Array anlegen | std.cpu.dispatch (SimdAlloc) |
| Elementweise f32-Addition auf Arrays | std.cpu.dispatch (SimdAdd) |
| Elementweise f32-Multiplikation auf Arrays | std.cpu.dispatch (SimdMul) |
| Einzelnes Element eines SIMD-Arrays lesen | std.cpu.dispatch (SimdGet) |
| SIMD-Array-Länge abfragen | std.cpu.dispatch (SimdLen) |
| GPU-Berechnungen (CUDA/Vulkan/OpenCL) | std.gpu.* — noch nicht implementiert (geplant WP-GPU-07–09) |
Validierung
| Ich will … | Unit |
|---|---|
| IBAN validieren | std.validate.iban |
| Kreditkartennummer prüfen (Luhn) | std.validate.luhn |
| EAN-8/13-Barcode prüfen | std.validate.ean |
| ISBN-10/13 prüfen | std.validate.isbn |
| EU-Umsatzsteuer-ID prüfen | std.validate.vat |
| VIN / Fahrzeugidentifikationsnummer | std.validate.vin |
| ISIN (Wertpapierkennung) | std.validate.isin |
| Deutsche Steuer-ID / RVNR | std.validate.de_personal |
| Alle Validierungen → Übersicht | std.validate |
| Validierung vollständiger Guide | → Validierungs-Guide |
Bildverarbeitung
| Ich will … | Unit |
|---|---|
| Bild aus Datei laden (Format automatisch erkennen) | std.image.image (ImageDecode) |
| Bild aus Speicher-Puffer laden (HTTP, ZIP) | std.image.image (ImageDecodeFromMem) |
| Nur JPEG laden (minimale Abhängigkeiten) | std.image.core + std.image.jpeg (JpegDecode) |
| Nur PNG laden | std.image.core + std.image.png (PngDecode) |
| Format per Magic-Bytes prüfen | std.image.core (GrfDetectFormat) |
| Bildgröße (Breite/Höhe) lesen | std.image.image (ImageGetWidth, ImageGetHeight) |
| Pixel an (x,y) lesen | std.image.image (ImagePixelAt) — gibt 0xRRGGBBAA |
| Pixel setzen / Bild programmatisch erzeugen | std.image.core (GrfImageAlloc, GrfImageSetPixel) |
| Alle Pixel mit einer Farbe füllen | std.image.core (GrfImageClear) |
| MJPEG-Frame aus AVI-Datei extrahieren | std.video.avi (AviExtractMjpegFrame) + std.image.core |
| RGBA→BGRA konvertieren (für Vega-Compositor) | Manuell per peek8/poke8 (Workflow 7 im Image-Guide) |
| Bild in PDF einbetten | std.pdf.image |
| Vollständiger Guide | → Bildverarbeitung-Guide |
Audio & Hardware
| Ich will … | Unit |
|---|---|
| WAV-Datei laden oder schreiben | std.audio |
| WAV-Datei abspielen (einfach) | std.audio.playback |
| PCM direkt per ALSA ausgeben | std.audio.alsa |
| MP3 dekodieren | std.audio.mpg123 |
| Bluetooth vollständiger Guide | → Bluetooth-Guide |
| Bluetooth BLE-Gerät als GATT-Client | std.hardware.bluetooth_gattc |
| Eigenen BLE-Service anbieten (GATT-Server) | std.hardware.bluetooth_gatts (GattServerRegister) |
| Classic Bluetooth (RFCOMM, seriell) | std.hardware.bluetooth_rfcomm (RFCommConnect / RFCommSend) |
| Bluetooth-Gerät discovern, pairen, verbinden (BlueZ) | std.hardware.bluetooth_dbus (BlueZStartDiscovery / BlueZConnectDevice) |
| BLE-Geräte in der Umgebung scannen | std.hardware.bluetooth_ext (BleScannerStart / BleScannerReadNext) |
| BLE-Advertising (als Peripheral senden) | std.hardware.bluetooth_ext (BleAdvertisementRegister) |
| GATT-Characteristics typsicher verwenden | std.hardware.bluetooth_ai (MakeReadableChar / MakeNotifiableChar) |
| USB vollständiger Guide | → USB-Guide |
| USB-Gerät nach VID/PID finden und öffnen | std.hardware.usb_discovery (UsbFindDevice) |
| USB Descriptor-Baum lesen (Config/Interface/Endpoint) | std.hardware.usb_parse (UsbAllocDevice / UsbParseConfiguration) |
| USB Device Descriptor lesen (VID/PID, Class) | std.hardware.usb_control (UsbGetDeviceDescriptor) |
| Interface für exklusiven Zugriff beanspruchen | std.hardware.usb_control (UsbClaimInterface) |
| Bulk-Daten an USB-Gerät senden | std.hardware.usb_bulk (UsbBulkWrite) |
| Bulk-Daten von USB-Gerät empfangen | std.hardware.usb_bulk (UsbBulkRead) |
| Interrupt-Transfer asynchron lesen (HID, Gamepad) | std.hardware.usb_interrupt (UsbSubmitInterruptRead / UsbWaitForUrb) |
| Kontinuierlichen HID-Stream mit URB-Pool lesen | std.hardware.usb_urb_pool (UsbUrbPoolInit / UsbUrbPoolPoll) |
| Audio/Video per Isochronous Transfer streamen | std.hardware.usb_iso (UsbSubmitIsoRead / UsbReapIsoUrb) |
| Endpoint-Richtung typsicher absichern | std.hardware.usb_endpoint_types (UsbMakeBulkOut / UsbMakeBulkIn) |
| Endpoint-Adresse einmalig binden und per Key nutzen | std.hardware.usb_endpoint_bind (UsbDefOutEndpoint / UsbEpWrite) |
| Interface-Claim idempotent verwalten | std.hardware.usb_ifc_mgr (UsbIfcAcquire / UsbIfcRelease) |
| Übersicht aller USB-Units | std.hardware.usb |
| GPIO vollständiger Guide | → GPIO-Guide |
| GPIO-Pin als Ausgang schalten (LED, Relais) | std.hardware.gpio_mmio (GpioWritePin) oder std.hardware.gpio_pin (GpioOutputPinWrite) |
| GPIO-Pin als Eingang lesen (Taster, Sensor) | std.hardware.gpio_pin (GpioInputPinRead) |
| LED dimmen / Software-PWM erzeugen | std.hardware.gpio_ext (GpioSoftPWM) |
| Auf Flanke warten (Tasterklick, Interrupt) | std.hardware.gpio_ext (GpioWaitForEdge) |
| Pull-Up / Pull-Down konfigurieren | std.hardware.gpio_mmio (GpioSetPullMode) |
| Pin auf Alt-Funktion setzen (SPI, I2C, UART) | std.hardware.gpio_ext (GpioSetAltMode) |
| Mehrere Pins atomar setzen (ioctl) | std.hardware.gpio_ioctl (GpioSetLineValues mit mask-Bitmap) |
| GPIO-Chip-Info abfragen (Lines, Name) | std.hardware.gpio_ioctl (GpioGetChipInfo) |
| Präzise Mikrosekunden-Wartezeit | std.hardware.gpio_util (GpioDelayMicroseconds) |
| BCM2711 Register-Offsets nachschlagen | std.hardware.rpi4 (nur Konstanten) |
| Übersicht aller GPIO-Units | std.hardware.gpio |
Android
| Ich will … | Unit |
|---|---|
| JNI-Typen (JNIEnv, jobject …) | std.android.jni |
| Logcat-Ausgabe | std.android.log |
| OpenGL ES 2.0 | std.android.gles2 |
| APK zusammenbauen | std.android.apk_builder |
| Sensoren (Beschleunigung, Gyroskop) | std.android.sensor |
| Netzwerk-Syscalls auf Android | std.net.internal.syscalls_android |
| Android vollständiger Guide | → Android-Guide |
| Übersicht aller Android-Units | std.android |
Cloud — AWS & DigitalOcean
| Ich will … | Unit |
|---|---|
| S3-Datei hochladen / herunterladen | std.cloud.s3 |
| Große Datei (> 100 MB) nach S3 hochladen | std.cloud.s3 (S3PutObjectMultipart) |
| S3-Objekte paginiert auflisten | std.cloud.s3 (S3ListAll / S3ListObjectsNext) |
| S3-Teilbereich herunterladen (Range) | std.cloud.s3 (S3GetObjectRange) |
| S3-Presigned GET-URL (Download-Link) | std.cloud.s3 (S3PresignGet) |
| S3-Presigned PUT-URL (Client-Upload ohne Credentials) | std.cloud.s3 (S3PresignPut) |
| Cloudflare R2 via S3-API | std.cloud.s3 (S3ConnectR2) |
| MinIO (Self-Hosted S3) | std.cloud.s3 (S3ConnectMinio) |
| EC2-Instanz starten / stoppen | std.cloud.ec2 |
| DynamoDB-Item lesen / schreiben | std.cloud.dynamodb |
| Lambda-Funktion aufrufen | std.cloud.lambda (LambdaInvoke) |
| SQS-Nachricht senden / empfangen | std.cloud.sqs |
| SNS-Topic-Nachricht / SMS versenden | std.cloud.sns |
| CloudWatch-Metriken schreiben | std.cloud.cloudwatch (CWPutMetricData) |
| AWS-Secret auslesen | std.cloud.secrets (SecretsGetString) |
| SSM-Parameter lesen | std.cloud.secrets (SSMGetParameterValue) |
| IAM-Rolle annehmen (STS AssumeRole) | std.cloud.iam (STSAssumeRole) |
| AWS-Credentials aus Umgebung / Datei laden | std.cloud.aws.core (AWSCredentialsDefault) |
| DigitalOcean Droplet erstellen | std.cloud.digitalocean.droplets (DropletCreateSimple) |
| DO Block-Storage Volume anhängen | std.cloud.digitalocean.volumes (VolumeAttach) |
| DO Spaces (S3-kompatibler Speicher) nutzen | std.cloud.digitalocean.spaces |
| DO Managed Database anlegen | std.cloud.digitalocean.databases (DatabaseCreate) |
| DO Kubernetes-Cluster anlegen / Kubeconfig | std.cloud.digitalocean.kubernetes (K8sClusterCreate, K8sKubeconfig) |
| DO App Platform deployen | std.cloud.digitalocean.apps (AppCreateFromSpec) |
| DO Serverless Function aufrufen | std.cloud.digitalocean.functions (FunctionInvoke) |
| DO DNS-Record anlegen / aktualisieren | std.cloud.digitalocean.networking (DomainRecordCreate) |
| DO Load Balancer erstellen | std.cloud.digitalocean.networking (LBCreate) |
| DO Container Registry nutzen | std.cloud.digitalocean.registry |
| DO-Credentials aus Umgebung laden | std.cloud.digitalocean.credentials (DOCredentialsFromEnv) |
| Cloud-Übersicht (AWS + DO) | → std.cloud |
| S3 vollständiger Guide (Upload, Multipart, Presigned, Listing) | → S3-Guide |
| Cloud vollständiger Guide | → Cloud-Guide |
| Cloudflare DNS-Record setzen | std.cloud.cf.dns (DNSRecordUpsert) |
| Cloudflare Worker deployen | std.cloud.cf.workers (WorkerDeploy) |
| Cloudflare KV-Store lesen / schreiben | std.cloud.cf.kv (KVGet / KVPutWithTTL) |
| R2-Objekt hochladen (Cloudflare) | std.cloud.cf.r2 (R2Upload) |
| D1-SQLite-Datenbank abfragen (Cloudflare) | std.cloud.cf.d1 (D1Query) |
| Zone-Cache leeren (Cloudflare) | std.cloud.cf.cache (CachePurgeAll) |
| IP-Adresse sperren / WAF-Regel (Cloudflare) | std.cloud.cf.waf (FirewallBlockIP) |
| Cloudflare Pages deployen | std.cloud.cf.pages (PagesDeployDir) |
| Tunnel ohne offenen Port (Cloudflare) | std.cloud.cf.tunnel (TunnelCreate) |
| Cloudflare-Credentials laden | std.cloud.cf.credentials (CFCredentialsFromEnv) |
| Cloudflare-Übersicht (alle CF-Units) | → std.cloud.cf |
Cloud — Google Cloud Platform (GCP)
| Ich will … | Unit |
|---|---|
| GCS-Datei hochladen | std.cloud.gcp.storage (GCSUpload) |
| GCS-Datei herunterladen | std.cloud.gcp.storage (GCSDownload) |
| GCS-Bucket anlegen | std.cloud.gcp.storage (GCSBucketCreate) |
| GCS-Objekte auflisten | std.cloud.gcp.storage (GCSList) |
| GCE-VM anlegen / starten / stoppen | std.cloud.gcp.compute (GCEInstanceCreate / GCEInstanceStart) |
| Auf asynchrone GCE-Operation warten | std.cloud.gcp.compute (GCEOperationWait) |
| Firestore-Dokument schreiben / lesen | std.cloud.gcp.firestore (FSCreate / FSGet) |
| Firestore-Collection auflisten | std.cloud.gcp.firestore (FSList) |
| Pub/Sub-Nachricht publishen | std.cloud.gcp.pubsub (PubSubPublish) |
| Pub/Sub-Nachrichten abrufen und bestätigen | std.cloud.gcp.pubsub (PubSubPull / PubSubAck) |
| Cloud Function deployen | std.cloud.gcp.functions (GCFDeploy) |
| Cloud Function aufrufen | std.cloud.gcp.functions (GCFInvoke) |
| Cloud Run Services auflisten | std.cloud.gcp.functions (GCRServiceList) |
| Log-Eintrag in Cloud Logging schreiben | std.cloud.gcp.logging (LogWrite / LogWriteJSON) |
| Custom Metric in Cloud Monitoring schreiben | std.cloud.gcp.logging (MonWriteMetric) |
| GCP-Secret auslesen | std.cloud.gcp.secrets (SecretGet) |
| GCP-Secret anlegen | std.cloud.gcp.secrets (SecretCreate) |
| IAM Service Account anlegen | std.cloud.gcp.secrets (IAMCreateServiceAccount) |
| GCP-Credentials aus Service-Account-JSON laden | std.cloud.gcp.credentials (GCPCredentialsFromFile) |
| GCP Application Default Credentials laden | std.cloud.gcp.credentials (GCPCredentialsDefault) |
| GCP-Übersicht (alle GCP-Units) | → std.cloud.gcp |
Blockchain
| Ich will … | Unit |
|---|---|
| Eine neue Transaktion erstellen und signieren | std.blockchain (BLNewTransaction, BLSignTransaction) |
| Eine Transaktion verifizieren | std.blockchain (BLVerifyTransaction) |
| Eine Coinbase-Transaktion erstellen (Mining-Belohnung) | std.blockchain (BLNewCoinbaseTx) |
| Einen neuen Block erstellen | std.blockchain (BLNewBlock, BLCalculateHash, BLMeetsTarget) |
| Einen Block minen (PoW) | std.blockchain (BLMinePendingTransactions) |
| TX zum Mempool hinzufügen | std.blockchain (BLAddTransaction) |
| Kontostand einer Adresse abfragen | std.blockchain (BLBlockchainGetBalance) |
| Ledger-Zustand direkt lesen | std.blockchain (BLGetBalance, BLGetNonce) |
| Gesamte Kette auf Gültigkeit prüfen | std.blockchain (BLIsValidChain) |
| Merkle-Root berechnen | std.blockchain (BLMerkleRoot) |
| Big-Endian-Serialisierung für Blockchain-Daten | std.blockchain (BLSerializeInt32, BLSerializeInt64) |
| P2P-Knoten starten und Peers verbinden | std.blockchain.p2p (BLP2PNodeNew, BLP2PNodeStart, BLP2PConnectPeer) |
| Transaktion an alle Peers broadcasten | std.blockchain.p2p (BLP2PBroadcastTx) |
| Block an alle Peers broadcasten | std.blockchain.p2p (BLP2PBroadcastBlock) |
| Eingehende P2P-Nachricht verarbeiten | std.blockchain.p2p (BLP2PHandleIncoming) |
| Neue Peer-Verbindung akzeptieren | std.blockchain.p2p (BLP2PPoll) |
| Blockchain-Übersicht (alle Units) | → std.blockchain |
| Blockchain-Guide (Workflows, P2P, Speicherverwaltung) | → Blockchain-Guide |
KassenSichV / TSE
| Ich will … | Unit |
|---|---|
| Kassenbon TSE-signieren (einfach, einstufig) | kassensichv.manager (TseProcessBeleg) |
| Tischbewirtung / mehrstufigen Vorgang signieren | kassensichv.manager (TseOpenBeleg → TseCloseBeleg) |
| QR-Code-String nach BSI TR-03153 erzeugen | automatisch durch TseProcessBeleg / TseCloseBeleg in SigErgebnis.qrCode |
| BelegDaten-Typ und Prozesstyp-Konstanten | kassensichv.types |
| TSE-Anbindung ohne Hardware testen (CI/CD) | kassensichv.mock (TseMockNew, Fehlersimulation) |
| Cloud-TSE anschließen (Fiskaly, Deutsche Fiskal) | kassensichv.rest (TseRestNew, JSON-Config) |
| USB-TSE anschließen (Swissbit, Epson) | kassensichv.file (TseFileNew, base_path) |
| DSFinV-K-Export für Finanzamt-Prüfung | kassensichv.manager (TseExportAuditData) |
| TSE-Fehler behandeln, offene Transaktionen erkennen | kassensichv.exceptions |
| KassenSichV-Übersicht (alle Units) | → kassensichv |
| KassenSichV-Guide (Workflows, Checkliste, Entscheidungsguide) | → KassenSichV-Guide |
EDI / EDIFACT
| Ich will … | Unit |
|---|---|
| EDIFACT-Nachricht parsen (UNA/UNB, Segmente, Elemente) | std.edi.core (EdiSegmentNext, EdiElementSplit) |
| Quittung / Fehlermeldung senden (CONTRL, APERAK) | std.edi.messages (EdiContrlOk / EdiContrlErr / EdiAperakWrite) |
| Allgemeine Textnachricht per EDI senden (GENRAL) | std.edi.messages (EdiGenralWrite) — BODY muss nach Lesen freigegeben werden |
| Partner-Registry für AS2/SFTP verwalten | std.edi.partner (EdiPartnerWrite / EdiPartnerFind) |
| Prüfen ob Partner Nachrichtentyp unterstützt | std.edi.partner (EdiPartnerSupports) |
| Preisanfrage (RFQ) senden und Angebot lesen | std.edi.rfq (EdiReqoteWrite / EdiQuotesRead) |
| Bestellung erstellen (ORDERS) | std.edi.orders (EdiOrdersWrite) |
| Auftragsbestätigung lesen (ORDRSP) | std.edi.orders (EdiOrdrspRead) — abgelehnte Positionen via STATUS=7 |
| Bestelländerung senden (ORDCHG) | std.edi.orders (EdiOrdchgWrite) |
| Bestellsumme validieren (Rundungstoleranzdiff ≤ 1 Cent) | std.edi.orders (EdiOrdersValidate) |
| Rechnung erstellen (INVOIC) | std.edi.invoice (EdiInvoicWrite) — Summen werden automatisch aus Positionen berechnet |
| Rechnung validieren (Netto-/Bruttodifferenz) | std.edi.invoice (EdiInvoicValidate) |
| Rechnungsdisput melden (COMDIS) | std.edi.invoice (EdiComdisWrite) |
| Saldenabstimmung (COACSU) | std.edi.invoice (EdiCoacsuWrite) |
| Preiskatalog senden (PRICAT) | std.edi.catalog (EdiPricatWrite) |
| GTIN (EAN) per GS1 Mod-10 prüfen | std.edi.catalog (EdiGtinCheck) — Längen 8/12/13/14 |
| GLN (Firmen-Standortnummer) prüfen | std.edi.catalog (EdiGlnCheck) — 13-stellig Mod-10 |
| Lieferschein mit SSCC-Hierarchie senden (DESADV) | std.edi.shipping (EdiDesadvWrite) — Palette→Karton→Artikel |
| Wareneingangsmeldung senden (RECADV) | std.edi.shipping (EdiRecadvWrite) |
| SSCC-18-Prüfziffer validieren oder generieren | std.edi.shipping (EdiSsccCheck / EdiSsccGenerate) |
| Zahlungsavis senden (REMADV) | std.edi.payment (EdiRemadvWrite) |
| Lastschriftmandat senden (DIRDEB) | std.edi.payment (EdiDirdebWrite) — Mandatsreferenz Pflicht |
| Akkreditiv (DOCAPP) erstellen | std.edi.payment (EdiDocappWrite) |
| IBAN validieren (MOD-97) | std.edi.payment (EdiIbanCheck) |
| BIC validieren (8 oder 11 Zeichen) | std.edi.payment (EdiBicCheck) |
| Sammel-Zahlungsauftrag (PAYMUL) mit Summenprüfung | std.edi.payment (EdiPaymulWrite + EdiPaymulValidate) |
| Lagerbestandsmeldung senden (INVRPT) | std.edi.inventory (EdiInvrptWrite) |
| Wöchentlichen Absatzbericht senden (SLSRPT) | std.edi.inventory (EdiSlsrptWrite) |
| Absatzprognose mit Konfidenz senden (SLSFCT) | std.edi.inventory (EdiSlsfctWrite) — CONFIDENCE 0–100 |
| Rollierenden Lieferabruf senden (DELFOR) | std.edi.delfor (EdiDelforWrite) — bis 52 Wochen, Fest-/Planbedarfe |
| JIT-Abruf minutengenau senden (DELJIT) | std.edi.delfor (EdiDeljitWrite) — Format CCYYMMDDHHMM |
| Kumulative Abrufmenge prüfen | std.edi.delfor (EdiDelforCheckCumu) |
| Zollanmeldung senden (CUSDEC) | std.edi.customs (EdiCusdecWrite) |
| Zollantwort lesen (CUSRSP) | std.edi.customs (EdiCusrspRead) — Statuscodes 1=akzeptiert, 4=freigegeben |
| Stauplan für Container-Schiff senden (BAPLIE) | std.edi.seafreight (EdiBaplieWrite) |
| VGM-Gewicht (SOLAS-Pflicht) senden (VERMAS) | std.edi.seafreight (EdiVermasWrite) |
| Container Gate-In/-Out melden (CODECO) | std.edi.seafreight (EdiCodecoWrite) |
| ISO-6346-Container-ID validieren | std.edi.seafreight (EdiContainerCheck) |
| Transportauftrag mit mehreren Legs (IFTMIN) | std.edi.transport (EdiIftminWrite) — ein Leg pro Transportmodus |
| Sendungsstatus abfragen / senden (IFTSTA) | std.edi.transport (EdiIftstaWrite / EdiIftstaRead) |
| Gefahrgutmeldung erstellen (IFTDGN) | std.edi.transport (EdiIftdgnWrite) |
| UN-Gefahrgut-Nummer validieren | std.edi.transport (EdiUnNumberCheck) — genau 4 Stellen |
| EDI-Übersicht (alle 14 Units) | → std.edi |
| EDI vollständiger Guide (Konzepte, Workflows, Fehlerbehandlung) | → EDI/EDIFACT-Guide |
HL7 v2 / Gesundheitswesen
| Ich will … | Unit |
|---|---|
| MLLP-Frame aus TCP-Puffer extrahieren | std.hl7.core (MllpFrameRead) |
| HL7-Nachricht in MLLP-Frame einpacken | std.hl7.core (MllpFrameWrite) |
| MSH-Header parsen (Sender/Empfänger/Typ/ID) | std.hl7.core (Hl7MshParse) |
| ACK^AA / ACK^AE / ACK^AR erzeugen | std.hl7.core (Hl7AckWrite) — Sender/Empfänger werden aus MSH getauscht |
| Doppelte Nachrichten erkennen (Duplikat-ID) | std.hl7.core (Hl7DupCheck) — FNV1a-Ring, 16 Partner × 64 Einträge |
| HL7-Version prüfen (2.3.1 – 2.7) | std.hl7.core (Hl7VersionCheck) |
| Testnachricht erkennen (MSH-11 = T) | std.hl7.core (Hl7IsTestMsg) — Testnachrichten nicht in Produktions-DB schreiben |
| UTF-8-Nachricht erkennen (MSH-18 UNICODE) | std.hl7.core (Hl7IsUtf8) — Standard ist ISO-8859-1 |
| Patientenaufnahme/-entlassung/-verlegung verarbeiten (ADT^A01/A02/A03) | std.hl7.adt (Hl7AdtParse) |
| Patienten-ID aus PID-3 (inkl. Wiederholungen) lesen | std.hl7.adt (Hl7PidParse) — bis 3 IDs via PID-3 Repeats |
| Stationszuweisung auslesen (Punkt/Zimmer/Bett) | std.hl7.adt (Hl7Pv1Parse) → HL7_PV1_LPOINT, HL7_PV1_LROOM, HL7_PV1_LBED |
| Patientenzusammenführung erkennen und verarbeiten (A34–A45) | std.hl7.adt (Hl7AdtIsMerge / HL7_ADT_ISMERGE) → MRG enthält alte ID |
| Nächste Angehörige auslesen (NK1) | std.hl7.adt (Hl7Nk1Parse) |
| ADT-Nachricht erzeugen (z. B. Update A08) | std.hl7.adt (Hl7AdtWrite) — schreibt MSH+PID+PV1+[MRG] |
| Allgemeinen Laborauftrag verarbeiten (ORM^O01) | std.hl7.orders (Hl7OrmParse) |
| Spezifischen Laborauftrag verarbeiten (OML^O21) | std.hl7.orders (Hl7OmlParse) |
| STAT-Auftrag erkennen (Sofortpriorität) | std.hl7.orders → HL7_ORD_ISSTAT wird automatisch gesetzt wenn OBR-5='S' |
| Auftragsquittung senden (ORR^O02 / ORL^O22) | std.hl7.orders (Hl7OrrWrite) — Typ hängt von MSGTYPE (ORM vs. OML) ab |
| Medikamentengabe dokumentieren (RAS^O17) | std.hl7.orders (Hl7RasParse) → Hl7RxAdmin-Struct (Wirkstoff, Dosis, Einheit, Route) |
| Auftrag erzeugen und versenden | std.hl7.orders (Hl7OrmWrite / Hl7OmlWrite) |
| Laborbefund verarbeiten (ORU^R01) | std.hl7.results (Hl7OruParse) |
| Probenorientierten Befund verarbeiten (OUL^R22) | std.hl7.results (Hl7OulParse) |
| Einzelne OBX-Beobachtung parsen (Messwert, Einheit, Referenzbereich) | std.hl7.results (Hl7ObxParse) |
| Panikwert erkennen (HH / LL / AA / CC) | std.hl7.results → HL7_OBX_ISCRIT automatisch gesetzt |
| Korrigierten Befund erkennen (OBX-11 = C oder W) | std.hl7.results → HL7_OBX_ISCORR automatisch gesetzt |
| Termin anlegen, verschieben, absagen (SIU^S12–S26) | std.hl7.scheduling (Hl7SiuParse / Hl7SiuWrite) |
| Absage, Löschung und Nicht-Erscheinen unterscheiden | std.hl7.scheduling → HL7_APPT_ISCANCEL / ISDELETE / ISNOSHOW |
| NTE-Kommentar zum Befund lesen | std.hl7.results (Hl7NteParse) |
| Befundnachricht erzeugen (ORU^R01) | std.hl7.results (Hl7OruWrite) — schreibt MSH+OBR+OBX |
| HL7-Übersicht (alle 4 Units) | → std.hl7 |
Tipps zur Unit-Auswahl
- Immer die spezifischste Unit wählen:
std.net.httpsstattstd.net.tls+std.net.httpmanuell kombinieren — es sei denn, man braucht Kontrolle über den TLS-Handshake. - Für PDF/A: Die Reihenfolge ist wichtig:
PdfSetConformance→PdfGenerateXMP→PdfSave. - Für PostgreSQL vs. SQLite: PostgreSQL wenn mehrere Prozesse gleichzeitig schreiben; SQLite wenn Single-Writer oder Embedded genügt.
- epoll vs. poll/select:
std.net.epollfür > 100 gleichzeitige Verbindungen;std.net.socket(Poll) für kleinere Server. - std.db.redis vs. std.db.redis_simple:
redis_simplehat keine Abhängigkeit aufstd.string— nützlich für extrem kleine Binaries oder Embedded-Targets.
Letzte Aktualisierung: 2026-06-16 (HL7 v2 ergänzt)