> Inhalt: JavaScout Base-System (JSBS)

JSBS_Language_BOC_Set – Client-seitige Klasse für ein Set von Business-Object zur Abbildung einer Sprache

* Bitte beachten Sie die Hinweise und Bestimmungen bezüglich Urheberrecht, Haftungsausschluß und geschützte Marken oder Warenzeichen die für dieses Web-Dokument und möglicherweise auch für 'verlinkte' Dokumente gelten.

  • Der Betreiber dieser Web-Site (www.javascout.biz) ist nicht verantwortlich für den Inhalt von Web-Sites, die innerhalb dieses Web-Dokumentes oder anderer Dokumente von www.javascout.biz verlinkt sind.

  • Wenn dieses Web-Dokument oder andere Dokumente dieser Web-Site (www.javascout.biz) Rechte von Ihnen verletzen, oder sie glauben, dass Rechte Anderer (Dritter Personen) dadurch verletzt werden, informieren Sie bitte den Betreiber dieser Web-Site.
    Eine E-Mail können Sie ganz einfach durch Anklicken des Symbols oder Textes im Frame rechts oben senden.

Dieses Dokument drucken.

 Letzte Bearbeitung dieses  Dokuments:
2011-11-18

Inhaltsverzeichnis

Code 
Erklärungen und Anwendungsbeispiele 
Verwandte Dokumentation 

Code

package js_base.boc;
/*
 * de: Packages mit den Klassen für SQL-Datenbanken.
 * en: Packages with the classes for the SQL-databases. */
import java.sql.*;
/*
 * de: Packages mit der Klasse für das Bearbeiten eines 'Vector'.
 * en: Packages with the classes to manipulate a 'Vector'. */
import java.util.*;
/*
 * de:
 * Packages mit den Klassen für die Elemente der Benutzeroberfläche (GUI)
 * Diese Klassen werden benötigt weil in dieser Klasse auch die Methode für den
 * Aufbau der Tabelle (JTable) mit der Auswahl-Liste gefundener Datensätze enthalten ist.
 * en:
 * Packages with the classes for the elements of the Graphic User Interface (GUI)
 * These classes are needed because this classes contains the method to build
 * the JTable with the selection list of found datasets. */
import javax.swing.*;
/*
 * de: Packages mit der Generellen und Server-seitige Klasse für dieses BO.
 * en: Packages with the general an server-side class for this BO. */
import js_base.bo.*;
import js_base.bos.*;
/*
 * de:
 * Klasse für die effiziente Verwaltung der Verbindungen zur Datenbank.
 * Wird verwendet wenn das Anwendungsprogramm als Einzelplatz-System konfiguriert ist
 * und der Zugriff direkt auf die Datenbank erfolgt.
 * en:
 * Class for a performant administration of the connection to the database.
 * Is used in case that the application program is configured as 'stand-alone' and
 * the database is directly accessed. */
import js_base.connections.JSBS_DB_ConnectionManager;
/*
 * de:
 * Interface für die Verbindung des Clients zum EJB ('Remote interface').
 * Wird verwendet wenn das Anwendungsprogramm als Client/Server konfiguriert ist und der
 * Zugriff über den EJB-Mechanismus erfolgt.
 * en:
 * Interface handling the connection of the client with the EJB ('Remote interface').
 * Is used in case that the application program is configured as 'client/server' and
 * the database is accessed over the EJB-mechanism. */
import js_base.ejb.interfaces.remote.JSBS_StandardEJBBeanRemote;
/* de:
 * Package mit der Klasse für das StartFrame (aus dem Parameter verwendet werden) und
 * Methoden für die Bearbeitung von JFrames.
 * en:
 * Package with the class for the StartFrame (which delivers parameters needed) and
 * and methods to manipulate JFrames. */
import js_base.frame.*;
/* de:
 * Klasse mit speziellen Werten des Client-programms die auf der Server-Seite
 * des BO benötigt werden.
 * en:
 * Class with specific values of the client-program which are needed at the
 * server-side of the BO. */
import js_base.structures.JSBS_MinimalParameters; 
/**
 *
 * @author kurt(at)javascout[dot]biz
 * @date 2011-10-01
 *
 * @description
 * de:
 *  Client-seitiger Teil des Business Object für die 'Language' (Sprache).
 *  
 *  Innerhalb dieser Klasse wird die Entscheidung getroffen ob das Anwendungsprogramm
 *  als 'Stand-Alone' Version (mit der Datenbank auf dem gleichen Computer)  oder
 *  als 'Client-Server' Version (bei der die Daten auf einem Java Application Server / JAS
 *  gehalten werden und die Daten über den Mechanismus der EJB (Enterprise Java Beans)
 *  verwaltet werden.
 * -------------------
 * en:
 *  Client-Side derivation of the Business Object for the 'Language'.
 *
 *  Within this class the selection is made, if the application is running with the database
 *  on the same machine (Stand-Alone) or
 *  it is a 'client-server' application and the data is held on a Java-Application-Server (JAS)
 *  and has to be retrieved using the EJB (Enterprise Java Bean) mechanism.
 *
 * @change-log
 * when         who               why
 * --------------------------------------------------------
 *
 */
