std.edi.delfor

Lieferabrufe per EDIFACT: rollierender Lieferzeitplan (DELFOR) und Just-in-Time-Abruf (DELJIT). DELFOR unterstützt bis zu 52 Anforderungen pro Position (52 Kalenderwochen), unterscheidet zwischen festen (Typ 1) und Planungsbedarfen (Typ 3) und enthält eine Kumulationsprüfung.

DELFOR (BGM 241) — Delivery Forecast: rollierende Lieferplanung mit Fest- und Planbedarfen
DELJIT (BGM 251) — Delivery Just In Time: Minutengenaue Abrufzeitpunkte (DTM Qualifier 201, Format CCYYMMDDHHMM)

import std.edi.delfor;

// DELFOR mit 1 Position, 2 Anforderungen
var lines: int64 := alloc(EDI_DELFOR_LINE_SIZE);

poke64(lines + EDI_DELFOR_LINE_GTIN,    "04012345678901" as int64);
poke64(lines + EDI_DELFOR_LINE_GTINLEN, 14);
poke64(lines + EDI_DELFOR_LINE_CUMULQTY,250);  // Kumulierte Menge bisher
poke64(lines + EDI_DELFOR_LINE_REQCOUNT, 2);

// Anforderung 1: Festbedarf KW49
var req1: int64 := lines + EDI_DELFOR_LINE_REQS;
poke64(req1 + EDI_DELFOR_REQ_DATE, "20261207" as int64);
poke64(req1 + EDI_DELFOR_REQ_QTY,  50);
poke64(req1 + EDI_DELFOR_REQ_TYPE, 1);  // 1 = fest

// Anforderung 2: Planungsbedarf KW50
var req2: int64 := lines + EDI_DELFOR_LINE_REQS + EDI_DELFOR_REQ_SIZE;
poke64(req2 + EDI_DELFOR_REQ_DATE, "20261214" as int64);
poke64(req2 + EDI_DELFOR_REQ_QTY,  80);
poke64(req2 + EDI_DELFOR_REQ_TYPE, 3);  // 3 = Planung

var out: int64 := alloc(16384);
var n: int64 := EdiDelforWrite(
    "DELFOR-2026-012" as int64,
    "20261201" as int64,
    lines, 1, out, 16384);

free(lines, EDI_DELFOR_LINE_SIZE);
free(out, 16384);

Imports

std.edi.core
std.alloc

Konstanten

Konstante	Wert	Bedeutung
`EDI_DELFOR_REQ_TYPE` = 1	1	Festbedarf (QTY-Qualifier: 1)
`EDI_DELFOR_REQ_TYPE` = 3	3	Planungsbedarf (QTY-Qualifier: 3)
`EDI_DELFOR_MAX_REQ`	52	Max. Anforderungen pro Position (52 Wochen)

Structs

EdiDelforReq (EDI_DELFOR_REQ_SIZE = 24 Bytes)

Eine einzelne Mengenanforderung innerhalb einer DELFOR-Position.

Offset-Konstante	Inhalt
`EDI_DELFOR_REQ_DATE`	Zeiger auf Datum „YYYYMMDD“
`EDI_DELFOR_REQ_QTY`	Menge (QTY+type:qty)
`EDI_DELFOR_REQ_TYPE`	1 = Festbedarf, 3 = Planungsbedarf

EdiDelforLine (EDI_DELFOR_LINE_SIZE = 1 280 Bytes)

Eine Position im Lieferabruf. Die Struktur ist groß wegen des internen Anforderungs-Arrays: 32 Bytes (Kopf) + 52 × 24 Bytes (Anforderungen) = 1 280 Bytes.

Offset-Konstante	Inhalt
`EDI_DELFOR_LINE_GTIN / EDI_DELFOR_LINE_GTINLEN`	GTIN-Zeiger und -Länge
`EDI_DELFOR_LINE_CUMULQTY`	Kumulative Gesamtmenge (SCC-Segment)
`EDI_DELFOR_LINE_REQCOUNT`	Anzahl der Anforderungen (0–52)
`EDI_DELFOR_LINE_REQS`	Start des Anforderungs-Arrays (Offset 32)

