|
Letzte
Bearbeitung dieses Dokuments: |
Code
Erklärungen
und Anwendungsbeispiele
Verwandte
Dokumentation
package
js_base.boc;/*
* de: Package und Klasse für das Bearbeiten eines
'Vector'.
* en: Package and class to manipulate a 'Vector'.
*/import
java.util.Vector;
/*
* de: Package mit der Generellen Klasse für dieses BO.
* en: Package with the general class for this BO. */import
js_base.bo.*;/*
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.*; /**
*
* @author kurt(at)javascout[dot]biz
* @date
2011-10-04
*
* @description
* de:
* Klasse für den Datenabgleich zwischen JAS (Java Application Server) und lokaler Datenbank
* für Daten der Klasse JSBS_Language_BO
(Sprache).
*
* Diese Klasse ist notwendig wenn das Anwendungsprogramm auch für die Version 'MobileClient'
* implementiert ist und damit die Daten zwischen lokaler Datenbank des mobilen Client-Gerätes
* und den Daten auf dem JAS synchronisiert werden müssen.
*
-------------------
* en: *
Class for the synchronization of date between JAS (Java Application Server) and local databass
*
for data of class JSBS_Language_BO (language).
*
* This class is needed when the applicatio-program is implemented for the version 'MobileClient',
* too. Then, the data between the local database on the mobile client device and the database
* on the JAS have to be synchronized.
*
*
@change-log
*
when who why
*
--------------------------------------------------------
*
*/public
class JSBS_Language_BO_Synchronizer
extends Thread {/* ---------------------
* VARIABLE dieser Klasse / VARIABLES of this
class.
* --------------------- *//*
*
de:
* Referenz auf das Start-Frame (CommandCenter), das bei
der 'Konstruktion' eines Objekts
* dieser Klasse übergeben
wurde.
* Im StartFrame sind die Objekte für die Verbindungen zur Datenbank und zum JAS enthalten.
* Weiters ist dort das aktuelle Arbeitsdatum definiert.
* en: *
Reference to the Start-Frame (CommandCenter) that was passed during
the 'construction' an object *
of this class.
* The StartFrame contains the objects for the connection to the database and the JAS.
* Further it holds the actual working-date. */
private
JSBS_StartFrame frmCC
=
null;/*
*
de:
* Referenz auf das Task-Frame, das das Objekt dieser
Klasse 'konstruiert' hat.
* Dieses wird als Parameter beim 'Konstruieren' von BOC (Client-side Teil der BO)
* benötigt.
* en: *
Reference to the Task-Frame that 'constructed' an object of this
class.
* This reference is needed when BOC (client-side part of a BO) are 'constructed'. */
private
JSBS_TaskFrame frmTask
=
null;/* *
de: * Vector mit den Allgemeinen Attributen (CommonAttributes) der BO, deren Daten zwischen * lokaler Datenbank und JAS abgeglichen werden sollen. * Über die Allgemeinen Attribute kann erkannt werden ob ein Datensatz auf dem JAS und der
* Datenbank am mobilen Client Gerät ident ist. *
en: * Vector with the CommonAttributes of the BO, which data should be synchronized between
* local database and JAS.
* The CommonAttributes indicate if a dataset on the JAS and the database on the mobile
* client device is identical. */ private Vector<JSBS_BO> vecBO_List_ToProcess
=
new Vector<JSBS_BO>();/*
*
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 variabels defined above.
*
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_BO_Synchronizer(JSBS_StartFrame
parmfrmStart, JSBS_TaskFrame parmfrmTask) { frmCC
= parmfrmStart; frmTask
= parmfrmTask;
}/*
*
METHODEN / METHODS
* ----------------------
*//*
* --------------------
* de:
* METHODE
zum Übergeben eines einzelnen BO an diese Klasse und Starten des
* Abgleichs von dessen Daten auf der lokalen Datenbank mit den Daten auf dem JAS.
* * en:
* METHOD
to pass a single BO to this class and start the synchronization of its
* data on the local database with the data on the JAS. */
public void passBO(JSBS_Language_BO parmJSBS_Language_BO)
{/*
* de:
* Prüfen ob der zu bearbeitende Parameter nicht 'null' ist;
sonst diese Methode beenden.
* en:
* Check if the Parameter to be processed is not 'null'; otherwise end this method. */ if
(parmJSBS_Language_BO == null) return; /*
* de:
* Ein neues BO 'konstruieren' und die Werte des BO aus dem Parameter kopieren.
* Ein neues BO ist deswegen notwendig weil im Parameter nur die Referenz auf das
* BO übergeben wird.
* Weil diese Klasse einen nebenläufigen Prozess enthält kann das BO im übergebenen
* Parameter schon 'verschwunden' sein wenn es bearbeitet werden soll.
* en:
* 'Construct' a new BO and copy the values from the BO passed in the parameter.
* A new BO is needes as this class contains a thread (running in parallel) and the
* BO in the parameter might be already 'disappeared' at the time it should be processed. */
JSBS_BO locJSBS_BO = new JSBS_BO();
locJSBS_BO.copyFromJSBS_BO(parmJSBS_Language_BO);/*
* de:
* Gerade konstruiertes BO in den Vector mit den zu synchronisierenden BO einfügen.
* Der Befehl wird 'synchronized' ausgeführt damit im nebenläufigen Prozess
* (Methode 'run()') nicht gleichzeitig eine Abfrage auf die Anzahl der Elemente
* im Vector erfolgen kann. Sonst würde ein falscher Wert und Index verwendet.
* en:
* Insert the just constructed BO into the Vector with the BO to be synchronized.
* The command is executed 'synchronized' to avoid a concurrent query for the
* number of elements in the vector. Otherwise a wrong value and index would be used. */ synchronized
(vecBO_List_ToProcess) {
vecBO_List_ToProcess.addElement(locJSBS_BO); }/*
* de:
* Prüfen ob der nebenläufige Prozess bereits gestartet ist und wenn nötig den
* nebenläufigen Prozess starten.
* en:
* Check if the thread is already started and start it if neccessary. */ if
(! this.isAlive()) this.run();
}/*
* --------------------
* de:
* METHODE
zum Übergeben einer Liste von BO (BO-Set) an diese Klasse und Starten des
* Abgleichs von dessen Daten auf der lokalen Datenbank mit den Daten auf dem JAS.
*
* en:
* METHOD
to pass a list of BO (BO-set) to this class and start the synchronization
* of its data on the local database with the data on the JAS. */
public void passBOList(JSBS_Language_BO_Set parmJSBS_Language_BO_Set)
{/*
* de:
* Prüfen ob der zu bearbeitende Parameter nicht 'null' ist;
sonst diese Methode beenden.
* en:
* Check if the Parameter to
be processed is not 'null'; otherwise end this method. */ if
(parmJSBS_Language_BO_Set == null) return; if
(parmJSBS_Language_BO_Set.vecRecordSet == null) return; /*
*
de:
* Größe (Anzahl der BO) des Vectors der im Parameter übergeben wurde feststellen
* und Index
zum Durchsuchen definieren.
* en: * Determine
the size (number of BO) of the vector passed as parameter
* and define the index to search the
vector. */ int intVectorSize
= parmJSBS_Language_BO_Set.vecRecordSet.size(); int intVectorIndex;/*
*
de:
*
Mit einer for-Schleife alle BO des als Parameter übergebenen
Objekts in den
*
Vector mit den CommonAttributes übernehmen.
* en:
*
Use a for-loop to transfer
all BO within the object passed as parameter
*
into the vector with the CommonAttributes. */ for
(intVectorIndex
= 0; intVectorIndex < intVectorSize; intVectorIndex++)
{/*
*
de:
* Neues BO mit den CommonAttributes definieren und die Werte aus dem indizierten BO.
* in das neue BO kopieren.
* en: * Define a new BO with the CommonAttributes and copy the values of the indexed BO.
* into the new BO. */ JSBS_BO locJSBS_BO =
new JSBS_BO(); locJSBS_BO.copyFromJSBS_BO((JSBS_BO) parmJSBS_Language_BO_Set.vecRecordSet.elementAt(intVectorIndex));/*
* de:
* Gerade konstruiertes BO in den Vector mit den zu synchronisierenden BO einfügen.
* Der Befehl wird 'synchronized' ausgeführt damit im nebenläufigen Prozess
* (Methode 'run()') nicht gleichzeitig eine Abfrage auf die Anzahl der Elemente
* im Vector erfolgen kann. Sonst würde ein falscher Wert und Index verwendet.
* en:
* Insert the just constructed BO into the Vector with the BO to be synchronized.
* The command is executed 'synchronized' to avoid a concurrent query for the
* number of elements in the vector. Otherwise a wrong value and index would be used. */ synchronized
(vecBO_List_ToProcess) { vecBO_List_ToProcess.addElement(locJSBS_BO); } }/*
* de:
* Prüfen ob der nebenläufige Prozess bereits gestartet ist und wenn nötig den
* nebenläufigen Prozess starten.
* en:
* Check if the thread is already started and start it if neccessary. */ if
(! this.isAlive()) this.run();
}
/*
* --------------------
*
de:
* METHODE, die nebenläufig ausgeführt wird (Thread).
* Dabei werden alle Elemente des Vectors mit den CommonAttribute-BO verarbeitet.
* Für jedes CommonAttribute-BO wird verglichen, ob die Datensätze dieses BO gleichzeitig
* auf der Datenbank des JAS und der lokalen Datenbank des MobileClient vorhanden sind.
* Fehlende Datensätze werden (in die jeweilige Richtung) kopiert.
* Nach dem Synchronisieren eines BO wird der Eintrag aus der Liste (vecBO_List_To_Process)
* entfernt. Diese Methode wird beendet wenn kein Eintrag mehr in der Liste vorhanden ist.
* Diese Methode 'run()' muss in einem Thread unbedingt vorhanden sein !
* --------------------
* en: *
METHOD that is run as a thread (parallel process).
* Within this method, all elements of the vector with the CommonAttribute-BO are processed.
* For each CommonAttribute-BO is compared, if the datasets of this BO are present on the
* database of the JAS and on the local database of the MobileClient. Missing datasets are
* copied (in the needed direction).
* After synchronising a BO, the entry in the list (vecBO_List_To_Process) is removed. This
* method ends when no more entries are present in the list.
* This method 'run()' is mandatory within a Thread ! */
public
void run()
{
/*
*
de: Diese Methode muss unbedingt eine try/catch-Logik enthalten.
*
en: A try/catch-logic is mandatory for this method.
*/
try
{
/*
* de:
* Variable für die Anzahl der Elemente im Vector definieren.
* Die Anzahl wird innerhalb der for-Schleife abgefragt.
* en:
* Define a variable for the number of elements within the vector.
*/ int intVectorSize;/*
* de:
* 'Endlose' for-Schleife beginnen.
* Die Schleife wird abgebrochen wenn der Vector kein Element mehr enthält.
* Durch den nebenläufigen Prozess können aber während des Ausführens der for-Schleife
* weiter Elemente in den Vector eingefügt werden - daher wird das Abbruch-Kriterium
* erst am Ende der for-Schleife geprüft.
* en:
* Start an 'endless' for-loop.
* The loop ends when no more element is within the vector.
* With the parallel process, elements can be added during the for-loop is running.
* Therefore the termination-criteria is checked at the end of the loop.
*/ for
(;;)
{/*
* de:
* Anzahl der Elemente im Vector abfragen.
* Der Befehl wird 'synchronized' ausgeführt damit nicht gleichzeitig ein weiteres
* Element eingefügt oder entfernt werden kann.
* en:
* Get the number of elements within the vector.
* The command is executed 'synchronized' to avoid a concurrent entry or removal of
* an element. */ synchronized
(vecBO_List_ToProcess) { intVectorSize = vecBO_List_ToProcess.size(); }/*
de:
* Wenn im Vector kein Element mehr vorhanden ist wird die for-Schleife beendet.
* Und damit auch die Methode 'run()'.
*
en:
* If no more element is within the vector then the for-loop is terminated.
* That causes a termination of the method 'run()', too.
*/
if
(intVectorSize <= 0) break;
/*
*
de: Methode aufrufen in der das erste BO im Vector (mit Index 0) synchronisiert wird.
*
en: Call the method for synchronizing the first BO (with index 0) within the vector.
*/
synchronizeBO();
}
}
catch (Exception
e) {
/*
de:
* Es ist ziemlich unwahrscheinlich, dass in einem so einfachen Thread ein Fehler auftritt.
* Sollte ein Fehler doch passieren bleibt dieser unbehandelt weil damit nur das Abgleichen
* der Daten zwischen Datenbank des JAS und lokaler Datenbank unterbrochen wird.
* Dies wird bei einem neuerlichen Abgleich nachgeholt und ist damit im Anwendungsprogramm
* vorgesehen.
*
en:
* The change
that an error appears in such a simple thread is very low.
* If an error
should happen anyway, it is not handled. The only effect of an error is,
that
* the
synchronization of data on the JAS and data on the local database is
stopped.
* This is done
at a new synchronization and therefore a feature of the
application-program.
*/
}
}/*
* --------------------
*
de:
* METHODE zum Aufrufen des nebenläufigen Prozess
(Thread) zum Abgleichen von BO wenn das *
Anwendungsprogramm in der Version 'MobileClient' läuft.
* Dabei wird das erste Element aus dem Vector (Index 0) ausgelesen und für dieses BO
* werden alle Datensätze (historisch, aktuell gültig, in der Zukunft gültig) von der
* lokalen Datenbank und der Datenbank des JAS gelesen.
* Wurde das BO auf einer Seite verändert dann werden die Datensätze zwischen JAS und
* MobileClient synchronisiert.
*
* en: *
METHOD to call the thread to synchronize BO if the
application-programm runs with the
* version 'MobileClient'.
* To do this, the first element of the vector (index 0) is read and for this BO all
* datasets (historic, actually valid, valid in the future) are read from the database
* of the JAS and from the local database.
* If the BO was changed on one side, the datasets will be synchronized beween JAS and
* MobileClient.
*/
private
void synchronizeBO()
{/*
* de:
* Variable für die Allgemeinen Attribute (CommonAttributes) eines BO aus dem Vector.
* en:
* Variable for the CommonAttributes of one BO out of the vector. */ JSBS_BO locBO;/*
* de:
* Prüfen ob überhaupt ein Element im Vector enthalten ist; sonst diese Methode gleich
* beenden. Anschließend das erste Element (Index 0) im Vector auslesen.
* Der Befehl wird 'synchronized' ausgeführt damit nicht gleichzeitig ein weiteres
* Element eingefügt oder entfernt werden kann.
* en:
* Verify if at least one element is within the vector; otherwise terminate this
* method immediately. Read the first element (index 0) out of the vector thereafter.
* The command is executed 'synchronized' to avoid a concurrent entry or removal of
* an element. */ synchronized
(vecBO_List_ToProcess) { if (vecBO_List_ToProcess.size() <= 0) return; locBO = (JSBS_BO) vecBO_List_ToProcess.elementAt(0); }/*
* de:
* BOC-Variable für das Lesen von der lokalen Datenbank konstruieren.
* en:
* Construct the BOC-variable to read from the local database. */ JSBS_Language_BOC_Set
structJSBS_Language_BOC_Set_DB = new JSBS_Language_BOC_Set(frmCC,
frmTask);/*
* de:
* Alle Datensätze für dieses BO von der lokalen Datenbank lesen.
* en:
* Read all datasets for this BO from the local database. */ structJSBS_Language_BOC_Set_DB.selectAllByObjectID(locBO.ObjectID);
/*
* de:
* Prüfen ob die Datenbank-Operation fehlerfrei war. Dazu den Status-Code des BOC abfragen.
* en:
* Verify if the database operation ended without an error. To do this evaluate the
* status-code of the BOC. */ switch (structJSBS_Language_BOC_Set_DB.StatusCode) { case JSBS_BO.CONST_OK :/*
* de:
* Verarbeitung wie erwartet; Daten ohne Fehler gelesen.
* en:
* Processing ended as expected; data read without an error. */ break; case JSBS_BO.CONST_NOT_FOUND :/*
* de:
* Noch keine Daten vorhanden; das ist kein Fehler.
* en:
* No data present; that is not an error. */ break; default :/*
* de:
* Ein anderer Fehler ist beim Lesen der Daten aufgetreten.
* Fehlerbehandlungsmethode des Task-Frame aufrufen und Methode beenden.
* en:
* Another error occured when reading the data.
* Call the error-handler of the Task-Frame and end the method. */ frmTask.handleErrorEvent(this.getClass().getName(), "synchronizeBO_DB", Integer.toString(structJSBS_Language_BOC_Set_DB.StatusCode), structJSBS_Language_BOC_Set_DB.StatusMsg); return; }/*
* de:
* BOC-Variable für das Lesen von der Datenbank des JAS konstruieren.
* en:
* Construct the BOC-variable to read from the database of the JAS. */ JSBS_Language_BOC_Set
structJSBS_Language_BOC_Set_JAS = new JSBS_Language_BOC_Set(frmCC,
frmTask);/*
* de:
* Alle Datensätze für dieses BO von der Datenbank des JAS lesen.
* en:
* Read all datasets for this BO from the database of the JAS. */ structJSBS_Language_BOC_Set_JAS.selectAllByObjectID(locBO.ObjectID);
/*
* de:
* Prüfen ob die Datenbank-Operation fehlerfrei war. Dazu den Status-Code des BOC abfragen.
* en:
* Verify if the database operation ended without an error. To do this evaluate the
* status-code of the BOC. */ switch (structJSBS_Language_BOC_Set_JAS.StatusCode) { case JSBS_BO.CONST_OK :/*
* de:
* Verarbeitung wie erwartet; Daten ohne Fehler gelesen.
* en:
* Processing ended as expected; data read without an error. */ break; case JSBS_BO.CONST_NOT_FOUND :/*
* de:
* Noch keine Daten vorhanden; das ist kein Fehler.
* en:
* No data present; that is not an error. */ break; default :/*
* de:
* Ein anderer Fehler ist beim Lesen der Daten aufgetreten.
* Fehlerbehandlungsmethode des Task-Frame aufrufen und Methode beenden.
* en:
* Another error occured when reading the data.
* Call the error-handler of the Task-Frame and end the method. */ frmTask.handleErrorEvent(this.getClass().getName(), "synchronizeBO_JAS", Integer.toString(structJSBS_Language_BOC_Set_JAS.StatusCode), structJSBS_Language_BOC_Set_JAS.StatusMsg); return; }
/*
* de:
* Variable für die jeweiligen Datensätze des BO aus den Listen (mit einzelnen, historischen
* Datensätzen eines BO) von lokaler Datenbank und JAS.
* en:
* variables for the particular datasets of the BO from the lists (with single, historic datasets
* of a BO) from local database and JAS. */ JSBS_Language_BO locBO_DB; JSBS_Language_BO locBO_JAS;
/*
* de:
* Variable für die Anzahl der Elemente in den jeweiligen Vectors (Sets) und Variable für die Indizes.
* en:
* Variables for the number of elements within each vector (set) and variables for the indizes. */ int intDBVectorSize = structJSBS_Language_BOC_Set_DB.vecRecordSet.size(); int intDBVectorIndex; int intJASVectorSize; int intJASVectorIndex;
/*
* de:
* Merker ob ein Datensatz des untersuchten BO bereits synchron auf beiden Datenbanken existiert.
* en:
* Flag to signal if a dataset of the inspected BO already exists synchronized on both databases. */ boolean bolAlreadySynchronized;/*
* de:
* for-Schleife für das Bearbeiten der einzelnen Datensätze des BO auf der lokalen Datenbank.
* Die Untersuchung wird beim 'ältesten' Datensatz (Element des Vectors mit dem höchsten Index)
* begonnen weil bereits geprüfte Datensätze aus dem Vector entfernt werden.
* en:
* for-loop to process the singular datasets of the BO on the local database.
* The inspection starts at the 'olest' dataset (element in the vector with the highest index)
* as already inspected datasets will be removed from the vector. */ for (intDBVectorIndex = intDBVectorSize - 1; intDBVectorIndex >= 0; intDBVectorIndex--) {/*
* de:
* Herausholen eines einzelnen Datensatzes aus dem Vector; damit wird die weitere Verarbeitung leichter.
* en:
* Get a single dataset out of the vector; that simplifies the further processing. */ locBO_DB = (JSBS_Language_BO) structJSBS_Language_BOC_Set_DB.vecRecordSet.elementAt(intDBVectorIndex);/*
* de:
* Setzen des Merkers für das Festhalten, ob der Datensatz von der lokalen Datenbank auch bereits
* auf der Datenbank des JAS vorhanden ist.
* en:
* Set the flag to keep track if the dataset from the local database exists on the database of
* the JAS, too. */ bolAlreadySynchronized = false; /*
* de:
* Ermitteln der Anzahl der Elemente im Vector (Set) mit den Datensätzen vom JAS.
* Dieses Ermitteln muss bei jedem Durchlauf der for-Schleife neu erfolgen weil bereits
* synchronisierte Datensätze aus dem Vector mit den Datensätzen vom JAS gelöscht werden.
* en:
* Determine the number of elements within the vector (set) with the datasets from the JAS.
* This has to be done at each start of the for-loop as already synchronized datasets are
* removed from the vector with the datasets from the JAS. */ intJASVectorSize = structJSBS_Language_BOC_Set_JAS.vecRecordSet.size();/*
* de:
* for-Schleife für das Bearbeiten der einzelnen Datensätze des BO auf der Datenbank des JAS.
* Die Untersuchung wird beim 'ältesten' Datensatz (Element des Vectors mit dem höchsten Index)
* begonnen weil bereits geprüfte Datensätze aus dem Vector entfernt werden.
* en:
* for-loop to process the singular datasets of the BO on the database of the JAS.
* The inspection starts at the 'olest' dataset (element in the vector with the highest index)
* as already inspected datasets will be removed from the vector. */ for (intJASVectorIndex = intJASVectorSize - 1; intJASVectorIndex >= 0; intJASVectorIndex--) {/*
* de:
* Herausholen eines einzelnen Datensatzes aus dem Vector; damit wird die weitere Verarbeitung leichter.
* en:
* Get a single dataset out of the vector; that simplifies the further processing. */ locBO_JAS = (JSBS_Language_BO) structJSBS_Language_BOC_Set_JAS.vecRecordSet.elementAt(intJASVectorIndex);/*
* de:
* Prüfen ob die Datensätze auf der lokalen Datenbank und der Datenbank des JAS bereits gleich sind.
* en:
* Check if the datasets on the local database and the database of the JAS are already equal. */ bolAlreadySynchronized = ! locBO_JAS.isDifferent(locBO_DB); if (bolAlreadySynchronized) { /*
* de:
* Datensätze auf beiden Seiten komplett gleich; aus dem jeweiligen Vector entfernen und diese
* (innere) for-Schleife beenden.
* en:
* Datasets completely equal on both sides; remove from each particular vector and terminate
* this (inner) for-loop. */ structJSBS_Language_BOC_Set_DB.vecRecordSet.removeElementAt(intDBVectorIndex); structJSBS_Language_BOC_Set_JAS.vecRecordSet.removeElementAt(intJASVectorIndex); break ; }/*
* de:
* Mit diesem 'if' wird geprüft, ob der DataSetID gleich ist - im Umkehrschluss muss damit bei
* mindestem einem Attribut der Wert unterschiedlich sein.
* en:
* With this 'if' is checked if the DataSetID is equal - as a reverse conclusion the value of
* at least one attribute must be different. */ if (locBO_DB.DataSetID == locBO_JAS.DataSetID) { /*
* de:
* Prüfen, welcher Datensatz später verändert wurde und die Werte von diesem auf die 'andere
* Seite' übertragen.
* en:
* Check which dataset was changed later in time and transfer the value of this dataset to
* the 'other side'. */ if (locBO_DB.ChangedAt.after(locBO_JAS.ChangedAt)) synchronizeFromDB(locBO_DB); else synchronizeFromJAS(locBO_JAS); /*
* de:
* Datensätze synchronisiert. Merker setzen, Element aus dem jeweiligen Vector entfernen und
* diese (innere) for-Schleife beenden.
* en:
* Datasets synchronized. Set the flag, remove the element from each particular vector
* and terminate this (inner) for-loop. */ bolAlreadySynchronized = true; structJSBS_Language_BOC_Set_DB.vecRecordSet.removeElementAt(intDBVectorIndex); structJSBS_Language_BOC_Set_JAS.vecRecordSet.removeElementAt(intJASVectorIndex); break ; }/* de:
Ende der inneren for-Schleife.
* en: End of the inner for-loop. */ }/*
* de:
* Abfragen ob für den Datensatz auf der lokalen Datenbank kein Gegenpart auf dem JAS
* gefunden wurde.
* en:
* Check if a equivalent dataset on the JAS was not found on the local database. */ if (! bolAlreadySynchronized) { /*
* de:
* Datensatz von der lokalen Datenbank auf die Datenbank des JAS kopieren und aus dem
* Vector mit dem Set der lokalen Datenbank entfernen.
* en:
* Copy the dataset from the local database to the database on the JAS and remove from
* the vector with the set of the local database. */ synchronizeFromDB(locBO_DB); structJSBS_Language_BOC_Set_DB.vecRecordSet.removeElementAt(intDBVectorIndex); }/* de:
Ende der äußeren for-Schleife.
* en: End of the outer for-loop. */ }/*
* de:
* Die jetzt noch im Set des JAS enthaltenen Datensätze fehlen auf der Datenbank des
* MobileClient und werden jetzt dort eingefügt.
* Zuerst die Anzahl der Elemente im Vector ermitteln.
* en:
* The datasets still in the set of the JAS are missing at the database of the MobileClient
* and will be inserted now.
* First, get the number of elements in the vector. */ intJASVectorSize = structJSBS_Language_BOC_Set_JAS.vecRecordSet.size();/*
* de:
* for-Schleife zum Auslesen der verbliebenen Elemente im Vector der Datensätze vom
* JAS. Jeder Datensatz wird von der Datenbank des JAS auf die lokale Datenbank kopiert.
* en:
* for-loop to read the remaining elements in the vector for the datasets from the JAS.
* Each dataset will be copied from the database on the JAS to the local database. */ for (intJASVectorIndex = intJASVectorSize - 1; intJASVectorIndex >= 0; intJASVectorIndex--) { locBO_JAS = (JSBS_Language_BO) structJSBS_Language_BOC_Set_JAS.vecRecordSet.elementAt(intJASVectorIndex); synchronizeFromJAS(locBO_JAS); }/*
* de:
* Das gerade synchronisierte BO (im Vector das erste Element mit Index 0) aus dem Vector
* entfernen.
* Der Befehl wird 'synchronized' ausgeführt damit nicht gleichzeitig ein weiteres
* Element eingefügt oder die Anzahl der Elemente geprüft werden kann.
* en:
* Remove the just synchronized BO (the first element in the vector with index 0)
* from the vector.
* The command is executed 'synchronized' to avoid a concurrent entry of an element
* or the operation to count the elements in the vector. */ synchronized
(vecBO_List_ToProcess) { vecBO_List_ToProcess.removeElementAt(0); }
}/*
* --------------------
*
de:
* METHODE zum Kopieren der Daten des als Parameter übergebenen Datensatzes (als Teil * der Zeitreihe eines BO) auf die Datenbank des JAS (Java Application Server).
*
* en: *
METHOD to copy the data of the dataset (as part of the time series of a BO) passed *
in the parameter to the database of the JAS (Java Application Server).
*/
private
void synchronizeFromDB(JSBS_Language_BO parmJSBS_Language_BO)
{/*
* de:
* Merken des DataSetID auf der lokalen Datenbank für den Fall, dass der Wert auf der *
JAS-Seite geändert wird. *
Die Änderung kann vorkommen wenn während des asynchronen Betriebs des MobileClient *
der gleiche Wert auch auf dem JAS (an ein unterschiedliches BO) vergeben wurde.
* en:
* Keep the DataSetID on the local database for the case, that the value is changed
* on the JAS-side.
* A change might occur if, during the asynchronous operation of the MobileClient,
* the same value was assigned on the JAS (to a different BO), too. */ double dblOriginalDataSetID = parmJSBS_Language_BO.DataSetID;/*
* de:
* BOC-Variable für das Speichern auf dem JAS konstruieren.
* en:
* Construct the BOC-variable to store on the JAS. */ JSBS_Language_BOC
structJSBS_Language_BOC = new JSBS_Language_BOC(frmCC,
frmTask);/*
* de:
* Werte aus dem Parameter auf das gerade konstruierte BOC übertragen und
* Speichern auf dem JAS.
* en:
* Transfer the values from the parameter to the just constructed BOC and
* store on the JAS. */ structJSBS_Language_BOC.copyFromJSBS_Language_BO(parmJSBS_Language_BO);
structJSBS_Language_BOC.synchronizedStore_JAS();
/*
* de:
* Prüfen ob die Datenbank-Operation fehlerfrei war. Dazu den Status-Code des BOC abfragen.
* en:
* Verify if the database operation ended without an error. To do this evaluate the
* status-code of the BOC. */ switch (structJSBS_Language_BOC.StatusCode) { case JSBS_BO.CONST_OK :/*
* de: Verarbeitung wie erwartet; Daten ohne Fehler gespeichert.
* en: Processing ended as expected; data stored without an error. */ break; default :/*
* de:
* Ein anderer Fehler ist beim Lesen der Daten aufgetreten.
* Fehlerbehandlungsmethode des Task-Frame aufrufen und Methode beenden.
* en:
* Another error occured when reading the data.
* Call the error-handler of the Task-Frame and end the method. */ frmTask.handleErrorEvent(this.getClass().getName(), "synchronizeFromDB_JAS", Integer.toString(structJSBS_Language_BOC.StatusCode), structJSBS_Language_BOC.StatusMsg); return; }/*
* de:
* Prüfen, ob der Wert des DataSetID auf dem JAS geändert wurde.
* In diesem Fall wird der Wert des DataSetID auf der lokalen Datenbank jenem auf dem
* JAS angepasst.
* en:
* Verify, if the value of the DataSetID was changed on the JAS.
* In that case the value of the DataSetID on the local database will be changed to
* that on the JAS. */ if (dblOriginalDataSetID != structJSBS_Language_BOC.DataSetID) { /*
* de: Ändern des Datensatzes auf der lokalen Datenbank.
* en: Dhange the dataset on the local database. */ structJSBS_Language_BOC.synchronizedStore_DB(dblOriginalDataSetID);
/*
* de:
* Prüfen ob die Datenbank-Operation fehlerfrei war. Dazu den Status-Code des BOC abfragen.
* en:
* Verify if the database operation ended without an error. To do this evaluate the
* status-code of the BOC. */ switch (structJSBS_Language_BOC.StatusCode) { case JSBS_BO.CONST_OK :/*
* de:
* Verarbeitung wie erwartet; Daten ohne Fehler gelesen.
* en:
* Processing ended as expected; data read without an error. */ break; default :/*
* de:
* Ein anderer Fehler ist beim Lesen der Daten aufgetreten.
* Fehlerbehandlungsmethode des Task-Frame aufrufen und Methode beenden.
* en:
* Another error occured when reading the data.
* Call the error-handler of the Task-Frame and end the method. */ frmTask.handleErrorEvent(this.getClass().getName(), "synchronizeFromDB_DB", Integer.toString(structJSBS_Language_BOC.StatusCode), structJSBS_Language_BOC.StatusMsg); return; }
}
}/*
* --------------------
*
de:
* METHODE zum Kopieren der Daten des als Parameter übergebenen Datensatzes (als Teil * der Zeitreihe eines BO) auf die lokale Datenbank des mobilen Client Gerätes.
*
* en: *
METHOD to copy the data of the dataset (as part of the time series of a BO) passed *
in the parameter to the local database of the mobile client device.
*/
private
void synchronizeFromJAS(JSBS_Language_BO parmJSBS_Language_BO)
{/*
* de:
* BOC-Variable für das Speichern auf der lokalen Datenbank konstruieren.
* en:
* Construct the BOC-variable to store on the local database. */ JSBS_Language_BOC
structJSBS_Language_BOC = new JSBS_Language_BOC(frmCC,
frmTask);/*
* de:
* Werte aus dem Parameter auf das gerade konstruierte BOC übertragen und
* Speichern auf der lokalen Datenbank.
* en:
* Transfer the values from the parameter to the just constructed BOC and
* store on the local database. */ structJSBS_Language_BOC.copyFromJSBS_Language_BO(parmJSBS_Language_BO);
structJSBS_Language_BOC.synchronizedStore_DB(0);
/*
* de:
* Prüfen ob die Datenbank-Operation fehlerfrei war. Dazu den Status-Code des BOC abfragen.
* en:
* Verify if the database operation ended without an error. To do this evaluate the
* status-code of the BOC. */ switch (structJSBS_Language_BOC.StatusCode) { case JSBS_BO.CONST_OK :/*
* de: Verarbeitung wie erwartet; Daten ohne Fehler gespeichert.
* en: Processing ended as expected; data stored without an error. */ break; default :/*
* de:
* Ein anderer Fehler ist beim Lesen der Daten aufgetreten.
* Fehlerbehandlungsmethode des Task-Frame aufrufen und Methode beenden.
* en:
* Another error occured when reading the data.
* Call the error-handler of the Task-Frame and end the method. */ frmTask.handleErrorEvent(this.getClass().getName(), "synchronizeFromJAS", Integer.toString(structJSBS_Language_BOC.StatusCode), structJSBS_Language_BOC.StatusMsg); return; }
}}
Die Methoden dieser Klasse werden nur von Methoden innerhalb des JavaScout Basis-Systems aufgerufen und sind nicht für eine allgemeine Verwendung gedacht.
|
Dokument |
Inhalt |
|
|
|