public class JSBS_Language_BOC_Set extends JSBS_Language_BO_Set {
/* ---------------------
 * de:
 * KONSTANTE für die symbolischen Namen der 'Spalten' in der Matrix der formatierten Daten.
 * Diese symbolischen Namen werden in der Methode 'buildRawDataVector' verwendet.
 * Über XML-Parameter in der Datei 'DisplayStrings.xml' wird damit die Anordnung dieser
 * Spalten für die Auswahl-Tabelle gesteuert.
 * ---------------------
 * en:
 * CONSTANTS for the symbolic names of the 'columns' within the matrix of the formatted data.
 * These symbolic names are used within the method 'buildRawDataVector'.
 * The layout of these columns at a table for selection-choices is controlled by XML-parameters
 * within the file 'DisplayStrings.xml'. */
    public static final String CONST_ColumnName_ISOLanguageCode = "ISOLanguageCode";
    public static final String CONST_ColumnName_LanguageCodeForLabelling = "LanguageCodeForLabelling";
    public static final String CONST_ColumnName_LanguageName = "LanguageName";
    public static final String CONST_ColumnName_LanguageCodeForLabellingAndLanguageName =
                                                            "LanguageCodeForLabellingAndLanguageName";
/* ---------------------
 * VARIABLE dieser Klasse / VARIABLES of this class.
 * --------------------- */
/*
 * de:
 * Referenz auf das Start-Frame (CommandCenter), das bei der 'Konstruktion' eines Objekts
 * dieser Klasse übergeben wurde.
 * Über diese Referenz werden jene Parameter abgefragt, die steuern, ob der zugehörige
 * Server-Side Teil des BO direkt 'konstruiert' werden soll (bei einer StandAlone / Einzelplatz-
 * Version) oder ein EJB (Enterprise-Java-Bean) aufgerufen werden muss (bei einer Client/Server-
 * Version).
 * en:
 * Reference to the Start-Frame (CommandCenter) that was passed during the 'construction' of
 * an object of this class.
 * This reference is used to access the parameter, which control if the associated
 * Server-Side part of the BO will be constructed directly (at a StandAlone-Version) or
 * an EJB (Enterprise-Java-Bean) has to be called (at a Client/Server-Version). */
    private JSBS_StartFrame frmCC = null;
/*
 * de:
 * Referenz auf das Task-Frame, das das Objekt dieser Klasse 'konstruiert' hat.
 * Diese Referenz wird benötigt um den genauen Namen der Klasse des Task-Frames zu ermitteln
 * wenn in der Methode 'setToGUI(...)' die Tabelle aufgebaut werden muss.
 * en:
 * Reference to the Task-Frame that 'constructed' an object of this class.
 * This reference is needed to get the exact name of the class (of the Task-Frame) when
 * a table has to be build within the method 'setToGUI(...)'. */
    private JSBS_TaskFrame frmTask = null;
/*
 * de:
 * Referenz zur bestehenden Verbindung zur Datenbank.
 * Dieser Werte muss von der aufrufenden Methode als Parameter übergeben werden
 * wenn diese Klasse 'konstruiert' wird.
 * en:
 * Referenc to the established connection to the database.
 * This value has to be passed by the calling method when this class is constructed. */
    private Connection structDBCon = null;
/*
 * de:
 * Referenz zur Datenbank-Verbindung die durch den ConnectionManager verwaltet wird.
 * Dieser Wert wird vom ConnectionManager vergeben wenn eine Verbindung zur Datenbank
 * hergestellt wurde und wird gebraucht, um die Verbindung zur Datenbank an den
 * ConnectionManager 'zurückzugeben' wenn die Verbindung in dieser Klasse nicht mehr
 * gebraucht wird.
 * en:
 * Reference to the DB-Connection administered by the ConnectionManager.
 * Provided from the ConnectionManager at the establishing of a DB-Connection and
 * needed to return the DB-Connection to the ConnectionManager when the Connection
 * is no longer needed within this class. */
    private int intDBConReference = 0;
/*
 * de:
 * Objekt für den Abgleich bei einer 'MobileClient' Version.
 * In der Klasse ist implementiert, wie die Daten eines mobilen Client mit den Daten
 * am Server abgeglichen werden nachdem der mobile Client wieder mit dem Server verbunden ist.
 * en:
 * Object for the synchronisation at a 'MobileClient' version.
 * Within that class is implemented, how the data of a mobile client is synchronised with
 * the data of the server after the mobile client is reconnected to the server.
 * within this class. */
    private JSBS_Language_BO_Synchronizer structJSBS_Language_BO_Synchronizer = null;
/*
 * CONSTRUCTOR
 * --------------------
 * de:
 * Übernehmen des jeweiligen Tasks der diese Klasse konstruiert hat (und als Parameter übergeben
 * wird) und speichern des Task in den oberhalb definierten Variablen.
 * Das Objekt des Start-Frame (parmfrmStart) könnte zwar aus dem Task-Frame ermittelt werden - aus
 * Gründen der Komptibilität zu den Design-Patterns (Muster) für die Entwicklung eines
 * Anwendungsprogramms werden aber beide Werte übergeben.
 * en:
 * Takes the task that constructed this class (which is passed as a parameter) and stores it
 * in the above defined variable.
 * The object of the Start-Frame (parmfrmStart) could be derived from the Task-Frame - for
 * the compatibility to the design-pattern (templates) for the development of an application-
 * program, both values are passed. */
    public JSBS_Language_BOC_Set(JSBS_StartFrame parmfrmStart, JSBS_TaskFrame parmfrmTask) {
      frmCC = parmfrmStart;
      frmTask = parmfrmTask;
    }
/*
 * --------------------
 * de:
 * Spezieller 'Constructor' für diese Klasse.
 * Dieser 'Constructor' wird gebraucht, weil eine Variable dieses BOC auch direkt
 * im JSBS_StartFrame definiert ist. Dort wird es von der Methode zum Füllen von
 * Comboboxen für die Auswahl einer Sprache gebraucht.
 * Die Variable für das Task-Frame wird in dieser Constructor-Methode mit gültigen Werten
 * versorgt.
 * en:
 * Particular 'Constructor' for this class.
 * This 'Constructor' is needed as a variable of this BOC is defined directly within
 * the JSBS_StartFrame. There it is used by the method to fill combo-boxes with valid
 * values for the selection of a language.
 * The variable for the Task-Frame is supplied with valid values within this constuctor-
 * method. */
    public JSBS_Language_BOC_Set(JSBS_StartFrame parmfrmStart) {
      frmCC = parmfrmStart;
      frmTask = new JSBS_TaskFrame(frmCC);
    }
/*
 * METHODEN / METHODS
 * ---------------------- */
/*
 * --------------------
 * de:
 * METHODE zum Herstellen einer Verbindung zum Datenbanksystem.
 * Der Parameter steuert ob die Verbindung mit 'autocommit' versehen wird
 * (wenn der Parameter 'parmReadOnly' 'true' ist).
 * Das Setzen von 'autocommit' verbessert die Performanz des Datenbanksystem;
 * verhindert aber eine programm-gesteuerte Ausführung der Transaktion damit die
 * Integrität von Datenänderungen erhalten bleibt.
 * Der zurück gegebenen Wert signalisiert, ob die Verbindung zur Datenbank
 * erfolgreich hergestellt wurde.
 *
 * en:
 * METHOD to establish a connection to the database-system.
 * The parameter controls if the connection is set to 'autocommit'
 * (when the parameter 'parmReadOnly' is 'true').
 * Setting 'autocommit' increases the performance of the database-system
 * but prevents a program-controlled transaction-sequence to keep the integrity of
 * data-relations.
 * The returned value signals if the connection to the database was successfully
 * established. */
    private boolean getDatabaseConnection(boolean parmReadOnly) {
/* 
 * de:
 * Eine Referenz zu einer Datenbank-Verbindung vom ConnectionManager anfordern.
 * Die Referenz-Nummer wird in der globalen Variable dieser Klasse gespeichert.
 * en:
 * Get a reference to the database-connection provided by the ConnectionManager
 * The reference-number will be stored within the global variable of this class. */
      intDBConReference =
        frmCC.structJSBS_DB_ConnectionManager.reserveConnection(this, parmReadOnly);
/* 
 * de:
 * Prüfen ob eine Verbindung zur Datenbank verfügbar ist (ConnectionReference >= 0);
 * sonst einen Fehler zurück liefern.
 * en:
 * Check if the database-connection is available (ConnectionReference >= 0);
 * otherwise return error. */
      if (intDBConReference < 0) {
        StatusCode = JSBS_Language_BO.CONST_DB_SYSTEM_ERROR;
        StatusMsg = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
        return false;
      }
/* 
 * de: Datenbank-Verbindung holen und in der Variable in dieser Klasse abspeichern.
 * en: Get the database-connection and store it in the variable within this class. */
      structDBCon =
            frmCC.structJSBS_DB_ConnectionManager.getReservedConnection(this, intDBConReference);
      return true;
    }
/*
 * --------------------
 * de:
 * METHODE zum Aufbau der Matrix mit den formatierten Daten.
 * In dieser Matrix sind in der ersten 'Zeile' die symbolischen Spalten-Namen enthalten.
 * Über XML-Parameter in der Datei 'DisplayStrings.xml' wird damit die Anordnung der
 * Spalten für die Auswahl-Tabelle gesteuert.
 * Die 'Matrix' besteht aus einem 'Vector' der für jede Zeile wieder einen 'Vector'
 * mit den Daten für die Spalten enthält.
 * In der ersten 'Zeile' der Matrix sind die symbolischen Spaltennamen enthalten.
 * --------------------
 * en:
 * METHOD to build the matrix with the formatted data.
 * This matrix contains the symbolic column-names within the first 'row'.
 * The order of the columns in the table for selection-choices can be controlled by
 * XML-parameters within the file 'DisplayStrings.xml'.
 * The 'matrix' consists of a 'vector' which contains further 'vectors' for each 'line'
 * which contains the data for the 'columns' of this 'line'.
 * The first 'line' of the 'matrix' contains the symbolic column-names. */
    public void buildRawDataVector() {
/*
 * de:
 * Vector für die Zeilen leeren; dieser Vector ist in der geerbten Basisklasse definiert.
 * en:
 * Empty the vector for the lines; this vector is defined in the inherited base-class */
      vecRawDisplayData.removeAllElements();
/*
 * de:
 * Neuen 'Vector' für die erste Zeile 'konstruieren'; diese Zeile enthält die
 * symbolischen Namen für die Spalten.
 * en:
 * Construct a new 'vector' for the first line; this vector contains the symbolic
 * names for the columns. */
      Vector vecHeader = new Vector();
/* de: Die Konstante für die Zeilen-Nummer ist in der geerbten Basisklasse definiert.
 * en: The constant for the line-number is defined within the inherited base-class. */
      vecHeader.addElement(CONST_ColumnName_RowNr);
      vecHeader.addElement(CONST_ColumnName_ISOLanguageCode);
      vecHeader.addElement(CONST_ColumnName_LanguageCodeForLabelling);
      vecHeader.addElement(CONST_ColumnName_LanguageName);
      vecHeader.addElement(CONST_ColumnName_LanguageCodeForLabellingAndLanguageName);
/* de: Die gerade erstellte 'Zeile' einfügen.
 * en: Insert the just created 'line'. */
      vecRawDisplayData.addElement(vecHeader);
/*
 * de: In einer for-Schleife die Daten dieses BO-Set in die Matrix einfügen.
 * en: Use a for-loop to insert the data of this BO-Set into the matrix. */
      int locintVectorIndex;
      int locintVectorSize = vecRecordSet.size();
      for (locintVectorIndex = 0; locintVectorIndex < locintVectorSize; locintVectorIndex++) {
/*
 * de: Neuen 'Vector' für die Zeile 'konstruieren'.
 * en: Construct a new 'vector' for the line. */
        Vector vecData = new Vector();
/* 
 * de:
 * Die Zeilennummer als Spalte einfügen;
 * das Formatieren erfolgt in der Methode für die Anzeige. */
        vecData.addElement(locintVectorIndex + 1);
/*
 * de:
 * Das indizierte BO aus der Liste mit den (von der Datenbank gelesenen) BO 'herauslösen'.
 * Die Werte werden auf ein neu 'konstruiertes' BO kopiert weil innerhalb des Vector
 * nur mit Referenzen gearbeitet wird und deswegen ein Objekt, auf das der Vector 'zeigen'
 * kann, notwendig ist.
 * en:
 * Get the indicated BO from the list with the BO (read from the database).
 * The values are transferred to a new 'constructed' BO. The reason for that algorithm is, that
 * within a vector only references can be used, therefore a new object the vector can point to
 * is needed. */
        JSBS_Language_BO tmpJSBS_Language_BO =
            new JSBS_Language_BO();
        tmpJSBS_Language_BO.copyFromJSBS_Language_BO (
            (JSBS_Language_BO) vecRecordSet.elementAt(locintVectorIndex));
/*
 * de:
 * Werte der Variablen aus dem 'herausgelösten' BO in den 'Matrix'-Vector einfügen.
 * Das Formatieren numerischer Werte erfolgt in der Methode für die Anzeige.
 * en:
 * Insert the values of the BO derived from the list-vector into the 'matrix'-vector.
 * Formatting of numeric values is done within the method for display. */
        vecData.addElement(tmpJSBS_Language_BO.ISOLanguageCode);
        vecData.addElement(tmpJSBS_Language_BO.LanguageCodeForLabelling);
        vecData.addElement(tmpJSBS_Language_BO.LanguageName);
/*
 * de:
 * Aufbauen eines kombinierten Textes mit dem Sprach-Code in der die Bezeichnung der
 * Sprache ist und die Bezeichnung der Sprache.
 * Weil für die Standard-Sprach-Bezeichnunge kein Sprach-Code für die Bezeichnung
 * verfügbar ist, wird in diesem Fall nur die Standard-Bezeichnung der Sprache angezeigt.
 * en:
 * Build a combined text with the language-code defining the language for the
 * language-name and the language-name.
 * As there is no language-code for the default-language-name, only the default-language-name
 * is displayed in that case. */
        String strLanguageCodeForLabellingAndLanguageName = "";
/*
 * de:
 * Prüfen ob der Datensatz eine zusätzliche Bezeichnung der Sprache abbildet und in
 * diesem Fall den Sprach-Code für die Bezeichnung der Sprache in die gerade definierte
 * Zeichenkette einfügen.
 * en:
 * Verify, if the dataset represents an additional language-name. In that case add the 
 * language-code for this additional language into the just defined string. */
        if (tmpJSBS_Language_BO.LanguageCodeForLabelling.trim().length() > 0)
                strLanguageCodeForLabellingAndLanguageName +=
                tmpJSBS_Language_BO.LanguageCodeForLabelling + ": ";
/*
 * de:
 * Bezeichnung für die Sprache auf jeden Fall zur Zeichenkette hinzufügen und die
 * gesamte Zeichenkette in den Vector mit den Roh-Daten einfügen.
 * en:
 * Unconditionally add the language-name to the string and insert the string into 
 * the vector with the raw-data. */
        strLanguageCodeForLabellingAndLanguageName += tmpJSBS_Language_BO.LanguageName;
        vecData.addElement(strLanguageCodeForLabellingAndLanguageName);
/* 
 * de: Die gerade erstellte 'Zeile' einfügen.
 * en: Insert the just created 'line'. */
        vecRawDisplayData.addElement(vecData);
      }
    }
/*
 * --------------------
 * de:
 * METHODE zum Anzeigen der Werte aus diesem BO-Set in einem GUI-Element der Klasse JTable.
 * Diese Methode verwendet eine Methode aus der Basisklasse 'JSBS_XML_DisplayStrings'
 * um ein GUI-Element der Klasse 'JTable' mit den Daten zu füllen.
 * Im Parameter 'parmArrayColumnWidth' wird eine Information über die Breite der Spalten
 * in der Tabelle übergeben.
 *
 * en:
 * METHOD to dispay the values of this BO-Set within a GUI-Element of class JTable.
 * This method uses a method from the base-class 'JSBS_XML_DisplayStrings' to fill
 * a GUI-element of class 'JTable' with data.
 * Within the parameter 'parmArrayColumnWidth', an information about the width of the
 * columns of the table is passed. */
    public void setToGUI(JTable parmJTable, String [] parmArrayColumnWidth) {
/*
 * de:
 * Namen der Klasse des Task-Frames ermitteln.
 * Dieser Wert wird gebraucht um die Anordnung und Breite der Spalten in der Tabelle (JTable)
 * aus der XML-Struktur auslesen zu können.
 * en:
 * Get the name of the class of the task-frame.
 * This value is needed to read the order and the width of the column for the JTable
 * out of the XML-structure. */
        String strFrameClassName = frmTask.getClass().getName();
/*
 * de:
 * Methode zum Füllen der Tabelle aufrufen.
 * en:
 * Call the method to fill the JTable. */
        frmTask.frmCC.structJSBS_XML_DisplayStrings.processJTable(
                parmJTable,
                strFrameClassName,
                vecRawDisplayData,
                parmArrayColumnWidth);
    }
/*
 * --------------------
 * de:
 * METHODE zum Aufrufen des nebenläufigen Prozess (Thread) zum Abgleichen von BO wenn das
 * Anwendungsprogramm in der Version 'MobileClient' läuft.
 *
 * en:
 * METHOD to call the thread to synchronize BO if the application-programm runs with the
 * version 'MobileClient'. */
    private void synchronizeBO() {
/*
 * de:
 * Zuerst prüfen ob schon ein Objekt für den nebenläufigen Prozess (Thread) existiert
 * und bei Bedarf ein Thread-Objekt konstruieren.
 * en:
 * First check if an object for the thread already exist and construct one if needed. */
        if (structJSBS_Language_BO_Synchronizer == null)
                structJSBS_Language_BO_Synchronizer = new JSBS_Language_BO_Synchronizer(frmCC, frmTask);
/*
 * de:
 * Dieses BO-Set (gesamtes Objekt) an den Synchronizer übergeben.
 * Der nebenläufige, asynchrone Prozess wird in der aufgerufenen Methode gestartet.
 * en:
 * Pass this BO-set (complete object) to the Synchronizer.
 * The asynchronous thread will be started within the called method. */
        structJSBS_Language_BO_Synchronizer.passBOList(this);
    }
/*
 * --------------------
 * de:
 * METHODE zum Vergleichen von zwei BO-Sets und Übernehmen der jeweils neuesten Version
 * eines BO in das 'vecRecordSet' dieses Objekts.
 * --------------------
 * en:
 * METHOD to compare two BO-sets and transfer of the newest version of a BO into the
 * 'vecRecordSet' of this object. */
    private void mergeList(JSBS_Language_BO_Set parmJSBS_Language_BO_Set_1,
                           JSBS_Language_BO_Set parmJSBS_Language_BO_Set_2) {
/*
 * de: Zuerst Prüfen ob gültige Werte in den Parametern vorhanden sind.
 * en: First verify if valid values are passed in the parameters. */
        if (parmJSBS_Language_BO_Set_1 == null) {
          this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
          this.StatusMsg = "mergeList: parmJSBS_Language_BO_Set_1 is 'null'";
        }
        if (parmJSBS_Language_BO_Set_1.vecRecordSet == null) {
          this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
          this.StatusMsg = "mergeList: parmJSBS_Language_BO_Set_1.vecRecordSet is 'null'";
        }
        if (parmJSBS_Language_BO_Set_2 == null) {
          this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
          this.StatusMsg = "mergeList: parmJSBS_Language_BO_Set_2 is 'null'";
        }
        if (parmJSBS_Language_BO_Set_2.vecRecordSet == null) {
          this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
          this.StatusMsg = "mergeList: parmJSBS_Language_BO_Set_2.vecRecordSet is 'null'";
        }
/*
 * de: Variable die für den Abgleich gebraucht werden definieren.
 * en: Define the variables that are needed for the merge. */
        int intVectorSizeThis;
        int intVectorIndexThis;
        int intVectorSizeParm;
        int intVectorIndexParm;
        JSBS_Language_BO locJSBS_Language_BO_This;
        JSBS_Language_BO locJSBS_Language_BO_Parm;
        JSBS_Language_BO locJSBS_Language_BO_ToInsert;
/*
 * de:
 * Vector mit den BO dieses Objekts leeren und BO aus dem Vector des Parameter 1 übertragen.
 * en:
 * Empty the vector with the BO of this object and transfer the BO from the vector of Parameter 1. */
        vecRecordSet = new Vector();
        intVectorSizeParm = parmJSBS_Language_BO_Set_1.vecRecordSet.size();
        for (intVectorIndexParm = 0; intVectorIndexParm < intVectorSizeParm; intVectorIndexParm++) {
          locJSBS_Language_BO_Parm = (JSBS_Language_BO)
                  parmJSBS_Language_BO_Set_1.vecRecordSet.elementAt(intVectorIndexParm);
          locJSBS_Language_BO_ToInsert = new JSBS_Language_BO();
          locJSBS_Language_BO_ToInsert.copyFromJSBS_Language_BO(locJSBS_Language_BO_Parm);
          vecRecordSet.addElement(locJSBS_Language_BO_ToInsert);
        }
/*
 * de:
 * In einem zweiten Durchgang alle BO des Parameter 2 mit den bereits im vecRecordSet dieses
 * Objektes enthaltenen vergleichen.
 * Sind im Parameter 2 neue oder 'jüngere' BO enthalten, dann diese in das vecRecordSet dieses
 * Objektes einfügen bzw. 'ältere' ersetzen.
 * en:
 * In a second pass, compare all BO from the Parameter 2 with the ones already contained in
 * vecRecordSet of this object.
 * If Parameter 2 contains new or 'younger' BO, then insert them into the vecRecordSet of this
 * object or replace 'older' ones. */
        intVectorSizeParm = parmJSBS_Language_BO_Set_2.vecRecordSet.size();
        for (intVectorIndexParm = 0; intVectorIndexParm < intVectorSizeParm; intVectorIndexParm++) {
          locJSBS_Language_BO_Parm = (JSBS_Language_BO)
                  parmJSBS_Language_BO_Set_2.vecRecordSet.elementAt(intVectorIndexParm);
/*
 * de:
 * BO für das eventuelle Einfügen mit dem BO aus dem Parameter 2 versorgen. Das wird später zum
 * Signalisieren benutzt, ob das BO aus dem Parameter 2 eingefügt werden soll.
 * en:
 * Set the BO used for inserting to the BO of parameter 2. This is used later to signal, if the BO
 * from Parameter 2 has to be inserted. */
          locJSBS_Language_BO_ToInsert = new JSBS_Language_BO();
          locJSBS_Language_BO_ToInsert.copyFromJSBS_Language_BO(locJSBS_Language_BO_Parm);
/*
 * de:
 * In einer inneren for-Schleife das BO-Set dieses Objektes durchsuchen und die BO vergleichen. 
 * en:
 * Use an inner for-loop to inspect the BO-Set of this object and compare the BO. */
          intVectorSizeThis = this.vecRecordSet.size();
          for (intVectorIndexThis = 0; intVectorIndexThis < intVectorSizeThis; intVectorIndexThis++) {
            locJSBS_Language_BO_This = (JSBS_Language_BO) 
                  this.vecRecordSet.elementAt(intVectorIndexThis);
/*
 * de:
 * Vergleichen ob die beiden BO den gleichen ObjectID haben - also das gleiche BO sind.
 * en:
 * Compare if both BO have the same ObjectID - i.e. they are the same BO. */
            if (locJSBS_Language_BO_This.ObjectID == locJSBS_Language_BO_Parm.ObjectID) {
/* de:
 * Markieren, dass dieses BO nicht mehr in das vecRecordSet dieses Objekts eingefügt werden muss.
 * en:
 * Mark that this BO does not have to be inserted into the vecRecordSet of this object. */
              locJSBS_Language_BO_ToInsert = null;
/* de: Prüfen, ob das BO aus dem Parameter 2 'jünger' ist.
 * en: Check, if the BO in parameter 2 is 'younger'. */
              if (locJSBS_Language_BO_This.ChangedAt.before(locJSBS_Language_BO_Parm.ChangedAt)) {
/* de:
 * BO aus dem Parameter 2 ist 'jünger'; dessen Werte in das BO im vecRecordSet dieses Objekts übertragen.
 * en:
 * BO from parameter 2 is 'younger'; transfer its values into the BO in vecRecordSet of this object. */
                ((JSBS_Language_BO) this.vecRecordSet.elementAt(intVectorIndexThis)).
                    copyFromJSBS_Language_BO(locJSBS_Language_BO_Parm);
              }
            }
          }
/*
 * de:
 * Prüfen ob das bearbeitete BO aus dem Parameter 2 in das 'vecRecordSet' dieses Objekts eingefügt werden muss. 
 * en:
 * Verify, if the BO from the parameter 2 has to be inserted into the vecRecordSet of this object. */
          if (locJSBS_Language_BO_ToInsert != null)
              vecRecordSet.addElement(locJSBS_Language_BO_ToInsert);
        }
    }
/*
 * --------------------
 * de:
 * METHODEN zum Lesen aller Datensätze (nicht mehr gültig, aktuell gültig, erst in Zukunft gültig)
 * für den gegeben ObjectID von der Datenbank.
 * en:
 * METHODS to read all datasets (no longer valid, actually valid, valid in the future) for the
 * given ObjectID from the database. */
/*
 * de: METHODE zum Lesen der Daten von der lokalen Datenbank.
 * en: METHOD to read the data from the local database. */
    protected void selectAllByObjectID_DB(double parmObjectID) {
/* de:
 * Datenbank läuft auf der lokalen Maschine; Verbindung zur Datenbank herstellen.
 * en:
 * Database is running on the local machine; establish the connection to the database. */
        getDatabaseConnection(true);
/* de:
 * Prüfen ob eine Verbindung zur Datenbank hergestellt werden konnte.
 * Eine Referenznummer gleich oder größer 0 bedeutet eine ordnungsgemäße Verbindung zur DB.
 * en:
 * Verify if a connection to the database could have been established.
 * A reference-number of 0 or greater signals a proper connection to the database. */
        if (intDBConReference < 0) {
/* de:
 * Fehler beim Verbinden zur Datenbank; über Status-Variable an die aufrufende Methode
 * signalisieren. Diese Methode beenden.
 * en:
 * Error when connecting to the database; signal this to the calling method using
 * the status-variables. End this Method. */
          StatusCode = JSBS_Language_BO.CONST_DB_SYSTEM_ERROR;
          StatusMsg = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
          return;
        }
/* de:
 * Datenbank läuft auf der lokalen Maschine; 'Server-Seitige' Klasse des BO direkt
 * 'konstruieren'.
 * Verbindung zur Datenbank und die Werte dieser 'Client-seitigen' BO-Klasse
 * als Parameter übertragen.
 * en:
 * Database is running on the local machine; construct the 'Server-Side' BO directly.
 * Pass the database-connection and the values of this 'Client-Side' BO as parameters. */
        JSBS_Language_BOS_Set bosJSBS_Language_BOS_Set =
          new JSBS_Language_BOS_Set(frmTask.structMinParm, structDBCon, true); 
/* de: Aufrufen der Methode, die die Operation auf der Datenbank ausführt.
 * en: Call the method to perform the database-operation(s). */
        bosJSBS_Language_BOS_Set.selectAllByObjectID(parmObjectID);
/* de:
 * Übertragen der zurückgelieferten Werte der Variablen und des Status.
 * Ausserdem kann auf das BOS nicht mehr zugegriffen werden sobald diese Methode beendet ist.
 * en:
 * Transfer the returned values of the variables and the Status.
 * Additionally the values of the BOS can no longer be accesses as soon as this method has ended. */
        copyFromJSBS_Language_BO_Set(bosJSBS_Language_BOS_Set);
/* de:
 * Verbindung zur Datenbank an den Connection-Manager zurück geben.
 * Der Connection Manager verwaltet die offenen Verbindungen zur Datenbank und verwendet
 * sie wieder bei der nächsten Anforderung.
 * en:
 * Return the connection to the database to the Connection-Manager.
 * The Connection-Manager administers open connections to the database and reuses it
 * at the next request. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
    }
/*
 * de: METHODE zum Lesen der Daten über den JAS (Java Application Server).
 * en: METHOD to read the data via the JAS (Java Application Server). */
    protected void selectAllByObjectID_JAS(double parmObjectID) {
/* de: Der Zugriff auf die Datenbank läuft über den EJB-Mechanismus.
 * en: Access to the database is by using the EJB-mechanism. */
        try {
/* de:
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB.
 * Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * en:
 * Instantiate (construct) the client-side object ('Remote interface') for calling
 * methods of the EJB.
 * The method to instantiate is implemented in the Start-Frame. */
          JSBS_StandardEJBBeanRemote remoteJSBS_StandardEJBBean =
            frmCC.get_JSBS_StandardEJBBeanRemote();
/*
 * de: Prüfen, ob überhaupt eine Verbindung zum JAS hergestellt werden konnte.
 * en: Verify if a connection to the JAS has been established. */
          if (remoteJSBS_StandardEJBBean == null) {
/*
 * de: Keine Verbindung zum JAS; Fehler zurückmelden.
 * en: No connection to the JAS; report error. */
            this.StatusCode = JSBS_Language_BO.CONST_DB_UNKNOWN_ERROR;
            this.StatusMsg = "No connection to JAS; method: JSBS_Language_BOC.selectAllByObjectID()";
            return;
          }
/* de:
 * Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu diesem
 * Client-seitigen Teil des BO - passende Server-seitige Methode aufgerufen.
 * Neue Werte für die Variablen des BO und eventuelle Fehlermeldungen sind im zurückgelieferten
 * BO enthalten.
 * en:
 * Call the 'wrapper'-method of the EJB. Within this 'wrapper'-method the server-side method 
 * - which fits this method of the client-side derivation of the BO - is called.
 * New values for variables of the BO and probably occured error-messages are contained in the
 * returned BO. */
          JSBS_Language_BO_Set boJSBS_Language_BO_Set =
            remoteJSBS_StandardEJBBean.
              JSBS_Language_BO_Set__selectAllByObjectID(frmTask.structMinParm, parmObjectID);
/* de:
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) kopieren.
 * en:
 * Copy the values of the returned BO to this BOC (client-side derivation of the BO). */
          this.copyFromJSBS_Language_BO_Set(boJSBS_Language_BO_Set);
        }
        catch (Exception e) {
/* de:
 * Fehler beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen.
 * en:
 * Error when executing the method of the EJB.
 * Transfer the error-message from the Exception and set status. */
          this.StatusCode = JSBS_Language_BO.CONST_DB_UNKNOWN_ERROR;
          this.StatusMsg = e.getMessage();
        }
    }
/*
 * --------------------
 * de:
 * METHODE zum Lesen aller aktuell gültigen Sprachen von der Datenbank.
 * en:
 * METHOD to read all languages valid at the actual data from the database. */
    public void selectAllByObjectID(double parmObjectID) {
/*
 * de: Entscheiden mit welcher Version das Anwendungsprogramm läuft.
 * en: Decide what version the application runs. */
        switch (frmCC.RunVersion) {
        case JSBS_StartFrame.CONST_StandAlone:
/* de:
 * Einzelplatzversion. Datenbank läuft auf der lokalen Maschine; Spezielle Methode aufrufen.
 * en:
 * Stand-alone version. Database is running on the local machine; call the specialized method. */
            selectAllByObjectID_DB(parmObjectID);
            break;
        case JSBS_StartFrame.CONST_FatClient:
/* de:
 * Client-Server-Version.
 * Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java Application Server); spezielle Methode aufrufen.
 * en:
 * Client-Server-version.
 * Data is accessed via the EJB-mechanism and the JAS (Java Application Server); call the specialized method. */
            selectAllByObjectID_JAS(parmObjectID);
            break;
        case JSBS_StartFrame.CONST_MobileClient:
/* de:
 * Zuerst die Daten von der lokalen Datenbank abfragen. Per Definition muss das immer möglich sein.
 * en:
 * Read the data from the local database. As per definition this must always be possible. */
            selectAllByObjectID_DB(parmObjectID);
/* de:
 * Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar.
 * en:
 * Verify, if an error occured when reading the local database. In that case end this method - that makes
 * the status available for the calling method. */
            if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* de: 'Erlaubte' Status-Codes für die Abfrage von der lokalen Datenbank.
 * en: 'Permitted' status-codes for the read from the local database. */
            }
            else return;
/* de:
 * Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt die weitere Verarbeitung.
 * en:
 * Verify, if the connection to the JAS exists. The further processing depends on the result. */
            if (frmCC.testJASConnection()) {
/* de:
 * BO-Sets für die Daten der lokalen Datenbank und den Daten vom JAS konstruieren.
 * Damit können später die jeweiligen Daten verglichen und Unterschiede behandelt werden.
 * en:
 * Construct BO-Sets for the data from the local database and the data from the JAS.
 * This allows to compare the data later and process differences. */
              JSBS_Language_BO_Set structJSBS_Language_BO_Set_Local = new JSBS_Language_BO_Set();
              JSBS_Language_BO_Set structJSBS_Language_BO_Set_JAS = new JSBS_Language_BO_Set();
/* de:
 * Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene Variable übertragen und den
 * Vector mit den BO in diesem Objekt leeren.
 * en:
 * Transfer the result of the read from the local database to the variable designated for that.
 * Empty the vector with the BO within this object thereafter. */
              structJSBS_Language_BO_Set_Local.copyFromJSBS_Language_BO_Set(this);
              vecRecordSet.removeAllElements();
/* de: Daten vom JAS abfragen.
 * en: Read the data from the JAS. */
              selectAllByObjectID_JAS(parmObjectID);
/* de:
 * Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar.
 * en:
 * Verify, if an error occured when reading from the JAS. In that case end this method - that makes
 * the status available for the calling method. */
              if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* de: 'Erlaubte' Status-Codes für die Abfrage über den JAS.
 * en: 'Permitted' status-codes for the read via the JAS. */
              }
              else return;
/* de:
 * Ergebnis der Abfrage über den JAS auf die dafür vorgesehene Variable übertragen und den
 * Vector mit den BO in diesem Objekt leeren.
 * en:
 * Transfer the result of the read via the JAS to the variable designated for that.
 * Empty the vector with the BO within this object thereafter. */
              structJSBS_Language_BO_Set_JAS.copyFromJSBS_Language_BO_Set(this);
              vecRecordSet.removeAllElements();
/* de: Methode zum Abgleich der Daten von beiden Quellen aufrufen.
 * en: Call the method that merges the data from both sources. */
              mergeList(structJSBS_Language_BO_Set_Local, structJSBS_Language_BO_Set_JAS);
/* de:
 * Methode zum Sortieren nach dem Sprach-Code aufrufen weil die BO nach dem Abgleich nach
 * ihrer Herkunft sortiert sind.
 * en:
 * Call the method to sort by language-code as the BO are sorted by their source after the merge. */
              sortByISOLanguageCode_LanguageCodeForLabelling();
            }
            break;
        }
/*
 * de: Methode aufrufen, die die Matrix für die Anzeige der Daten erstellt.
 * en: Call the method that builds the matrix for the display of the data. */
      buildRawDataVector();
    }