Anforderungs-Array-Zugriff:

// i-te Anforderung einer Zeile
var req: int64 := line + EDI_DELFOR_LINE_REQS + i * EDI_DELFOR_REQ_SIZE;

EdiDeljitLine (EDI_DELJIT_LINE_SIZE = 56 Bytes)

Eine Position im JIT-Abruf.

Offset-Konstante	Inhalt
`EDI_DELJIT_LINE_GTIN / EDI_DELJIT_LINE_GTINLEN`	GTIN-Zeiger und -Länge
`EDI_DELJIT_LINE_QTY`	Abrufmenge
`EDI_DELJIT_LINE_DATETIME / EDI_DELJIT_LINE_DTLEN`	Zeiger auf 12-Zeichen-Datetime „CCYYMMDDHHMM“
`EDI_DELJIT_LINE_LOC / EDI_DELJIT_LINE_LOCLEN`	Lieferort (optional)

Funktionen

DELFOR

Signatur	Beschreibung
`EdiDelforWrite(refNum: int64, date: int64, lines: int64, lineCount: int64, out: int64, outMax: int64): int64`	Schreibt DELFOR. Fest- und Planbedarfe werden über QTY-Qualifier 1 bzw. 3 kodiert.
`EdiDelforRead(buf: int64, bufLen: int64, lines: int64, maxLines: int64): int64`	Parst DELFOR; befüllt `lines`-Array. Gibt Zeilenanzahl zurück.
`EdiDelforCheckCumu(newCumu: int64, oldCumu: int64): int64`	Kumulationsvalidierung: neue Menge muss ≥ alte Menge sein. Gibt 0=ok, 1=Warnung (unerwartete Rückwärts-Kumulation).

DELJIT

Signatur	Beschreibung
`EdiDeljitWrite(refNum: int64, date: int64, lines: int64, lineCount: int64, out: int64, outMax: int64): int64`	Schreibt DELJIT mit minutengenauem Zeitstempel (DTM Qualifier 201)
`EdiDeljitRead(buf: int64, bufLen: int64, lines: int64, maxLines: int64): int64`	Parst DELJIT; gibt Zeilenanzahl zurück

Codebeispiel — DELFOR lesen und Kumulationscheck

import std.edi.delfor;

var maxLines: int64 := 50;
var lines: int64 := alloc(maxLines * EDI_DELFOR_LINE_SIZE);
var count: int64 := EdiDelforRead(inBuf, inBufLen, lines, maxLines);

var i: int64 := 0;
while (i < count) {
    var line: int64 := lines + i * EDI_DELFOR_LINE_SIZE;
    var newCumu: int64 := peek64(line + EDI_DELFOR_LINE_CUMULQTY);
    var oldCumu: int64 := getLastCumu(i);  // aus eigenem Tracking

    if (EdiDelforCheckCumu(newCumu, oldCumu) == 1) {
        PrintLn("Warnung: Kumulationsmenge gesunken bei Position " + IntToStr(i));
    }
    i := i + 1;
}

free(lines, maxLines * EDI_DELFOR_LINE_SIZE);

Hinweise

Speicherbedarf DELFOR: EDI_DELFOR_LINE_SIZE = 1 280 Bytes pro Position (52 Wochen × 24 Bytes). Bei 100 Positionen sind das 128 KB — vor der Allokation prüfen.
Datetime-Format DELJIT: Das 12-Zeichen-Format CCYYMMDDHHMM hat kein Trennzeichen: 202612011430 = 01.12.2026 um 14:30 Uhr.
Kumulationslogik: Die kumulative Menge (SCC-Segment) wächst über den gesamten Lieferabruf-Zeitraum monoton. Senkt sich der Wert, ist das ein Signal für einen Abruf-Reset (neuer Bezugszeitraum).

Quelldatei

Unit	Datei
`std.edi.delfor`	`std/edi/delfor.lyx`

Letzte Aktualisierung: 2026-06-16