ts-api/dist/core/abschluss/gost/AbiturdatenManager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.cast_de_nrw_schule_svws_core_abschluss_gost_AbiturdatenManager = exports.AbiturdatenManager = void 0;
const JavaObject_1 = require("../../../java/lang/JavaObject");
const Naturwissenschaften_1 = require("../../../core/abschluss/gost/belegpruefung/Naturwissenschaften");
const SprachendatenManager_1 = require("../../../core/SprachendatenManager");
const Schwerpunkt_1 = require("../../../core/abschluss/gost/belegpruefung/Schwerpunkt");
const HashMap_1 = require("../../../java/util/HashMap");
const KurszahlenUndWochenstunden_1 = require("../../../core/abschluss/gost/belegpruefung/KurszahlenUndWochenstunden");
const GostBesondereLernleistung_1 = require("../../../core/types/gost/GostBesondereLernleistung");
const GostBelegpruefungErgebnis_1 = require("../../../core/abschluss/gost/GostBelegpruefungErgebnis");
const GostKursart_1 = require("../../../core/types/gost/GostKursart");
const Latinum_1 = require("../../../core/abschluss/gost/belegpruefung/Latinum");
const GostFachbereich_1 = require("../../../core/types/gost/GostFachbereich");
const Allgemeines_1 = require("../../../core/abschluss/gost/belegpruefung/Allgemeines");
const Sport_1 = require("../../../core/abschluss/gost/belegpruefung/Sport");
const GostHalbjahr_1 = require("../../../core/types/gost/GostHalbjahr");
const GostSchriftlichkeit_1 = require("../../../core/types/gost/GostSchriftlichkeit");
const ZulaessigesFach_1 = require("../../../core/types/statkue/ZulaessigesFach");
const Collections_1 = require("../../../java/util/Collections");
const Vector_1 = require("../../../java/util/Vector");
const GesellschaftswissenschaftenUndReligion_1 = require("../../../core/abschluss/gost/belegpruefung/GesellschaftswissenschaftenUndReligion");
const AbiFaecher_1 = require("../../../core/abschluss/gost/belegpruefung/AbiFaecher");
const HashSet_1 = require("../../../java/util/HashSet");
const LiterarischKuenstlerisch_1 = require("../../../core/abschluss/gost/belegpruefung/LiterarischKuenstlerisch");
const GostAbiturFach_1 = require("../../../core/types/gost/GostAbiturFach");
const GostBelegpruefung_1 = require("../../../core/abschluss/gost/GostBelegpruefung");
const GostFachManager_1 = require("../../../core/abschluss/gost/GostFachManager");
const Projektkurse_1 = require("../../../core/abschluss/gost/belegpruefung/Projektkurse");
const Deutsch_1 = require("../../../core/abschluss/gost/belegpruefung/Deutsch");
const Fremdsprachen_1 = require("../../../core/abschluss/gost/belegpruefung/Fremdsprachen");
const GostBelegpruefungErgebnisFehler_1 = require("../../../core/abschluss/gost/GostBelegpruefungErgebnisFehler");
const Mathematik_1 = require("../../../core/abschluss/gost/belegpruefung/Mathematik");
class AbiturdatenManager extends JavaObject_1.JavaObject {
    abidaten;
    gostFaecher;
    pruefungsArt;
    mapFachbereiche = new HashMap_1.HashMap();
    belegpruefungen = new Vector_1.Vector();
    belegpruefungsfehler = new Vector_1.Vector();
    belegpruefungErfolgreich = false;
    /**
     * Erstellt ein neues Manager-Objekt, welches mit den übergebenen Abiturdaten verknüpft wird.
     *
     * @param abidaten       die Abiturdaten
     * @param gostFaecher    die Fächer der Gymnasialen Oberstufe, die bei dem Abiturjahrgang zur Verfügung stehen.
     * @param pruefungsArt   die Art der Belegpruefung (z.B. EF1 oder GESAMT)
     */
    constructor(abidaten, gostFaecher, pruefungsArt) {
        super();
        this.abidaten = abidaten;
        this.gostFaecher = new HashMap_1.HashMap();
        for (let i = 0; i < gostFaecher.size(); i++) {
            let fach = gostFaecher.get(i);
            if (fach !== null)
                this.gostFaecher.put(fach.id, fach);
        }
        this.pruefungsArt = pruefungsArt;
        this.init();
    }
    /**
     * Führt die Belegprüfung der Art pruefungs_art für einen Schüler durch, dessen Abiturdaten mit dem angegebenen
     * Manager verwaltet werden.
     *
     * @param pruefungs_art    die Art der Prüfung, die durchgeführt wird
     *
     * @return eine Liste mit den durchgefuehrten Belegpruefungen
     */
    getPruefungen(pruefungs_art) {
        let pruefungen = new Vector_1.Vector();
        pruefungen.add(new Deutsch_1.Deutsch(this, pruefungs_art));
        let pruefungFremdsprachen = new Fremdsprachen_1.Fremdsprachen(this, pruefungs_art);
        pruefungen.add(pruefungFremdsprachen);
        pruefungen.add(new Latinum_1.Latinum(this, pruefungs_art));
        pruefungen.add(new LiterarischKuenstlerisch_1.LiterarischKuenstlerisch(this, pruefungs_art));
        pruefungen.add(new GesellschaftswissenschaftenUndReligion_1.GesellschaftswissenschaftenUndReligion(this, pruefungs_art));
        pruefungen.add(new Mathematik_1.Mathematik(this, pruefungs_art));
        let pruefungNaturwissenschaften = new Naturwissenschaften_1.Naturwissenschaften(this, pruefungs_art);
        pruefungen.add(pruefungNaturwissenschaften);
        pruefungen.add(new Sport_1.Sport(this, pruefungs_art));
        let pruefungProjektkurse = new Projektkurse_1.Projektkurse(this, pruefungs_art);
        pruefungen.add(pruefungProjektkurse);
        pruefungen.add(new Schwerpunkt_1.Schwerpunkt(this, pruefungs_art, pruefungFremdsprachen, pruefungNaturwissenschaften));
        pruefungen.add(new AbiFaecher_1.AbiFaecher(this, pruefungs_art));
        pruefungen.add(new KurszahlenUndWochenstunden_1.KurszahlenUndWochenstunden(this, pruefungs_art, pruefungProjektkurse));
        pruefungen.add(new Allgemeines_1.Allgemeines(this, pruefungs_art));
        return pruefungen;
    }
    /**
     * Initialisiert bzw. reinitialisert die Datenstrukturen, die für den schnellen Zugriff auf die Daten
     * eingerichtet werden.
     */
    init() {
        if (this.abidaten === null)
            return;
        this.initMapFachbereiche();
        this.belegpruefungen = this.getPruefungen(this.pruefungsArt);
        for (let i = 0; i < this.belegpruefungen.size(); i++) {
            let belegpruefung = this.belegpruefungen.get(i);
            belegpruefung.pruefe();
        }
        this.belegpruefungsfehler = GostBelegpruefung_1.GostBelegpruefung.getBelegungsfehlerAlle(this.belegpruefungen);
        this.belegpruefungErfolgreich = GostBelegpruefung_1.GostBelegpruefung.istErfolgreich(this.belegpruefungsfehler);
    }
    /**
     * Initialisiert bzw. reinitialisiert die Map für den schnellen Zugriff auf Fachbelegungen
     * anhand des Fachbereichs.
     */
    initMapFachbereiche() {
        this.mapFachbereiche.clear();
        let fachbereiche = GostFachbereich_1.GostFachbereich.values();
        for (let fachbereich of fachbereiche) {
            this.mapFachbereiche.put(fachbereich, new Vector_1.Vector());
        }
        let fachbelegungen = this.abidaten.fachbelegungen;
        for (let fachbelegung of fachbelegungen) {
            if (this.zaehleBelegung(fachbelegung) > 0) {
                fachbereiche = GostFachbereich_1.GostFachbereich.getBereiche(this.getFach(fachbelegung));
                for (let fachbereich of fachbereiche) {
                    let listFachbelegungen = this.mapFachbereiche.get(fachbereich);
                    if (listFachbelegungen === null)
                        continue;
                    listFachbelegungen.add(fachbelegung);
                }
            }
        }
    }
    /**
     * Liefert die in den Abiturdaten enthaltenen Sprachendaten.
     *
     * @return Die Sprachendaten (siehe {@link Sprachendaten})
     */
    getSprachendaten() {
        return this.abidaten.sprachendaten;
    }
    /**
     * Berechnet die Wochenstunden, welche von dem Schüler in den einzelnen
     * Halbjahren der gymnasialen Oberstufe für das Abitur relevant belegt wurden.
     *
     * @return ein Array mit den Wochenstunden für die sechs Halbjahre
     */
    getWochenstunden() {
        let stunden = [0, 0, 0, 0, 0, 0];
        for (let i = 0; i < 6; i++) {
            for (let fb of this.abidaten.fachbelegungen) {
                let hjb = fb.belegungen[i];
                if ((hjb === null) || (JavaObject_1.JavaObject.equalsTranspiler("AT", (hjb.kursartKuerzel))))
                    continue;
                stunden[i] += hjb.wochenstunden;
            }
        }
        return stunden;
    }
    /**
     * Berechnet die Anzahl der anrechenbaren Kurse, welche von dem Schüler in den einzelnen
     * Halbjahren der gymnasialen Oberstufe für das Abitur belegt wurden.
     *
     * @return ein Array mit den anrechenbaren Kursen für die sechs Halbjahre
     */
    getAnrechenbareKurse() {
        let anzahl = [0, 0, 0, 0, 0, 0];
        let bll = GostBesondereLernleistung_1.GostBesondereLernleistung.fromKuerzel(this.abidaten.besondereLernleistung);
        for (let i = 0; i < 6; i++) {
            for (let fb of this.abidaten.fachbelegungen) {
                let hjb = fb.belegungen[i];
                if ((hjb === null) || (JavaObject_1.JavaObject.equalsTranspiler("AT", (hjb.kursartKuerzel))))
                    continue;
                let kursart = GostKursart_1.GostKursart.fromKuerzel(hjb.kursartKuerzel);
                if ((kursart !== GostKursart_1.GostKursart.VTF) && (!((kursart === GostKursart_1.GostKursart.PJK) && (bll === GostBesondereLernleistung_1.GostBesondereLernleistung.PROJEKTKURS))))
                    anzahl[i]++;
            }
        }
        return anzahl;
    }
    /**
     * Liefert das Fach der gymnasialen Oberstufe für die angegeben Abiturfachbelegung.
     *
     * @param belegung   die Fachbelegung (siehe {@link AbiturFachbelegung})
     *
     * @return das Fach der gymnasialen Oberstufe (siehe {@link GostFach})
     */
    getFach(belegung) {
        if (belegung === null)
            return null;
        return this.gostFaecher.get(belegung.fachID);
    }
    /**
     * Prüft, ob das Faches in allen angegebenen Halbjahren belegt wurde.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegung      die zu prüfende Fachbelegung
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls das Fach in den Halbjahren belegt wurde, sonst false
     */
    pruefeBelegung(fachbelegung, ...halbjahre) {
        if (fachbelegung === null)
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return true;
        for (let halbjahr of halbjahre) {
            let belegungHalbjahr = fachbelegung.belegungen[halbjahr.id];
            if ((belegungHalbjahr === null) || (belegungHalbjahr.kursartKuerzel === null))
                return false;
        }
        return true;
    }
    /**
     * Bestimmt die Anzahl der Fachbelegungen, die dem Fach zugeordnet sind.
     * Wird keine gültige Fachbelegung übergeben, so wird 0 zurückgegeben.
     *
     * @param fachbelegung   die Fachbelegung
     *
     * @return die Anzahl der Belegungen des Faches
     */
    zaehleBelegung(fachbelegung) {
        if (fachbelegung === null)
            return 0;
        let anzahl = 0;
        for (let i = 0; i < GostHalbjahr_1.GostHalbjahr.maxHalbjahre; i++) {
            if (fachbelegung.belegungen[i] !== null)
                anzahl++;
        }
        return anzahl;
    }
    /**
     * Zählt die Anzahl der Belegungen für die angegebenen Fachbelegungen in den angegeben Halbjahren.
     * Ist die Fachbelegung null, so wird 0 zurückgegeben. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so wird ebenfalls 0 zurückgegeben.
     *
     * @param fachbelegungen      die Fachbelegungen
     * @param halbjahre           die Halbjahre
     *
     * @return die Anzahl der Belegungen in den Halbjahren und den Fächern
     */
    zaehleBelegungInHalbjahren(fachbelegungen, ...halbjahre) {
        if (fachbelegungen === null)
            return 0;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return 0;
        let anzahl = 0;
        for (let fachbelegung of fachbelegungen)
            for (let halbjahr of halbjahre)
                if (fachbelegung.belegungen[halbjahr.id] !== null)
                    anzahl++;
        return anzahl;
    }
    /**
     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren der angegebenen Kursart entspricht.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegung      die zu prüfende Fachnbelegung
     * @param kursart           die zu prüfende Kursart
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungMitKursart(fachbelegung, kursart, ...halbjahre) {
        if (fachbelegung === null)
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return true;
        for (let halbjahr of halbjahre) {
            let belegungHalbjahr = fachbelegung.belegungen[halbjahr.id];
            if ((belegungHalbjahr === null) || (kursart !== GostKursart_1.GostKursart.fromKuerzel(belegungHalbjahr.kursartKuerzel)))
                return false;
        }
        return true;
    }
    /**
     * Prüft, ob eine Fachbelegung existiert, welche in den angegebenen Halbjahren der angegebenen Kursart
     * entspricht.
     * Ist keine Fachbelegung angegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen
     * Fachbelegung kein Halbjahr angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param kursart           die zu prüfende Kursart
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungExistiertMitKursart(fachbelegungen, kursart, ...halbjahre) {
        if ((fachbelegungen === null) || (fachbelegungen.size() <= 0))
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return true;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeBelegungMitKursart(fachbelegung, kursart, ...halbjahre))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren mindestens einmal die angegebenen Kursart hat.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung nicht erfolgreich, da kein Halbjahr geprüft werden muss und somit die Kursart nicht
     * einmal existiert.
     *
     * @param fachbelegung      die zu prüfende Fachnbelegung
     * @param kursart           die zu prüfende Kursart
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die Kursart mindestens einmal in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungHatMindestensEinmalKursart(fachbelegung, kursart, ...halbjahre) {
        if (fachbelegung === null)
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return false;
        for (let halbjahr of halbjahre) {
            let belegungHalbjahr = fachbelegung.belegungen[halbjahr.id];
            if (belegungHalbjahr === null)
                continue;
            if (kursart === GostKursart_1.GostKursart.fromKuerzel(belegungHalbjahr.kursartKuerzel))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung des Faches in dem angegebenen Halbjahr der angegebenen Schriftlichkeit entspricht.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl.
     *
     * @param fachbelegung      die zu prüfende Fachnbelegung
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahr          das zu prüfende Halbjahr
     *
     * @return true, falls die Schriftlichkeit in dem Halbjahr gegeben ist, sonst false
     */
    pruefeBelegungMitSchriftlichkeitEinzeln(fachbelegung, schriftlichkeit, halbjahr) {
        if (fachbelegung === null)
            return false;
        let belegungHalbjahr = fachbelegung.belegungen[halbjahr.id];
        if ((belegungHalbjahr === null) || (belegungHalbjahr.schriftlich === null) || ((schriftlichkeit !== GostSchriftlichkeit_1.GostSchriftlichkeit.BELIEBIG) && (((schriftlichkeit === GostSchriftlichkeit_1.GostSchriftlichkeit.SCHRIFTLICH) && (!belegungHalbjahr.schriftlich)) || ((schriftlichkeit === GostSchriftlichkeit_1.GostSchriftlichkeit.MUENDLICH) && (belegungHalbjahr.schriftlich)))))
            return false;
        return true;
    }
    /**
     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegung      die zu prüfende Fachnbelegung
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungMitSchriftlichkeit(fachbelegung, schriftlichkeit, ...halbjahre) {
        if (fachbelegung === null)
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return true;
        for (let halbjahr of halbjahre)
            if (!this.pruefeBelegungMitSchriftlichkeitEinzeln(fachbelegung, schriftlichkeit, halbjahr))
                return false;
        return true;
    }
    /**
     * Prüft, ob eine Belegung des Faches in den angegebenen Halbjahren nicht der angegebenen Schriftlichkeit entspricht.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegung      die zu prüfende Fachnbelegung
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die Schriftlichkeit in den Halbjahren nicht gegeben ist, sonst false
     */
    pruefeBelegungErfuelltNicht(fachbelegung, schriftlichkeit, ...halbjahre) {
        if (fachbelegung === null)
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return true;
        for (let halbjahr of halbjahre) {
            let belegungHalbjahr = fachbelegung.belegungen[halbjahr.id];
            if ((belegungHalbjahr === null) || ((schriftlichkeit !== GostSchriftlichkeit_1.GostSchriftlichkeit.BELIEBIG) && (((schriftlichkeit === GostSchriftlichkeit_1.GostSchriftlichkeit.SCHRIFTLICH) && (!belegungHalbjahr.schriftlich)) || ((schriftlichkeit === GostSchriftlichkeit_1.GostSchriftlichkeit.MUENDLICH) && (belegungHalbjahr.schriftlich)))))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob eine Belegung des Faches in den angegebenen Halbjahren nicht der angegebenen Schriftlichkeit entspricht,
     * sofern es in dem Halbjahr überhaupt belegt wurde..
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegung      die zu prüfende Fachnbelegung
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die Schriftlichkeit in den Halbjahren nicht gegeben ist, sonst false
     */
    pruefeBelegungErfuelltNichtFallsBelegt(fachbelegung, schriftlichkeit, ...halbjahre) {
        if (fachbelegung === null)
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return true;
        for (let halbjahr of halbjahre) {
            let belegungHalbjahr = fachbelegung.belegungen[halbjahr.id];
            if (belegungHalbjahr === null)
                continue;
            let schriftlich = belegungHalbjahr.schriftlich === null ? false : belegungHalbjahr.schriftlich;
            if (((schriftlichkeit !== GostSchriftlichkeit_1.GostSchriftlichkeit.BELIEBIG) && (((schriftlichkeit === GostSchriftlichkeit_1.GostSchriftlichkeit.SCHRIFTLICH) && (!schriftlich)) || ((schriftlichkeit === GostSchriftlichkeit_1.GostSchriftlichkeit.MUENDLICH) && (schriftlich)))))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren mindestens einmal die angegebene Schritflichkeit hat.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung nicht erfolgreich, da kein Halbjahr geprüft werden muss und somit die Schriftlichkeit nicht
     * einmal existiert.
     *
     * @param fachbelegung      die zu prüfende Fachbelegung
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die angegebene Schriftlichkeit mindestens einmal in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungHatMindestensEinmalSchriftlichkeit(fachbelegung, schriftlichkeit, ...halbjahre) {
        if (fachbelegung === null)
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return false;
        for (let halbjahr of halbjahre) {
            let belegungHalbjahr = fachbelegung.belegungen[halbjahr.id];
            if (belegungHalbjahr === null)
                continue;
            if ((schriftlichkeit.istSchriftlich === null) || (schriftlichkeit.istSchriftlich === belegungHalbjahr.schriftlich))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob eine Fachbelegung existiert, welche in den angegebenen Halbjahren mindestens einmal die angegebene
     * Schritflichkeit hat.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung nicht erfolgreich, da kein Halbjahr geprüft werden muss und somit die Schriftlichkeit nicht
     * einmal existiert.
     *
     * @param fachbelegungen    die zu prüfenden Fachbelegungen
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die angegebene Schriftlichkeit bei einer Fachbelegung mindestens einmal in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungExistiertHatMindestensEinmalSchriftlichkeit(fachbelegungen, schriftlichkeit, ...halbjahre) {
        if ((fachbelegungen === null) || (fachbelegungen.size() <= 0))
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return false;
        for (let fachbelegung of fachbelegungen)
            if (this.pruefeBelegungHatMindestensEinmalSchriftlichkeit(fachbelegung, schriftlichkeit, ...halbjahre))
                return true;
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer mit den angegebenen Halbjahren existiert.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist z.B. bei bilingualen
     * Fächern nötig oder bei der Unterscheidung von Sport-Profilen.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls eine Fachbelegung mit den Halbjahren existiert, sonst false
     */
    pruefeBelegungExistiert(fachbelegungen, ...halbjahre) {
        if (fachbelegungen === null)
            return false;
        if ((halbjahre === null) || (halbjahre.length === 0))
            return true;
        for (let fachbelegung of fachbelegungen) {
            let fach = this.gostFaecher.get(fachbelegung.fachID);
            if (fach === null)
                continue;
            let alleBelegungen = this.getFachbelegungByFachkuerzel(fach.kuerzel);
            if ((alleBelegungen === null) || (alleBelegungen.size() === 0))
                continue;
            let hatBelegung = true;
            for (let halbjahr of halbjahre) {
                let hatHalbjahresBelegung = false;
                for (let aktFachbelegung of alleBelegungen) {
                    if (aktFachbelegung.belegungen[halbjahr.id] !== null) {
                        hatHalbjahresBelegung = true;
                        break;
                    }
                }
                if (!hatHalbjahresBelegung) {
                    hatBelegung = false;
                    break;
                }
            }
            if (hatBelegung)
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer mit dem angegebenen Halbjahr existiert.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl.
     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist z.B. bei bilingualen
     * Fächern nötig oder bei der Unterscheidung von Sport-Profilen.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param halbjahr          das zu prüfende Halbjahr
     *
     * @return true, falls eine Fachbelegung mit dem Halbjahr existiert, sonst false
     */
    pruefeBelegungExistiertEinzeln(fachbelegungen, halbjahr) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            let fach = this.gostFaecher.get(fachbelegung.fachID);
            if (fach === null)
                continue;
            let alleBelegungen = this.getFachbelegungByFachkuerzel(fach.kuerzel);
            if ((alleBelegungen === null) || (alleBelegungen.size() === 0))
                continue;
            for (let aktFachbelegung of alleBelegungen)
                if (aktFachbelegung.belegungen[halbjahr.id] !== null)
                    return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer mit einer durchgängigen Belegung existiert,
     * die zumindest in der Q1 und der Q2.1 schriftlich ist.
     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist bei bilingualen
     * Fächern nötig.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     *
     * @return true, falls eine durchgehend schriftliche Fachbelegung existiert, sonst false
     */
    pruefeBelegungExistiertDurchgehendSchriftlich(fachbelegungen) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            let fach = this.gostFaecher.get(fachbelegung.fachID);
            if (fach === null)
                continue;
            let alleBelegungen = this.getFachbelegungByFachkuerzel(fach.kuerzel);
            if ((alleBelegungen === null) || (alleBelegungen.size() === 0))
                continue;
            let hatBelegung = true;
            for (let halbjahr of GostHalbjahr_1.GostHalbjahr.values()) {
                let hatHalbjahresBelegung = false;
                for (let aktFachbelegung of alleBelegungen) {
                    if (aktFachbelegung.belegungen[halbjahr.id] !== null) {
                        let belegungHalbjahr = aktFachbelegung.belegungen[halbjahr.id];
                        if (((halbjahr !== GostHalbjahr_1.GostHalbjahr.Q11) && (halbjahr !== GostHalbjahr_1.GostHalbjahr.Q12) && (halbjahr !== GostHalbjahr_1.GostHalbjahr.Q21)) || ((belegungHalbjahr !== null) && (belegungHalbjahr.schriftlich !== null) && (belegungHalbjahr.schriftlich)))
                            hatHalbjahresBelegung = true;
                    }
                }
                if (!hatHalbjahresBelegung) {
                    hatBelegung = false;
                    break;
                }
            }
            if (hatBelegung)
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer in dem angegebenen Halbjahr der angegebenen Schriftlichkeit entspricht.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahr          das zu prüfende Halbjahr
     *
     * @return true, falls bei einer Fachbelegung die Schriftlichkeit in dem Halbjahr gegeben ist, sonst false
     */
    pruefeBelegungExistiertMitSchriftlichkeitEinzeln(fachbelegungen, schriftlichkeit, halbjahr) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeBelegungMitSchriftlichkeitEinzeln(fachbelegung, schriftlichkeit, halbjahr))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls bei einer Fachbelegung die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungExistiertMitSchriftlichkeit(fachbelegungen, schriftlichkeit, ...halbjahre) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeBelegungMitSchriftlichkeit(fachbelegung, schriftlichkeit, ...halbjahre))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren mindestens einmal die angegebene Kursart
     * hat. Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param kursart           die zu prüfende Kursart
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die Kursart bei einer Fachbelegung mindestens einmal in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungExistiertHatMindestensEinmalKursart(fachbelegungen, kursart, ...halbjahre) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeBelegungHatMindestensEinmalKursart(fachbelegung, kursart, ...halbjahre))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren existiert,
     * bei welchem in mind. einem der Halbjahren die angebene Schriftlichkeit nicht gegeben ist.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true oder false (siehe oben)
     */
    pruefeBelegungExistiertErfuelltNicht(fachbelegungen, schriftlichkeit, ...halbjahre) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeBelegungErfuelltNicht(fachbelegung, schriftlichkeit, ...halbjahre))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren existiert,
     * bei welchem in mind. einem der Halbjahren die angebene Schriftlichkeit nicht gegeben ist, sofern
     * das Fach überhaupt belegt wurde.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true oder false (siehe oben)
     */
    pruefeBelegungExistiertErfuelltNichtFallsBelegt(fachbelegungen, schriftlichkeit, ...halbjahre) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeBelegungErfuelltNichtFallsBelegt(fachbelegung, schriftlichkeit, ...halbjahre))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht
     * und das Fach durchgehend belegbar ist.
     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegung      die zu prüfende Fachnbelegung
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungDurchgehendBelegbar(fachbelegung, schriftlichkeit, ...halbjahre) {
        if (fachbelegung === null)
            return false;
        if (!GostFachManager_1.GostFachManager.istDurchgehendBelegbarBisQ22(this.getFach(fachbelegung)))
            return false;
        return this.pruefeBelegungMitSchriftlichkeit(fachbelegung, schriftlichkeit, ...halbjahre);
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht
     * und das Fach durchgängig belegbar ist.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls bei einer Fachbelegung die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungDurchgehendBelegbarExistiert(fachbelegungen, schriftlichkeit, ...halbjahre) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeBelegungDurchgehendBelegbar(fachbelegung, schriftlichkeit, ...halbjahre))
                return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht
     * und das Fach durchgängig belegt ist.
     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
     * angegeben, so ist die Prüfung erfolgreich sofern das Fach durchgängig belegt wurde, da kein Halbjahr auf die
     * Schriftlichkeit geprüft werden muss.
     *
     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
     * @param halbjahre         die zu prüfenden Halbjahre
     *
     * @return true, falls bei eine Fachbelegung durchgängig belegt wurde und die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
     */
    pruefeBelegungDurchgehendBelegtExistiert(fachbelegungen, schriftlichkeit, ...halbjahre) {
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeBelegung(fachbelegung, GostHalbjahr_1.GostHalbjahr.EF1, GostHalbjahr_1.GostHalbjahr.EF2, GostHalbjahr_1.GostHalbjahr.Q11, GostHalbjahr_1.GostHalbjahr.Q12, GostHalbjahr_1.GostHalbjahr.Q21, GostHalbjahr_1.GostHalbjahr.Q22))
                if (this.pruefeBelegungMitSchriftlichkeit(fachbelegung, schriftlichkeit, ...halbjahre))
                    return true;
        }
        return false;
    }
    /**
     * Prüft, ob die Fachbelegung in mindestens einem der Halbjahre die angegebene Kursart aufweist.
     * Existiert die Fachbelegung nicht (null), so kommt die Kursart auch nicht vor.
     *
     * @param fachbelegung   die Fachbelegung
     * @param kursart        die Kursart
     *
     * @return true, falls mindestens einmal die Kursart belegt wurde, sonst false
     */
    pruefeAufKursart(fachbelegung, kursart) {
        if (fachbelegung === null)
            return false;
        for (let belegunghalbjahr of fachbelegung.belegungen) {
            if ((belegunghalbjahr !== null) && GostKursart_1.GostKursart.fromKuerzel(belegunghalbjahr.kursartKuerzel) === kursart)
                return true;
        }
        return false;
    }
    /**
     * Filtert die Fachbelegungen und gibt nur die Fachbelegungen zurück, bei denen die
     * Kursart existiert.
     * Wird keine Fachbelegung übergeben (null oder leere Liste), so kommt auch keine
     * Belegung mit der Kursart vor.
     *
     * @param fachbelegungen   die Fachbelegungen
     * @param kursart          die Kursart
     *
     * @return eine Liste mit den Fachbelegungen, welche die kursart haben
     */
    filterBelegungKursartExistiert(fachbelegungen, kursart) {
        let result = new Vector_1.Vector();
        if ((fachbelegungen === null) || (fachbelegungen.size() <= 0))
            return result;
        for (let fachbelegung of fachbelegungen) {
            if (this.pruefeAufKursart(fachbelegung, kursart))
                result.add(fachbelegung);
        }
        return result;
    }
    /**
     * Prüft, ob die Fachbelegung eine durchgängige Belegung hat. Zusatzkurse können nicht für eine
     * durchgängige Belegung zählen.
     *
     * @param fachbelegung   die zu prüfende Fachbelegung
     *
     * @return true, wenn die Belegung durchgängig ist.
     */
    pruefeDurchgaengigkeit(fachbelegung) {
        if ((fachbelegung === null) || (this.pruefeAufKursart(fachbelegung, GostKursart_1.GostKursart.ZK)))
            return false;
        return this.pruefeBelegung(fachbelegung, GostHalbjahr_1.GostHalbjahr.EF1, GostHalbjahr_1.GostHalbjahr.EF2, GostHalbjahr_1.GostHalbjahr.Q11, GostHalbjahr_1.GostHalbjahr.Q12, GostHalbjahr_1.GostHalbjahr.Q21, GostHalbjahr_1.GostHalbjahr.Q22);
    }
    /**
     * Zählt die Fachbelegungen, welche eine durchgängige Belegung aufweisen. Zusatzkurse zählen
     * nicht für eine durchgängige Belegung.
     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist bei bilingualen
     * Fächern nötig.
     *
     * @param fachbelegungen   die zu überprüfenden Fachbelegungen
     *
     * @return die Anzahl der durchgängigen Belegungen
     */
    zaehleDurchgaengigeBelegungen(fachbelegungen) {
        if (fachbelegungen === null)
            return 0;
        let anzahl = 0;
        for (let fachbelegung of fachbelegungen) {
            let fach = this.gostFaecher.get(fachbelegung.fachID);
            if (fach === null)
                continue;
            if (fachbelegung.belegungen[GostHalbjahr_1.GostHalbjahr.EF1.id] === null)
                continue;
            let alleBelegungen = this.getFachbelegungByFachkuerzel(fach.kuerzel);
            if ((alleBelegungen === null) || (alleBelegungen.size() === 0))
                continue;
            let hatBelegung = true;
            let halbjahre = [GostHalbjahr_1.GostHalbjahr.EF1, GostHalbjahr_1.GostHalbjahr.Q11, GostHalbjahr_1.GostHalbjahr.Q12, GostHalbjahr_1.GostHalbjahr.Q21, GostHalbjahr_1.GostHalbjahr.Q22];
            for (let halbjahr of halbjahre) {
                let hatHalbjahresBelegung = false;
                for (let aktFachbelegung of alleBelegungen) {
                    if (aktFachbelegung.belegungen[halbjahr.id] !== null) {
                        hatHalbjahresBelegung = true;
                        break;
                    }
                }
                if (!hatHalbjahresBelegung) {
                    hatBelegung = false;
                    break;
                }
            }
            if (hatBelegung)
                anzahl++;
        }
        return anzahl;
    }
    /**
     * Prüft, ob die Fachbelegung eine durchgängige Belegung hat und prüft die Schriftlichkeit
     * in der Qualifikationsphase. Ein Fach in der Qualifikationsphase gilt als Schriftlich belegt,
     * sofern die ersten 3 Halbjahre der Qualifikationsphase schriftlich belegt wurden.
     * - Zusatzkurse können nicht für eine durchgängige Belegung zählen.
     *
     * @param fachbelegung   die zu prüfende die zu überprüfenden Fachbelegung
     *
     * @return true, wenn die Belegung durchgängig ist und die Schriftlichkeit den Anforderungen genügt.
     */
    pruefeDurchgaengigkeitSchriftlich(fachbelegung) {
        if (!this.pruefeDurchgaengigkeit(fachbelegung))
            return false;
        return this.pruefeBelegungMitSchriftlichkeit(fachbelegung, GostSchriftlichkeit_1.GostSchriftlichkeit.SCHRIFTLICH, GostHalbjahr_1.GostHalbjahr.Q11, GostHalbjahr_1.GostHalbjahr.Q12, GostHalbjahr_1.GostHalbjahr.Q21);
    }
    /**
     * Prüft, ob unter den angegebenen Fachbelegungen ein Fach als Abiturfach von einem der angegebenen Arten
     * gewählt wurde. Wird keine Art angebeben, so wird jede Fachbelegung akzeptiert und true zurückgegeben.
     *
     * @param fachbelegungen   die Fachbelegungen
     * @param arten            die Arten der Abiturfächer
     *
     * @return true, falls unter den Fachbelegungen mindestens ein Fach als Abiturfach von einem der
     *         angegebenen Arten gewählt wurde und false sonst
     */
    pruefeExistiertAbiFach(fachbelegungen, ...arten) {
        if ((arten === null) || (arten.length === 0))
            return true;
        if (fachbelegungen === null)
            return false;
        for (let fachbelegung of fachbelegungen)
            for (let art of arten) {
                let abiturFach = GostAbiturFach_1.GostAbiturFach.fromID(fachbelegung.abiturFach);
                if (abiturFach === art)
                    return true;
            }
        return false;
    }
    /**
     * Prüft anhand des Statistik-Kürzels, ob in dem angegebenen Halbjahr eine doppelte Fachbelegung
     * vorliegt oder nicht. Bei den Fremdsprachen werden nur unterschiedliche Fremdsprachen in einem Halbjahr
     * akzeptiert und es dürfen mehrere Vertiefungsfächer (VX) in einem Halbjahr vorkommen.
     *
     * @param halbjahr   das zu prüfende Halbjahr
     *
     * @return true, falls eine doppelte Belegung vorliegt, sonst false
     */
    hatDoppelteFachbelegungInHalbjahr(halbjahr) {
        let set = new HashSet_1.HashSet();
        let fachbelegungen = this.abidaten.fachbelegungen;
        for (let fb of fachbelegungen) {
            let fach = this.getFach(fb);
            if (fach === null)
                continue;
            let belegung = this.getBelegungHalbjahr(fb, halbjahr, GostSchriftlichkeit_1.GostSchriftlichkeit.BELIEBIG);
            if (belegung === null)
                continue;
            let kuerzel = GostFachManager_1.GostFachManager.getFremdsprache(fach);
            if (kuerzel === null)
                kuerzel = fach.kuerzel === null ? "" : fach.kuerzel;
            if (!set.add(kuerzel) && (!JavaObject_1.JavaObject.equalsTranspiler("VX", (kuerzel))))
                return true;
        }
        return false;
    }
    /**
     * Prüft anhand des Statistik-Kürzels, ob in einem der angegebenen Halbjahre eine doppelte Fachbelegung
     * vorliegt oder nicht. Bei den Fremdsprachen werden nur unterschiedliche Fremdsprachen in einem Halbjahr
     * akzeptiert und es dürfen mehrere Vertiefungsfächer (VX) in einem Halbjahr vorkommen.
     *
     * @param halbjahre   die zu prüfenden Halbjahre
     *
     * @return true, falls eine doppelte Belegung vorliegt, sonst false
     */
    hatDoppelteFachbelegung(...halbjahre) {
        if ((halbjahre === null) || (halbjahre.length === 0))
            return false;
        for (let halbjahr of halbjahre)
            if (this.hatDoppelteFachbelegungInHalbjahr(halbjahr))
                return true;
        return false;
    }
    /**
     * Gibt zurück, ob der Projektkurs als besondere Lernleistung verwendet wird.
     *
     * @return true, falls der Projektkurs als besondere Lernleistung verwendet wird
     */
    istProjektKursBesondereLernleistung() {
        return (GostBesondereLernleistung_1.GostBesondereLernleistung.PROJEKTKURS.is(this.abidaten.besondereLernleistung));
    }
    /**
     * Bestimmt die erste Fachbelegung mit dem angegebenen Statistik-Kürzel
     *
     * @param kuerzel          das Kürzel des Faches, kann null sein (dann wird auch null zurückgegeben)
     *
     * @return die Fachbelegung oder null, falls keine vorhanden ist
     */
    getFachbelegungByKuerzel(kuerzel) {
        if ((kuerzel === null) || (JavaObject_1.JavaObject.equalsTranspiler("", (kuerzel))))
            return null;
        let fachbelegungen = this.abidaten.fachbelegungen;
        for (let fb of fachbelegungen) {
            let fach = this.getFach(fb);
            if ((fach !== null) && (JavaObject_1.JavaObject.equalsTranspiler(kuerzel, (fach.kuerzel))))
                return fb;
        }
        return null;
    }
    /**
     * Liefert alle Fachbelegungen der Abiturdaten, welche den angegebenen Fachbereichen zuzuordnen sind.
     * Wird kein Fachbereich angegeben, so werden alle Fachbelegungen der Abiturdaten zurückgegeben.
     *
     * @param fachbereiche   die Fachbereiche
     *
     * @return eine Liste der Fachbelegungen aus den Fachbereichen
     */
    getFachbelegungen(...fachbereiche) {
        if ((fachbereiche === null) || (fachbereiche.length === 0))
            return this.abidaten.fachbelegungen;
        let result = new Vector_1.Vector();
        for (let fachbereich of fachbereiche) {
            let fachbelegungen = this.mapFachbereiche.get(fachbereich);
            if (fachbelegungen === null)
                continue;
            result.addAll(fachbelegungen);
        }
        return result;
    }
    /**
     * Liefert alle Fachbelegungen, die bilingual unterrichtet wurden.
     *
     * @return eine Liste der Fachbelegungen
     */
    getFachbelegungenBilingual() {
        let result = new Vector_1.Vector();
        let fachbelegungen = this.abidaten.fachbelegungen;
        for (let fb of fachbelegungen) {
            if (this.zaehleBelegung(fb) <= 0)
                continue;
            let fach = this.getFach(fb);
            if ((fach !== null) && (!GostFachbereich_1.GostFachbereich.FREMDSPRACHE.hat(fach)) && (!GostFachbereich_1.GostFachbereich.DEUTSCH.hat(fach)) && (fach.biliSprache !== null) && (!JavaObject_1.JavaObject.equalsTranspiler("D", (fach.biliSprache))))
                result.add(fb);
        }
        return result;
    }
    /**
     * Filtert die Fachbelegungen auf neu einsetzende Fremdsprachen.
     *
     * @param fachbelegungen   die zu filternden Fachbelegungen
     *
     * @return die gefilterten Fachbelegungen
     */
    filterFremdspracheNeuEinsetzend(fachbelegungen) {
        if (fachbelegungen === null)
            return Collections_1.Collections.emptyList();
        let result = new Vector_1.Vector();
        for (let fb of fachbelegungen) {
            let fach = this.getFach(fb);
            if ((fach !== null) && fach.istFremdsprache && fach.istFremdSpracheNeuEinsetzend)
                result.add(fb);
        }
        return result;
    }
    /**
     * Filtert die Fachbelegungen auf fortgeführte Fremdsprachen.
     *
     * @param fachbelegungen   die zu filternden Fachbelegungen
     *
     * @return die gefilterten Fachbelegungen
     */
    filterFremdspracheFortgefuehrt(fachbelegungen) {
        if (fachbelegungen === null)
            return Collections_1.Collections.emptyList();
        let result = new Vector_1.Vector();
        for (let fb of fachbelegungen) {
            let fach = this.getFach(fb);
            if ((fach !== null) && fach.istFremdsprache && !fach.istFremdSpracheNeuEinsetzend)
                result.add(fb);
        }
        return result;
    }
    /**
     * Filtert die Fachbelegungen danach, ob sie durchgehend belegbar sind
     *
     * @param fachbelegungen   die zu filternden Fachbelegungen
     *
     * @return die gefilterten Fachbelegungen
     */
    filterDurchgehendBelegbar(fachbelegungen) {
        let result = new Vector_1.Vector();
        if (fachbelegungen === null)
            return result;
        for (let fb of fachbelegungen) {
            let fach = this.getFach(fb);
            if (GostFachManager_1.GostFachManager.istDurchgehendBelegbarBisQ22(fach))
                result.add(fb);
        }
        return result;
    }
    /**
     * Filtert die Fachbelegungen. Es werden nur Fachbelegungen behalten, die in den angegebenen Halbjahren eine Belegung aufweisen.
     * Wird kein Halbjahr angegeben, so wird nichts gefiltert, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegungen    die zu filternden Fachbelegungen
     * @param halbjahre         die Halbjahre, die belegt sein müssen
     *
     * @return die gefilterten Fachbelegungen
     */
    filterBelegungen(fachbelegungen, ...halbjahre) {
        if (fachbelegungen === null)
            return Collections_1.Collections.emptyList();
        let result = new Vector_1.Vector();
        for (let fb of fachbelegungen) {
            if (this.pruefeBelegung(fb, ...halbjahre))
                result.add(fb);
        }
        return result;
    }
    /**
     * Diese Methode zählt die Anzahl der angegebenen Fachbelegungen, welche in allen
     * Halbjahren belegt sind. Dabei werden Fachbelegungen, welche dem gleichem Statistik-Fach
     * zuzuordnen sind zusammengefasst. Dies ist bei der Abwahl von bilingualen Sachfächern
     * relevant.
     *
     * @param fachbelegungen   die zu zählenden Fachbelegungen
     *
     * @return die Anzahl der Fachbelegungen
     */
    zaehleBelegungenDurchgaengig(fachbelegungen) {
        if (fachbelegungen === null)
            return 0;
        let faecher = new HashSet_1.HashSet();
        for (let fb of fachbelegungen) {
            let fach = this.gostFaecher.get(fb.fachID);
            if (fach === null)
                continue;
            let zulFach = ZulaessigesFach_1.ZulaessigesFach.getByKuerzelASD(fach.kuerzel);
            if (zulFach !== ZulaessigesFach_1.ZulaessigesFach.DEFAULT)
                faecher.add(zulFach);
        }
        let count = 0;
        for (let zulFach of faecher) {
            let vorhanden = true;
            for (let halbjahr of GostHalbjahr_1.GostHalbjahr.values()) {
                let belegung_vorhanden = false;
                for (let fb of fachbelegungen) {
                    let fbFach = this.gostFaecher.get(fb.fachID);
                    if (fbFach === null)
                        continue;
                    let fbZulFach = ZulaessigesFach_1.ZulaessigesFach.getByKuerzelASD(fbFach.kuerzel);
                    if ((zulFach === fbZulFach) && (fb.belegungen[halbjahr.id] !== null)) {
                        belegung_vorhanden = true;
                        break;
                    }
                }
                if (!belegung_vorhanden) {
                    vorhanden = false;
                    break;
                }
            }
            if (vorhanden)
                count++;
        }
        return count;
    }
    /**
     * Diese Methode zählt die Anzahl der angegebenen Fachbelegungen, welche in allen
     * Halbjahren belegt sind. Dabei werden Fachbelegungen, welche dem gleichem Statistik-Fach
     * zuzuordnen sind zusammengefasst. Dies ist bei der Abwahl von bilingualen Sachfächern
     * relevant.
     *
     * @param fachbelegungen   die zu zählenden Fachbelegungen
     *
     * @return die Anzahl der Fachbelegungen
     */
    zaehleBelegungenDurchgaengigSchriftlichInQPhase(fachbelegungen) {
        if (fachbelegungen === null)
            return 0;
        let faecher = new HashSet_1.HashSet();
        for (let fb of fachbelegungen) {
            let fach = this.gostFaecher.get(fb.fachID);
            if (fach === null)
                continue;
            let zulFach = ZulaessigesFach_1.ZulaessigesFach.getByKuerzelASD(fach.kuerzel);
            if (zulFach !== ZulaessigesFach_1.ZulaessigesFach.DEFAULT)
                faecher.add(zulFach);
        }
        let count = 0;
        for (let zulFach of faecher) {
            let vorhanden = true;
            for (let halbjahr of GostHalbjahr_1.GostHalbjahr.values()) {
                let belegung_vorhanden = false;
                for (let fb of fachbelegungen) {
                    let fbFach = this.gostFaecher.get(fb.fachID);
                    if (fbFach === null)
                        continue;
                    let fbZulFach = ZulaessigesFach_1.ZulaessigesFach.getByKuerzelASD(fbFach.kuerzel);
                    if (zulFach === fbZulFach) {
                        let belegung = fb.belegungen[halbjahr.id];
                        if (belegung !== null) {
                            let istSchriftlichkeitOK = true;
                            if (((halbjahr === GostHalbjahr_1.GostHalbjahr.Q11) || (halbjahr === GostHalbjahr_1.GostHalbjahr.Q12) || (halbjahr === GostHalbjahr_1.GostHalbjahr.Q21)) && ((belegung.schriftlich === null) || (!belegung.schriftlich)))
                                istSchriftlichkeitOK = false;
                            if (istSchriftlichkeitOK) {
                                belegung_vorhanden = true;
                                break;
                            }
                        }
                    }
                }
                if (!belegung_vorhanden) {
                    vorhanden = false;
                    break;
                }
            }
            if (vorhanden)
                count++;
        }
        return count;
    }
    /**
     * Filtert die Fachbelegungen. Es werden nur Belegungen behalten, die in den angegebenen Halbjahren die geforderte Schriftlichkeit aufweisen.
     * Wird kein Halbjahr angegeben, so wird nichts gefiltert, da kein Halbjahr geprüft werden muss.
     *
     * @param fachbelegungen    die zu filternden Fachbelegungen
     * @param schriftlichkeit   die geforderte Schriftlichkeit
     * @param halbjahre         die Halbjahre, die belegt sein müssen
     *
     * @return die gefilterten Fachbelegungen
     */
    filterBelegungenMitSchriftlichkeit(fachbelegungen, schriftlichkeit, ...halbjahre) {
        if (fachbelegungen === null)
            return Collections_1.Collections.emptyList();
        let result = new Vector_1.Vector();
        for (let fb of fachbelegungen) {
            if (this.pruefeBelegungMitSchriftlichkeit(fb, schriftlichkeit, ...halbjahre))
                result.add(fb);
        }
        return result;
    }
    /**
     * Liefert die erste Fachbelegung für den Fachbereich - sofern eine existiert
     *
     * @param fachbereich   der Fachbereich
     *
     * @return die Fachbelegung oder null
     */
    getFachbelegung(fachbereich) {
        let faecher = this.mapFachbereiche.get(fachbereich);
        if ((faecher === null) || (faecher.size() === 0))
            return null;
        return faecher.get(0);
    }
    /**
     * Liefert alle Fachbelegungen mit dem angegebenen Statistk-Kürzel des Faches
     *
     * @param kuerzel   das Kürzel des Faches
     *
     * @return eine Liste mit den Fachbelegungen
     */
    getFachbelegungByFachkuerzel(kuerzel) {
        let fachbelegungen = new Vector_1.Vector();
        if (kuerzel === null)
            return fachbelegungen;
        let tmpFachbelegungen = this.abidaten.fachbelegungen;
        for (let fachbelegung of tmpFachbelegungen) {
            let fach = this.gostFaecher.get(fachbelegung.fachID);
            if ((fach === null) || (!JavaObject_1.JavaObject.equalsTranspiler(kuerzel, (fach.kuerzel))))
                continue;
            fachbelegungen.add(fachbelegung);
        }
        return fachbelegungen;
    }
    /**
     * Prüft, ob der Kurs in dem angegebenen Halbjahr mit der angegebenen Schriftlichkeit belegt ist
     * und gibt ggf. die Belegung zurück.
     *
     * @param fachbelegung   die Abiturfachbelegung aus welcher die Belegungsinformationen für das Halbjahr entnommen wird
     * @param halbjahr       das Halbjahr, in welchem die Belegung gesucht wird.
     * @param schriftlich    gibt an, ob das Fach schriftlich oder mündlich belegt sein muss
     *
     * @return die Belegungsinformationen zu dem Fach
     */
    getBelegungHalbjahr(fachbelegung, halbjahr, schriftlich) {
        let belegung = fachbelegung.belegungen[halbjahr.id];
        return ((belegung !== null) && ((schriftlich === GostSchriftlichkeit_1.GostSchriftlichkeit.BELIEBIG) || ((schriftlich === GostSchriftlichkeit_1.GostSchriftlichkeit.SCHRIFTLICH) && (belegung.schriftlich)) || ((schriftlich === GostSchriftlichkeit_1.GostSchriftlichkeit.MUENDLICH) && (!belegung.schriftlich)))) ? belegung : null;
    }
    /**
     * Liefert die erste Sprachbelegung - sofern eine existiert
     *
     * @param sprache   das einstellige Kürzel der Sprache
     *
     * @return die Fachbelegung für die Sprache
     */
    getSprachbelegung(sprache) {
        if (sprache === null)
            return null;
        let fachbelegungen = this.abidaten.fachbelegungen;
        for (let fb of fachbelegungen) {
            let fach = this.getFach(fb);
            if ((fach === null) || (!GostFachManager_1.GostFachManager.istFremdsprachenfach(fach, sprache)))
                continue;
            if (JavaObject_1.JavaObject.equalsTranspiler(sprache, (GostFachManager_1.GostFachManager.getFremdsprache(fach))))
                return fb;
        }
        return null;
    }
    /**
     * Liefert für die übergebene Fachbelegung die Halbjahre, in denen das Fach mit einer der angebenen
     * Kursarten belegt wurde. Ist keine Kursart angegeben, so werden die Halbjahre aller Belegungen
     * zurückgegeben. Ist keine Fachbelegung angegeben, so wird eine leere Liste zurückgegeben.
     *
     * @param fachbelegung   die Fachbelegung
     * @param kursarten      die Kursarten
     *
     * @return eine Liste der Halbjahre in den das Fach mit einer der Kursarten belegt wurde
     */
    getHalbjahreKursart(fachbelegung, ...kursarten) {
        let halbjahre = new Vector_1.Vector();
        if (fachbelegung !== null) {
            for (let belegungHalbjahr of fachbelegung.belegungen) {
                if (belegungHalbjahr === null)
                    continue;
                let halbjahr = GostHalbjahr_1.GostHalbjahr.fromKuerzel(belegungHalbjahr.halbjahrKuerzel);
                if (halbjahr === null)
                    continue;
                if ((kursarten === null) || (kursarten.length === 0)) {
                    halbjahre.add(halbjahr);
                    continue;
                }
                for (let kursart of kursarten) {
                    if (JavaObject_1.JavaObject.equalsTranspiler(kursart, (GostKursart_1.GostKursart.fromKuerzel(belegungHalbjahr.kursartKuerzel)))) {
                        halbjahre.add(halbjahr);
                        break;
                    }
                }
            }
        }
        return halbjahre;
    }
    /**
     * Gibt die Sprache des bilingualen Bildungsgang zurück oder null, falls keiner gewählt wurde.
     *
     * @return die Sprache des bilingualen Bildungsgang oder null
     */
    getBiligualenBildungsgang() {
        return this.abidaten.bilingualeSprache;
    }
    /**
     * Prüft bei der Sprachenfolge, ob eine laut Sprachenfolge fortgeführte
     * Fremdsprache fehlerhafterweise als neu einsetzende Fremdsprache belegt wurde.
     * Übergebene Fachbelegungen, die keine Fremdsprachen sind werden ignoriert.
     *
     * @param fremdsprachen   die zu prüfenden Fachbelegungen
     *
     * @return true, falls eine fortgeführte Fremdsprache bei den übergebenen
     *         Fachbelegungen existiert, ansonsten false
     */
    hatFortgefuehrteFremdspracheInSprachendaten(fremdsprachen) {
        if (fremdsprachen === null)
            return false;
        if (this.abidaten.sprachendaten === null)
            return false;
        for (let fs of fremdsprachen) {
            let fach = this.getFach(fs);
            if ((fach === null) || (!fach.istFremdsprache))
                continue;
            if (SprachendatenManager_1.SprachendatenManager.istFortfuehrbareSpracheInGOSt(this.abidaten.sprachendaten, GostFachManager_1.GostFachManager.getFremdsprache(fach))) {
                return true;
            }
        }
        return false;
    }
    /**
     * Prüft bei der Sprachenfolge, ob für eine laut Sprachenfolge neu einsetzende
     * Fremdsprache fehlerhafterweise ein Kurs in einer fortgeführten Fremdsprache belegt wurde.
     * Übergebene Fachbelegungen, die keine Fremdsprachen sind werden ignoriert.
     *
     * @param fremdsprachen   die zu prüfenden Fachbelegungen
     *
     * @return true, falls eine neu einsetzende Fremdsprache bei den übergebenen
     *         Fachbelegungen existiert, ansonsten false
     */
    hatNeuEinsetzendeFremdspracheInSprachendaten(fremdsprachen) {
        if (fremdsprachen === null)
            return false;
        if (this.abidaten.sprachendaten === null)
            return false;
        for (let fs of fremdsprachen) {
            let fach = this.getFach(fs);
            if ((fach === null) || (!fach.istFremdsprache))
                continue;
            if (!SprachendatenManager_1.SprachendatenManager.istFortfuehrbareSpracheInGOSt(this.abidaten.sprachendaten, GostFachManager_1.GostFachManager.getFremdsprache(fach))) {
                return true;
            }
        }
        return false;
    }
    /**
     * Gibt an, ob am Ende der EF eine Muttersprachenprüfung geplant bzw. erfolgt ist.
     *
     * @return true, falls eine Muttersprachenprüfung am Ende der EF vorliegt, sonst false
     */
    hatMuttersprachenPruefungEndeEF() {
        return this.abidaten.muttersprachenpruefungEndeEF;
    }
    /**
     * Gibt an, ob die zweite Fremdsprache in der Sekundarstufe manuell erfolgreich
     * geprüft wurde und dort eine entsprechende Belegung existiert.
     *
     * @return true, falls in der Sek I eine zweite Fremdsprache belegt wurde
     */
    istSekIZweiteFremdspracheManuellGeprueft() {
        return this.abidaten.sek1Fremdsprache2ManuellGeprueft;
    }
    /**
     * Prüft, ob die Belegung seit der EF1 vorhanden ist. Hierbei werden
     * Zusatz-, Vertiefungs- und Projektkurse auch als später einsetzend akzeptiert.
     * Dies gilt auch für Literatur, instrumental- und vokalpraktische Kurse sowie
     * für Religion und Philosophie.
     *
     * @param fachbelegung   die Abiturfachbelegungen, die geprüft werden
     *
     * @return true, falls das Fach seit EF1 durchgängig belegt wurde oder eine der Ausnahmen zutrifft, sonsta false
     */
    istBelegtSeitEF(fachbelegung) {
        let fach = this.getFach(fachbelegung);
        if (fach === null)
            return false;
        if (GostFachbereich_1.GostFachbereich.LITERARISCH_KUENSTLERISCH_ERSATZ.hat(fach))
            return true;
        if (GostFachbereich_1.GostFachbereich.RELIGION.hat(fach))
            return true;
        if (JavaObject_1.JavaObject.equalsTranspiler("PL", (fach.kuerzel)))
            return true;
        for (let belegung of fachbelegung.belegungen) {
            if (belegung === null)
                continue;
            let halbjahr = GostHalbjahr_1.GostHalbjahr.fromKuerzel(belegung.halbjahrKuerzel);
            let kursart = GostKursart_1.GostKursart.fromKuerzel(belegung.kursartKuerzel);
            if ((halbjahr === null) || (kursart === null))
                continue;
            if ((kursart === GostKursart_1.GostKursart.ZK) || (kursart === GostKursart_1.GostKursart.PJK) || (kursart === GostKursart_1.GostKursart.VTF))
                continue;
            let prevHalbjahr = halbjahr.previous();
            if (prevHalbjahr === null)
                continue;
            if (fachbelegung.belegungen[prevHalbjahr.id] === null) {
                let alleBelegungen = this.getFachbelegungByFachkuerzel(fach.kuerzel);
                if ((alleBelegungen === null) || (alleBelegungen.size() <= 1))
                    return false;
                if (!this.pruefeBelegungExistiert(alleBelegungen, prevHalbjahr))
                    return false;
            }
        }
        return true;
    }
    /**
     * Gibt das Ergebnis der Belegprüfung zurück. Dieses enthält eine Liste der Fehler, die bei der Belegprüfung
     * festgestellt wurden und ob diese erfolgreich gewesen ist oder nicht.
     *
     * @return das Ergebnis der Belegprüfung
     */
    getBelegpruefungErgebnis() {
        let ergebnis = new GostBelegpruefungErgebnis_1.GostBelegpruefungErgebnis();
        ergebnis.erfolgreich = this.belegpruefungErfolgreich;
        for (let i = 0; i < this.belegpruefungsfehler.size(); i++) {
            let fehler = this.belegpruefungsfehler.get(i);
            ergebnis.fehlercodes.add(new GostBelegpruefungErgebnisFehler_1.GostBelegpruefungErgebnisFehler(fehler, this.pruefungsArt));
        }
        return ergebnis;
    }
    isTranspiledInstanceOf(name) {
        return ['de.nrw.schule.svws.core.abschluss.gost.AbiturdatenManager'].includes(name);
    }
}
exports.AbiturdatenManager = AbiturdatenManager;
function cast_de_nrw_schule_svws_core_abschluss_gost_AbiturdatenManager(obj) {
    return obj;
}
exports.cast_de_nrw_schule_svws_core_abschluss_gost_AbiturdatenManager = cast_de_nrw_schule_svws_core_abschluss_gost_AbiturdatenManager;
//# sourceMappingURL=AbiturdatenManager.js.map