/*
 * --------------------
 * de:
 * METHODEN zum Lesen aller aktuell gültigen Datensätze von der Datenbank.
 * en:
 * METHODS to read all datasets valid at the actual data from the database. */
/*
 * de: METHODE zum Lesen der Daten von der lokalen Datenbank.
 * en: METHOD to read the data from the local database. */
    private void selectAllValid_DB() {
/* de:
 * Datenbank läuft auf der lokalen Maschine; Verbindung zur Datenbank herstellen.
 * en:
 * Database is running on the local machine; establish the connection to the database. */
        getDatabaseConnection(true);
/* de:
 * Prüfen ob eine Verbindung zur Datenbank hergestellt werden konnte.
 * Eine Referenznummer gleich oder größer 0 bedeutet eine ordnungsgemäße Verbindung zur DB.
 * en:
 * Verify if a connection to the database could have been established.
 * A reference-number of 0 or greater signals a proper connection to the database. */
        if (intDBConReference < 0) {
/* de:
 * Fehler beim Verbinden zur Datenbank; über Status-Variable an die aufrufende Methode
 * signalisieren. Diese Methode beenden.
 * en:
 * Error when connecting to the database; signal this to the calling method using
 * the status-variables. End this Method. */
          StatusCode = JSBS_Language_BO.CONST_DB_SYSTEM_ERROR;
          StatusMsg = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
          return;
        }
/* de:
 * Datenbank läuft auf der lokalen Maschine; 'Server-Seitige' Klasse des BO direkt
 * 'konstruieren'.
 * Verbindung zur Datenbank und die Werte dieser 'Client-seitigen' BO-Klasse
 * als Parameter übertragen.
 * en:
 * Database is running on the local machine; construct the 'Server-Side' BO directly.
 * Pass the database-connection and the values of this 'Client-Side' BO as parameters. */
        JSBS_Language_BOS_Set bosJSBS_Language_BOS_Set =
          new JSBS_Language_BOS_Set(frmTask.structMinParm, structDBCon, true); 
/* de: Aufrufen der Methode, die die Operation auf der Datenbank ausführt.
 * en: Call the method to perform the database-operation(s). */
        bosJSBS_Language_BOS_Set.selectAllValid();
/* de:
 * Übertragen der zurückgelieferten Werte der Variablen und des Status.
 * Ausserdem kann auf das BOS nicht mehr zugegriffen werden sobald diese Methode beendet ist.
 * en:
 * Transfer the returned values of the variables and the Status.
 * Additionally the values of the BOS can no longer be accesses as soon as this method has ended. */
        copyFromJSBS_Language_BO_Set(bosJSBS_Language_BOS_Set);
/* de:
 * Verbindung zur Datenbank an den Connection-Manager zurück geben.
 * Der Connection Manager verwaltet die offenen Verbindungen zur Datenbank und verwendet
 * sie wieder bei der nächsten Anforderung.
 * en:
 * Return the connection to the database to the Connection-Manager.
 * The Connection-Manager administers open connections to the database and reuses it
 * at the next request. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
    }
/*
 * de: METHODE zum Lesen der Daten über den JAS (Java Application Server).
 * en: METHOD to read the data via the JAS (Java Application Server). */
    private void selectAllValid_JAS() {
/* de: Der Zugriff auf die Datenbank läuft über den EJB-Mechanismus.
 * en: Access to the database is by using the EJB-mechanism. */
        try {
/* de:
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB.
 * Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * en:
 * Instantiate (construct) the client-side object ('Remote interface') for calling
 * methods of the EJB.
 * The method to instantiate is implemented in the Start-Frame. */
          JSBS_StandardEJBBeanRemote remoteJSBS_StandardEJBBean =
            frmCC.get_JSBS_StandardEJBBeanRemote();
/*
 * de: Prüfen, ob überhaupt eine Verbindung zum JAS hergestellt werden konnte.
 * en: Verify if a connection to the JAS has been established. */
          if (remoteJSBS_StandardEJBBean == null) {
/*
 * de: Keine Verbindung zum JAS; Fehler zurückmelden.
 * en: No connection to the JAS; report error. */
            this.StatusCode = JSBS_Language_BO.CONST_DB_UNKNOWN_ERROR;
            this.StatusMsg = "No connection to JAS; method: JSBS_Language_BOC.selectAllValid()";
            return;
          }
/* de:
 * Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu diesem
 * Client-seitigen Teil des BO - passende Server-seitige Methode aufgerufen.
 * Neue Werte für die Variablen des BO und eventuelle Fehlermeldungen sind im zurückgelieferten
 * BO enthalten.
 * en:
 * Call the 'wrapper'-method of the EJB. Within this 'wrapper'-method the server-side method 
 * - which fits this method of the client-side derivation of the BO - is called.
 * New values for variables of the BO and probably occured error-messages are contained in the
 * returned BO. */
          JSBS_Language_BO_Set boJSBS_Language_BO_Set =
            remoteJSBS_StandardEJBBean.
              JSBS_Language_BO_Set__selectAllValid(frmTask.structMinParm);
/* de:
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) kopieren.
 * en:
 * Copy the values of the returned BO to this BOC (client-side derivation of the BO). */
          this.copyFromJSBS_Language_BO_Set(boJSBS_Language_BO_Set);
        }
        catch (Exception e) {
/* de:
 * Fehler beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen.
 * en:
 * Error when executing the method of the EJB.
 * Transfer the error-message from the Exception and set status. */
          this.StatusCode = JSBS_Language_BO.CONST_DB_UNKNOWN_ERROR;
          this.StatusMsg = e.getMessage();
        }
    }
/*
 * --------------------
 * de:
 * METHODE zum Lesen aller aktuell gültigen Sprachen von der Datenbank.
 * en:
 * METHOD to read all languages valid at the actual data from the database. */
    public void selectAllValid() {
/*
 * de: Entscheiden mit welcher Version das Anwendungsprogramm läuft.
 * en: Decide what version the application runs. */
        switch (frmCC.RunVersion) {
        case JSBS_StartFrame.CONST_StandAlone:
/* de:
 * Einzelplatzversion. Datenbank läuft auf der lokalen Maschine; Spezielle Methode aufrufen.
 * en:
 * Stand-alone version. Database is running on the local machine; call the specialized method. */
            selectAllValid_DB();
            break;
        case JSBS_StartFrame.CONST_FatClient:
/* de:
 * Client-Server-Version.
 * Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java Application Server); spezielle Methode aufrufen.
 * en:
 * Client-Server-version.
 * Data is accessed via the EJB-mechanism and the JAS (Java Application Server); call the specialized method. */
            selectAllValid_JAS();
            break;
        case JSBS_StartFrame.CONST_MobileClient:
/* de:
 * Zuerst die Daten von der lokalen Datenbank abfragen. Per Definition muss das immer möglich sein.
 * en:
 * Read the data from the local database. As per definition this must always be possible. */
            selectAllValid_DB();
/* de:
 * Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar.
 * en:
 * Verify, if an error occured when reading the local database. In that case end this method - that makes
 * the status available for the calling method. */
            if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* de: 'Erlaubte' Status-Codes für die Abfrage von der lokalen Datenbank.
 * en: 'Permitted' status-codes for the read from the local database. */
            }
            else return;
/* de:
 * Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt die weitere Verarbeitung.
 * en:
 * Verify, if the connection to the JAS exists. The further processing depends on the result. */
            if (frmCC.testJASConnection()) {
/* de:
 * BO-Sets für die Daten der lokalen Datenbank und den Daten vom JAS konstruieren.
 * Damit können später die jeweiligen Daten verglichen und Unterschiede behandelt werden.
 * en:
 * Construct BO-Sets for the data from the local database and the data from the JAS.
 * This allows to compare the data later and process differences. */
              JSBS_Language_BO_Set structJSBS_Language_BO_Set_Local = new JSBS_Language_BO_Set();
              JSBS_Language_BO_Set structJSBS_Language_BO_Set_JAS = new JSBS_Language_BO_Set();
/* de:
 * Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene Variable übertragen und den
 * Vector mit den BO in diesem Objekt leeren.
 * en:
 * Transfer the result of the read from the local database to the variable designated for that.
 * Empty the vector with the BO within this object thereafter. */
              structJSBS_Language_BO_Set_Local.copyFromJSBS_Language_BO_Set(this);
              vecRecordSet.removeAllElements();
/* de: Daten vom JAS abfragen.
 * en: Read the data from the JAS. */
              selectAllValid_JAS();
/* de:
 * Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar.
 * en:
 * Verify, if an error occured when reading from the JAS. In that case end this method - that makes
 * the status available for the calling method. */
              if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* de: 'Erlaubte' Status-Codes für die Abfrage über den JAS.
 * en: 'Permitted' status-codes for the read via the JAS. */
              }
              else return;
/* de:
 * Ergebnis der Abfrage über den JAS auf die dafür vorgesehene Variable übertragen und den
 * Vector mit den BO in diesem Objekt leeren.
 * en:
 * Transfer the result of the read via the JAS to the variable designated for that.
 * Empty the vector with the BO within this object thereafter. */
              structJSBS_Language_BO_Set_JAS.copyFromJSBS_Language_BO_Set(this);
              vecRecordSet.removeAllElements();
/* de: Methode zum Abgleich der Daten von beiden Quellen aufrufen.
 * en: Call the method that merges the data from both sources. */
              mergeList(structJSBS_Language_BO_Set_Local, structJSBS_Language_BO_Set_JAS);
/* de:
 * Methode zum Sortieren nach dem Sprach-Code aufrufen weil die BO nach dem Abgleich nach
 * ihrer Herkunft sortiert sind.
 * en:
 * Call the method to sort by language-code as the BO are sorted by their source after the merge. */
              sortByISOLanguageCode_LanguageCodeForLabelling();
            }
            break;
        }
/*
 * de: Methode aufrufen, die die Matrix für die Anzeige der Daten erstellt.
 * en: Call the method that builds the matrix for the display of the data. */
      buildRawDataVector();
    }
/*
 * --------------------
 * de:
 * METHODEN zum Lesen aller aktuell gültigen Datensätze für den gegebenen Sprach-Code
 * von der Datenbank.
 * en:
 * METHODS to read all dataset valid at the actual data for the given language-code
 * from the database. */
/*
 * de: METHODE zum Lesen der Daten von der lokalen Datenbank.
 * en: METHOD to read the data from the local database. */
    private void selectByISOLanguageCode_DB(String parmISOLanguageCode) {
/* de:
 * Datenbank läuft auf der lokalen Maschine; Verbindung zur Datenbank herstellen.
 * en:
 * Database is running on the local machine; establish the connection to the database. */
        getDatabaseConnection(true);
/* de:
 * Prüfen ob eine Verbindung zur Datenbank hergestellt werden konnte.
 * Eine Referenznummer gleich oder größer 0 bedeutet eine ordnungsgemäße Verbindung zur DB.
 * en:
 * Verify if a connection to the database could have been established.
 * A reference-number of 0 or greater signals a proper connection to the database. */
        if (intDBConReference < 0) {
/* de:
 * Fehler beim Verbinden zur Datenbank; über Status-Variable an die aufrufende Methode
 * signalisieren. Diese Methode beenden.
 * en:
 * Error when connecting to the database; signal this to the calling method using
 * the status-variables. End this Method. */
          StatusCode = JSBS_Language_BO.CONST_DB_SYSTEM_ERROR;
          StatusMsg = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
          return;
        }
/* de:
 * Datenbank läuft auf der lokalen Maschine; 'Server-Seitige' Klasse des BO direkt
 * 'konstruieren'.
 * Verbindung zur Datenbank und die Werte dieser 'Client-seitigen' BO-Klasse
 * als Parameter übertragen.
 * en:
 * Database is running on the local machine; construct the 'Server-Side' BO directly.
 * Pass the database-connection and the values of this 'Client-Side' BO as parameters. */
        JSBS_Language_BOS_Set bosJSBS_Language_BOS_Set =
          new JSBS_Language_BOS_Set(frmTask.structMinParm, structDBCon, true); 
/* de: Aufrufen der Methode, die die Operation auf der Datenbank ausführt.
 * en: Call the method to perform the database-operation(s). */
        bosJSBS_Language_BOS_Set.selectByISOLanguageCode(parmISOLanguageCode);
/* de:
 * Übertragen der zurückgelieferten Werte der Variablen und den Status enthalten.
 * Ausserdem kann auf das BOS nicht mehr zugegriffen werden sobald diese Methode beendet ist.
 * en:
 * Transfer the returned values of the variables and the Status.
 * Additionally the values of the BOS can no longer be accesses as soon as this method has ended. */
        copyFromJSBS_Language_BO_Set(bosJSBS_Language_BOS_Set);
/* de:
 * Verbindung zur Datenbank an den Connection-Manager zurück geben.
 * Der Connection Manager verwaltet die offenen Verbindungen zur Datenbank und verwendet
 * sie wieder bei der nächsten Anforderung.
 * en:
 * Return the connection to the database to the Connection-Manager.
 * The Connection-Manager administers open connections to the database and reuses it
 * at the next request. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
    }
/*
 * de: METHODE zum Lesen der Daten über den JAS (Java Application Server).
 * en: METHOD to read the data via the JAS (Java Application Server). */
    private void selectByISOLanguageCode_JAS(String parmISOLanguageCode) {
/* de: Der Zugriff auf die Datenbank läuft über den EJB-Mechanismus.
 * en: Access to the database is by using the EJB-mechanism. */
        try {
/* de:
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB.
 * Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * en:
 * Instantiate (construct) the client-side object ('Remote interface') for calling
 * methods of the EJB.
 * The method to instantiate is implemented in the Start-Frame. */
          JSBS_StandardEJBBeanRemote remoteJSBS_StandardEJBBean =
            frmCC.get_JSBS_StandardEJBBeanRemote();
/*
 * de: Prüfen, ob überhaupt eine Verbindung zum JAS hergestellt werden konnte.
 * en: Verify if a connection to the JAS has been established. */
          if (remoteJSBS_StandardEJBBean == null) {
/*
 * de: Keine Verbindung zum JAS; Fehler zurückmelden.
 * en: No connection to the JAS; report error. */
            this.StatusCode = JSBS_Language_BO.CONST_DB_UNKNOWN_ERROR;
            this.StatusMsg = "No connection to JAS; method: JSBS_Language_BOC.selectByISOLanguageCode()";
            return;
          }
/* de:
 * Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu diesem
 * Client-seitigen Teil des BO - passende Server-seitige Methode aufgerufen.
 * Neue Werte für die Variablen des BO und eventuelle Fehlermeldungen sind im zurückgelieferten
 * BO enthalten.
 * en:
 * Call the 'wrapper'-method of the EJB. Within this 'wrapper'-method the server-side method 
 * - which fits this method of the client-side derivation of the BO - is called.
 * New values for variables of the BO and probably occured error-messages are contained in the
 * returned BO. */
          JSBS_Language_BO_Set boJSBS_Language_BO_Set =
            remoteJSBS_StandardEJBBean.
              JSBS_Language_BO_Set__selectByISOLanguageCode(frmTask.structMinParm, parmISOLanguageCode);
/* de:
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) kopieren.
 * en:
 * Copy the values of the returned BO to this BOC (client-side derivation of the BO). */
          this.copyFromJSBS_Language_BO_Set(boJSBS_Language_BO_Set);
        }
        catch (Exception e) {
/* de:
 * Fehler beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen.
 * en:
 * Error when executing the method of the EJB.
 * Transfer the error-message from the Exception and set status. */
          this.StatusCode = JSBS_Language_BO.CONST_DB_UNKNOWN_ERROR;
          this.StatusMsg = e.getMessage();
        }
    }
/*
 * --------------------
 * de:
 * METHODE zum Lesen aller aktuell gültigen Sprachen von der Datenbank.
 * en:
 * METHOD to read all languages valid at the actual data from the database. */
    public void selectByISOLanguageCode(String parmISOLanguageCode) {
/*
 * de: Entscheiden mit welcher Version das Anwendungsprogramm läuft.
 * en: Decide what version the application runs. */
        switch (frmCC.RunVersion) {
        case JSBS_StartFrame.CONST_StandAlone:
/* de:
 * Einzelplatzversion. Datenbank läuft auf der lokalen Maschine; Spezielle Methode aufrufen.
 * en:
 * Stand-alone version. Database is running on the local machine; call the specialized method. */
            selectByISOLanguageCode_DB(parmISOLanguageCode);
            break;
        case JSBS_StartFrame.CONST_FatClient:
/* de:
 * Client-Server-Version.
 * Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java Application Server); spezielle Methode aufrufen.
 * en:
 * Client-Server-version.
 * Data is accessed via the EJB-mechanism and the JAS (Java Application Server); call the specialized method. */
            selectByISOLanguageCode_JAS(parmISOLanguageCode);
            break;
        case JSBS_StartFrame.CONST_MobileClient:
/* de:
 * Zuerst die Daten von der lokalen Datenbank abfragen. Per Definition muss das immer möglich sein.
 * en:
 * Read the data from the local database. As per definition this must always be possible. */
            selectByISOLanguageCode_DB(parmISOLanguageCode);
/* de:
 * Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar.
 * en:
 * Verify, if an error occured when reading the local database. In that case end this method - that makes
 * the status available for the calling method. */
            if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* de: 'Erlaubte' Status-Codes für die Abfrage von der lokalen Datenbank.
 * en: 'Permitted' status-codes for the read from the local database. */
            }
            else return;
/* de:
 * Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt die weitere Verarbeitung.
 * en:
 * Verify, if the connection to the JAS exists. The further processing depends on the result. */
            if (frmCC.testJASConnection()) {
/* de:
 * BO-Sets für die Daten der lokalen Datenbank und den Daten vom JAS konstruieren.
 * Damit können später die jeweiligen Daten verglichen und Unterschiede behandelt werden.
 * en:
 * Construct BO-Sets for the data from the local database and the data from the JAS.
 * This allows to compare the data later and process differences. */
              JSBS_Language_BO_Set structJSBS_Language_BO_Set_Local = new JSBS_Language_BO_Set();
              JSBS_Language_BO_Set structJSBS_Language_BO_Set_JAS = new JSBS_Language_BO_Set();
/* de:
 * Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene Variable übertragen und den
 * Vector mit den BO in diesem Objekt leeren.
 * en:
 * Transfer the result of the read from the local database to the variable designated for that.
 * Empty the vector with the BO within this object thereafter. */
              structJSBS_Language_BO_Set_Local.copyFromJSBS_Language_BO_Set(this);
              vecRecordSet.removeAllElements();
/* de: Daten vom JAS abfragen.
 * en: Read the data from the JAS. */
              selectByISOLanguageCode_JAS(parmISOLanguageCode);
/* de:
 * Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar.
 * en:
 * Verify, if an error occured when reading from the JAS. In that case end this method - that makes
 * the status available for the calling method. */
              if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* de: 'Erlaubte' Status-Codes für die Abfrage über den JAS.
 * en: 'Permitted' status-codes for the read via the JAS. */
              }
              else return;
/* de:
 * Ergebnis der Abfrage über den JAS auf die dafür vorgesehene Variable übertragen und den
 * Vector mit den BO in diesem Objekt leeren.
 * en:
 * Transfer the result of the read via the JAS to the variable designated for that.
 * Empty the vector with the BO within this object thereafter. */
              structJSBS_Language_BO_Set_JAS.copyFromJSBS_Language_BO_Set(this);
              vecRecordSet.removeAllElements();
/* de: Methode zum Abgleich der Daten von beiden Quellen aufrufen.
 * en: Call the method that merges the data from both sources. */
              mergeList(structJSBS_Language_BO_Set_Local, structJSBS_Language_BO_Set_JAS);
/* de:
 * Methode zum Sortieren nach dem Sprach-Code aufrufen weil die BO nach dem Abgleich nach
 * ihrer Herkunft sortiert sind.
 * en:
 * Call the method to sort by language-code as the BO are sorted by their source after the merge. */
              sortByISOLanguageCode_LanguageCodeForLabelling();
            }
            break;
        }
/*
 * de: Methode aufrufen, die die Matrix für die Anzeige der Daten erstellt.
 * en: Call the method that builds the matrix for the display of the data. */
      buildRawDataVector();
    }
}

▲ zum Inhaltsverzeichnis

Erklärungen und Anwendungsbeispiele

Die Methoden dieser Klasse werden nur von Methoden innerhalb des JavaScout Basis-Systems aufgerufen und sind nicht für eine allgemeine Verwendung gedacht.

▲ zum Inhaltsverzeichnis

Verwandte Dokumentation

Dokument

Inhalt



▲ zum Inhaltsverzeichnis