|
Letzte
Bearbeitung dieses Dokuments: |
Code
Erklärungen
und Anwendungsbeispiele
Verwandte
Dokumentation
package
js_base.utilities;
/**
*
* @author kurt[at]javascout(dot)biz
* @date
2012-06-04
*
* @description
* de:
* Klasse
mit statischen Methoden zur Bildung und Verwaltung von Sets mit
binären Werten (Merker / Flags).
* Jeder
dieser Merker ist eine Potenz von 2 (1, 2, 4, 8, 16, . . . .) und
repräsentiert den Wert 'Ja' oder 'Nein'.
* Das
Set der 'Merker' wird durch eine einzige Zahl vom Typ 'long'
repräsentiert.
* Die Methoden dieser Klasse
ermöglichen das Hinzufügen und Entfernen von
'Merkern'
* in das Set der 'Merker' und das
Prüfen, ob ein bestimmter 'Merker' in dem Set enthalten
ist.
* Diese Klasse kann durch
Anwendungs-spezifische Klassen geerbt werden. In den
erbenden
* Klassen können die einzelnen
'Merker' durch Konstanten mit sprechenden Namen implementiert
werden.
* -------------------
* en:
* Class
with static methods to create and administrate sets with binary
values (Flags).
* Each 'flag' is a power of 2 (1,
2, 4, 8, 16, . . . .) and represents the value 'Yes' or 'No'.
* The
set of the 'flags' is represented by a single number of type
'long'.
* The methods of this class allow to add
or remove of 'flags' to/from the set of
* the
'flags' and the verification if a certain 'flag' is contained with
the set.
* This class can be inherited by
application-specific classes. Within the inheriting
classes
* single 'flags' can be implemented as
constants with a nane that is easy remindable.
*
*
@change-log
* when who why
*
--------------------------------------------------------
*
*/public
class JSBS_FlagSet
{/*
*
**************************************************
*/
/* de:
* Methode zum Prüfen, ob der
Wert des übergebenen Parameters eine exakte Potenz
* von
2 ist. Damit kann geprüft werden, ob der Wert ein einzelner
'Merker' (Flag)
* ist oder bereits ein Set bestehend
aus mehreren 'Merkern' (Flags).
* en:
* Method
to verify if the value of the passed parameter is an exact power of
2.
* This allows to verify, if the value is a singular
Flag or already a set of
* several flags.
*/ private
static boolean isSingularFlag(long
parmFlagToBeChecked)
{/* de:
Variable zum Erzeugen der Potenzen von 2.
* en:
Variable to produce the powers of 2. */ long
intPowerOf2
= 1;/* de:
* for-Schleife zum Prüfen ob der zu prüfende
Wert (im Parameter übergeben)
* genau eine Potenz
von 2 ist.
* en:
* for-loop to verify
if the value to be checked (passed in the parameter)
* is
an exact power of 2. */ for
(;;)
{/* de:
* Prüfen, ob der im Parameter übergebenen
Wert genau die Potenz von 2 ist.
* en:
* Verify
if the value passed in the parameter is an exact power of 2.
*/ if
(intPowerOf2
== parmFlagToBeChecked) return
true;/* de:
Nächst-höhere Potenz von 2 berechnen.
* en:
Calculate the next higher power of 2. */ intPowerOf2
= intPowerOf2 * 2;/* de:
* Prüfen, ob die Potenz von 2 bereits größer
ist als der Wert im Parameter.
* en:
* Verify
if the power of 2 is already larger than the value passed in the
parameter. */ if
(intPowerOf2
> parmFlagToBeChecked) return
false; } }/*
*
**************************************************
*/
/* de:
* Methode zum Prüfen, ob der
Wert einer exakten Potenz (das ist ein einzelner
* 'Merker'
/ Flag) in einem Set von Merkern enthalten ist.
* en:
* Method
to verify if the value of an exact power of 2 (i.e. a singular flag)
is contained
* within a set of flags. */ private
static boolean isSingularFlagInFlagSet(long
parmFlagSet,
long
parmFlagToBeChecked)
{/* de:
* Zuerst Prüfen ob der Wert im Parameter für
den zu prüfenden 'Merker' wirklich nur der Wert
* für
einen einzelnen 'Merker' (Flag) enthält.
* en:
* First verify, if the value of the parameter for the
flag to be checked contains a value
* that represents a
singular flag only. */ if
(!
isSingularFlag(parmFlagToBeChecked)) return
false;/* de:
* Variable für den Restwert nach der
'MODULO'-Division.
* Potenzen von 2 können
ermittelt werden, wenn der Wert für das Set von 'Merkern'
(Flags)
* durch den doppelten Wert des zu prüfenden
'Merkers' (im Parameter 'parmFlagToBeChecked'
* übergeben)
'MODULO' dividiert wird.
* Ist der Restwert der
'MODULO'-Division gleich oder größer als der Wert für
den zu prüfenden
* 'Merker' (Flag), dann ist der
zu prüfende 'Merker' in dem Set enthalten.
* en:
* Variable for the residual value after the
'MODULO'-division.
* Powers of 2 can be determined if
the value for the set of flags are divided 'MODULO'
* by
the doubled value of the flag to be checked (passed in the parameter
'parmFlagToBeChecked'.
* Is the residual value of the
'MODULO'-division greater or equal the value of the flag to
* be
checked, the the flag to be checked is contained within the set of
flags. */ long
intResidualValue
= parmFlagSet % (parmFlagToBeChecked * 2); return
(intResidualValue
>= parmFlagToBeChecked); }/*
*
**************************************************
*/
/* de:
* Methode zum Umwandeln eines Arrays
mit 'Merkern' (Flags) in einen einzelnen Wert.
* en:
* Method
to convert an array with flags into a single value. */ private
static long convertArray(long[]
parmFlagsToBeChecked) {/* de:
Variable für den einzelnen Wert mit den zu prüfenden
'Merkern' (Flags).
* en: Variable a singular value
with the flags to be checked. */ long
intFlagsToBeChecked
= 0;/* de:
Variablen für die Steuerung der folgenden for-Schleife.
* en:
Variables to control the following for-loop. */ int
intArraySize
= parmFlagsToBeChecked.length; int
intArrayIndex; for
(intArrayIndex
= 0; intArrayIndex < intArraySize; intArrayIndex++) {/* de:
* Methode aufrufen, die den untersuchten Wert im Array
in den einzelnen Wert
* für die zu prüfenden
'Merker' hinzufügt.
* en:
* Call
the method that adds the inspected value within the array to the
singular
* value for the flags to be checked.
*/ addFlagsToFlagSet(intFlagsToBeChecked,
parmFlagsToBeChecked[intArrayIndex]); }/* de:
* Den einzelnen Wert mit den zu prüfenden
'Merkern' (Flags) an die aufrufende Methode
* zurück
liefern.
* en:
* Return the singular
value with the flags to be checked to the calling method.
*/ return
intFlagsToBeChecked; }/*
*
**************************************************
*/
/* de:
* Methode zum Prüfen, ob alle
singulären
'Merker' (Flags), die im Parameter
* 'parmFlagsToBeChecked'
übergeben werden, auch im Set der 'Merker' (im
* Parameter
'parmFlagSet' übergeben) enthalten sind.
* en:
* Method
to verify if all
singular
flags, that are passed within the
parameter
* 'parmFlagsToBeChecked', are contained
within the set of flags (passed in
* the parameter
'parmFlagSet'), too. */ public
static boolean areFlagsInFlagSet_AND(long
parmFlagSet,
long
parmFlagsToBeChecked)
{/* de:
Variable zum Erzeugen der Potenzen von 2.
* en:
Variable to produce the powers of 2. */ long
intPowerOf2
= 1;/* de:
* for-Schleife zum Prüfen ob die Potenz von 2
sowohl in den zu prüfenden 'Merkern' (Flags)
* als
auch im Set der 'Merker' enthalten ist.
* en:
* for-loop to verify if the power of 2 is contained
within the flags to be checked and
* within the set of
flags, too. */ for
(;;)
{/* de:
* Zuerst prüfen, ob die Potenz von 2 in den zu
prüfenden 'Merkern' enthalten ist.
* en:
* Verify first, if the power of 2 is contained within
the flags to be checked. */ if
(isSingularFlagInFlagSet(parmFlagsToBeChecked,
intPowerOf2)) {/* de:
* Jetzt prüfen, ob die Potenz von 2 auch im Set
der 'Merker' (Flags) enthalten ist.
* Ist die Potenz
von 2 nicht im Set enthalten, dann ist die AND-Bedingung nicht
erfüllt.
* en:
* Verify now, if
the power of 2 is contained in the set of flags, too.
* Is
the power of 2 not within the set of flags, then the AND-condition is
not fulfilled. */ if
(!
isSingularFlagInFlagSet(parmFlagSet, intPowerOf2)) return
false; }/* de:
Nächst-höhere Potenz von 2 berechnen.
* en:
Calculate the next higher power of 2. */ intPowerOf2
= intPowerOf2 * 2;/* de:
* Prüfen, ob die Potenz von 2 bereits größer
ist als der Wert im Parameter.
* In diesem Fall sind
alle 'Merker' (Flags) überprüft und im Set enthalten.
* en:
* Verify if the power of 2 is
already larger than the value passed in the parameter.
* In
that case all flags are checked and contained within the set.
*/ if
(intPowerOf2
> parmFlagsToBeChecked) return
true; } }
/* de:
* Wrapper-Methode
für ein Array mit den zu prüfenden 'Merkern' (Flags).
* en:
* Wrapper-method for an array with
the flags to be checked. */ public
static boolean areFlagsInFlagSet_AND(long
parmFlagSet,
long[]
parmFlagsToBeChecked) {/* de:
Array in eine einzelne Zahl umwandeln und die vorige Methode
aufrufen.
* en: Convert the array into a singular
number and call the method above. */ return
areFlagsInFlagSet_AND(parmFlagSet,
convertArray(parmFlagsToBeChecked)); }/*
*
**************************************************
*/
/* de:
* Methode zum Prüfen, ob
mindestens
einer
der
singulären 'Merker' (Flag), die
* im Parameter
'parmFlagsToBeChecked' übergeben werden, auch im Set der
'Merker'
* (im Parameter 'parmFlagSet' übergeben)
enthalten sind.
* en:
* Method to verify
if at
least one
of
the singular flags, that are passed within the
* parameter
'parmFlagsToBeChecked', are contained within the set of flags (passed
in
* the parameter 'parmFlagSet'), too. */ public
static boolean areFlagsInFlagSet_OR(long
parmFlagSet,
long
parmFlagsToBeChecked)
{/* de:
Variable zum Erzeugen der Potenzen von 2.
* en:
Variable to produce the powers of 2. */ long
intPowerOf2
= 1;/* de:
* for-Schleife zum Prüfen ob die Potenz von 2
sowohl in den zu prüfenden 'Merkern' (Flags)
* als
auch im Set der 'Merker' enthalten ist.
* en:
* for-loop to verify if the power of 2 is contained
within the flags to be checked and
* within the set of
flags, too. */ for
(;;)
{/* de:
* Zuerst prüfen, ob die Potenz von 2 in den zu
prüfenden 'Merkern' enthalten ist.
* en:
* Verify first, if the power of 2 is contained within
the flags to be checked. */ if
(isSingularFlagInFlagSet(parmFlagsToBeChecked,
intPowerOf2)) {/* de:
* Jetzt prüfen, ob die Potenz von 2 auch im Set
der 'Merker' (Flags) enthalten ist.
* Ist die Potenz
von 2 im Set enthalten, dann ist die OR-Bedingung erfüllt.
* en:
* Verify now, if the power of 2
is contained in the set of flags, too.
* Is the power
of 2 within the set of flags, then the OR-condition is fulfilled.
*/ if
(isSingularFlagInFlagSet(parmFlagSet,
intPowerOf2)) return
true; }/* de:
Nächst-höhere Potenz von 2 berechnen.
* en:
Calculate the next higher power of 2. */ intPowerOf2
= intPowerOf2 * 2;/* de:
* Prüfen, ob die Potenz von 2 bereits größer
ist als der Wert im Parameter.
* In diesem Fall sind
alle 'Merker' (Flags) überprüft und keiner im Set
enthalten.
* en:
* Verify if the power
of 2 is already larger than the value passed in the parameter.
* In
that case all flags are checked and none contained within the set.
*/ if
(intPowerOf2
> parmFlagsToBeChecked) return
false; } }
/* de:
* Wrapper-Methode
für ein Array mit den zu prüfenden 'Merkern' (Flags).
* en:
* Wrapper-method for an array with
the flags to be checked. */ public
static boolean areFlagsInFlagSet_OR(long
parmFlagSet,
long[]
parmFlagsToBeChecked) {/* de:
Array in eine einzelne Zahl umwandeln und die vorige Methode
aufrufen.
* en: Convert the array into a singular
number and call the method above. */ return
areFlagsInFlagSet_OR(parmFlagSet,
convertArray(parmFlagsToBeChecked)); }/*
*
**************************************************
*/
/* de:
* Methode zum Hinzufügen von
'Merkern' (Flag), die im Parameter
'parmFlagsToBeChecked'
* übergeben werden, zum Set
der 'Merker' (im Parameter 'parmFlagSet' übergeben).
* en:
* Method to add flags, that are
passed within the parameter 'parmFlagsToBeChecked',
* to
the set of flags (passed in the parameter 'parmFlagSet').
*/ public
static void addFlagsToFlagSet(long
parmFlagSet,
long
parmFlagsToBeAdded)
{/* de:
Variable zum Erzeugen der Potenzen von 2.
* en:
Variable to produce the powers of 2. */ long
intPowerOf2
= 1;/* de:
* for-Schleife zum Prüfen ob die Potenz von 2
sowohl in den hinzu zu fügenden 'Merkern'
* (Flags)
als auch im Set der 'Merker' enthalten ist.
* en:
* for-loop to verify if the power of 2 is contained
within the flags to be added and
* within the set of
flags, too. */ for
(;;)
{/* de:
* Zuerst prüfen, ob die Potenz von 2 in den hinzu
zu fügenden 'Merkern' enthalten ist.
* en:
* Verify first, if the power of 2 is contained within
the flags to be added. */ if
(isSingularFlagInFlagSet(parmFlagsToBeAdded,
intPowerOf2)) {/* de:
* Jetzt prüfen, ob die Potenz von 2 nicht im Set
der 'Merker' (Flags) enthalten ist.
* Ist die Potenz
von 2 nicht im Set enthalten, dann wird die Potenz von 2 zum Wert,
* der das Set repräsentiert, addiert.
* en:
* Verify now, if the power of 2 is not contained in
the set of flags.
* Is the power of 2 not within the
set of flags, then the power of 2 is added
* to the
value that represents the set. */ if
(!
isSingularFlagInFlagSet(parmFlagSet,
intPowerOf2))
parmFlagSet
+= intPowerOf2; }/* de:
Nächst-höhere Potenz von 2 berechnen.
* en:
Calculate the next higher power of 2. */ intPowerOf2
= intPowerOf2 * 2;/* de:
* Prüfen, ob die Potenz von 2 bereits größer
ist als der Wert im Parameter.
* In diesem Fall sind
alle 'Merker' (Flags) überprüft und wenn notwendig zum Set
addiert.
* en:
* Verify if the power of
2 is already larger than the value passed in the parameter.
* In
that case all flags are checked and - if neccessary – added to
the set. */ if
(intPowerOf2
> parmFlagsToBeAdded)
return; } }
/* de:
* Wrapper-Methode
für ein Array mit den zu prüfenden 'Merkern' (Flags).
* en:
* Wrapper-method for an array with
the flags to be checked. */ public
static void addFlagsToFlagSet(long
parmFlagSet,
long[]
parmFlagsToBeAdded) {/* de:
Array in eine einzelne Zahl umwandeln und die vorige Methode
aufrufen.
* en: Convert the array into a singular
number and call the method above.
*/ addFlagsToFlagSet(parmFlagSet,
convertArray(parmFlagsToBeAdded)); }/*
*
**************************************************
*/
/* de:
* Methode zum Entfernen von 'Merkern'
(Flag), die im Parameter 'parmFlagsToBeChecked'
* übergeben
werden, aus dem Set der 'Merker' (im Parameter 'parmFlagSet'
übergeben).
* en:
* Method to
remove flags, that are passed within the parameter
'parmFlagsToBeChecked',
* from the set of flags
(passed in the parameter 'parmFlagSet'). */ public
static void removeFlagsFromFlagSet(long
parmFlagSet,
long
parmFlagsToBeRemoved)
{/* de:
Variable zum Erzeugen der Potenzen von 2.
* en:
Variable to produce the powers of 2. */ long
intPowerOf2
= 1;/* de:
* for-Schleife zum Prüfen ob die Potenz von 2
sowohl in den zu entfernenden 'Merkern'
* (Flags) als
auch im Set der 'Merker' enthalten ist.
* en:
* for-loop to verify if the power of 2 is contained
within the flags to be removed and
* within the set of
flags, too. */ for
(;;)
{/* de:
* Zuerst prüfen, ob die Potenz von 2 in den zu
entfernenden 'Merkern' enthalten ist.
* en:
* Verify
first, if the power of 2 is contained within the flags to be removed.
*/ if
(isSingularFlagInFlagSet(parmFlagsToBeRemoved,
intPowerOf2)) {/* de:
* Jetzt prüfen, ob die Potenz von 2 im Set der
'Merker' (Flags) enthalten ist.
* Ist die Potenz von 2
im Set enthalten, dann wird die Potenz von 2 vom Wert,
* der
das Set repräsentiert, subtrahiert.
* en:
* Verify now, if the power of 2 is contained in the
set of flags.
* Is the power of 2 within the set of
flags, then the power of 2 is subtracteded
* from the
value that represents the set. */ if
(isSingularFlagInFlagSet(parmFlagSet,
intPowerOf2))
parmFlagSet
-= intPowerOf2; }/* de:
Nächst-höhere Potenz von 2 berechnen.
* en:
Calculate the next higher power of 2. */ intPowerOf2
= intPowerOf2 * 2;/* de:
* Prüfen, ob die Potenz von 2 bereits größer
ist als der Wert im Parameter.
* In diesem Fall sind
alle 'Merker' (Flags) überprüft und wenn notwendig vom Set
entfernt.
* en:
* Verify if the power
of 2 is already larger than the value passed in the parameter.
* In
that case all flags are checked and – if neccessary - removed
from the set. */ if
(intPowerOf2
> parmFlagsToBeRemoved)
return; } }
/* de:
* Wrapper-Methode
für ein Array mit den zu prüfenden 'Merkern' (Flags).
* en:
* Wrapper-method for an array with
the flags to be checked. */ public
static void removeFlagsFromFlagSet(long
parmFlagSet,
long[]
parmFlagsToBeRemoved) {/* de:
Array in eine einzelne Zahl umwandeln und die vorige Methode
aufrufen.
* en: Convert the array into a singular
number and call the method above.
*/ removeFlagsFromFlagSet(parmFlagSet,
convertArray(parmFlagsToBeRemoved)); }
}
Der
folgende Muster-Code repräsentiert eine Klasse die für ein
Anwendungsprogramm verwendet werden kann und die in diesem Dokument
beschriebenen Klasse erbt.
In der erbenden Klasse werden für
die einzelnen 'Merker' (Flags) konstante Werte mit sprechenden Namen
definiert.
Die
Variable für das Set der 'Merker' (Flags) kann in einer anderen
Klasse definiert werden weil dieser Wert als Variable an die Methoden
der geerbten Klasse übergeben werden kann.
Alternativ kann in
dieser Klasse – wenn von der Spezifikation des
Anwendungsprogramms gefordert – auch eine Variable für das
Set der 'Merker' (Flags) definiert werden. Wird diese Variable
definiert muss die Klasse auch innerhalb einer weiteren Klasse des
Anwendungsprogramms 'konstruiert' werden.
package
application_package.client;/*
*
Packages mit der Basisklasse. */import
js_base.utilities.JSBS_FlagSet;/**
*
* @author
name[at]company
* @date
20xx-xx-xx
*
* @description
* de:
* Klasse,
die die Basisklasse JSBS_FlagSet erbt und in der die konkreten Werte
der 'Merker' (Flags)
* implementiert
sind.
* Die statischen Methoden zur Bildung und
Verwaltung von Sets mit binären Werten (Merker / Flags)
* sind
in der Basisklasse JSBS_FlagSet implementiert.
* Die
in dieser Klasse festgelegten 'Merker' sind Potenzen von 2 (1, 2, 4,
8, 16, . . . .)
* und repräsentieren
jeweils die Werte 'Ja' oder
'Nein'.
* -------------------
* en:
* Class
that inherits the base-class JSBS_FlagSet and that implements the
values of the flags.
* The static methods to
create and administrate sets with binary values (Flags) are
implemented
* in the base-class
JSBS_FlagSet.
* The flags defined within this
class are powers of 2 (1, 2, 4, 8, 16, . . . .) and represent the
* values 'Yes' or 'No', respectively.
*
* @change-log
* when who why
* -----------------------------------------------------------------
*
*/public
class
application_task_ApplicationFlagSet
extends
JSBS_FlagSet
{/*
* de:
* Bei Bedarf kann hier die
Variable für das Set definiert werden.
* In diesem
Fall muss diese Klasse 'konstruiert' werden.
* en:
* If
reqziered, the variable for the Set can be define here.
* In
that case, this calss has to be 'constructed'. */// public
long
FlagSetName
=
0;/*
* de:
* Liste der einzelnen 'Merker'
(Flags) und deren Bedeutung.
* en:
* List
of the singular flags and their meaning. */
public
static long
CONST_FLAG_Set_Flagname
=
2^0; // Bedeutung
/
Meaning
public
static long
CONST_FLAG_Set_Flagname
=
2^1; // Bedeutung
/ Meaning
public
static long
CONST_FLAG_Set_Flagname
=
2^2; // Bedeutung
/ Meaning
public
static long
CONST_FLAG_Set_Flagname
=
2^3; // Bedeutung
/ Meaning
public
static long
CONST_FLAG_Set_Flagname
=
2^4; // Bedeutung
/ Meaning
public
static long
CONST_FLAG_Set_Flagname
=
2^5; // Bedeutung
/ Meaning
public
static long
CONST_FLAG_Set_Flagname
=
2^6; // Bedeutung
/ Meaning
public
static long
CONST_FLAG_Set_Flagname
=
2^7; // Bedeutung
/ Meaning
public
static long
CONST_FLAG_Set_Flagname
=
2^8; // Bedeutung
/ Meaning/*
* de:
* Bei Bedarf können weitere
Sets in dieser Klasse definiert werden.
* en:
* Additional
sets might be defined if needed. */
}
Die
Basisklasse und das Muster für die Anwendungs-spezifische Klasse
wurden ursprünglich entwickelt, um zu steuern, wie weitere
Attributswerte oder ganze BO zu einem BO gemischt werden können.
Ein Code-Muster für das Mischen ist unter Muster-Code
für ein BOS (Server-Side-Klasse eines Business-Object) >
Spezieller Muster Code > Lesen von Attributswerten von anderen
Datenbank-Tabellen – Methode mergeVariablexy
beschrieben.
Die
einfachste Methode ein Set von 'Merkern' zu bilden ist das Definieren
einer Variable und das Zuweisen von Werten zu dieser Variable.
Das
wird üblicherweise in der Klasse für den 'ActionHandler'
eines Teilprogramms für die Abwicklung von Geschäftsfällen
vor der Selektion der Werte eines BO erfolgen: long
FlagSetName
=
application_task_ApplicationFlagSet.CONST_FLAG_Set_Flagname1
+
application_task_ApplicationFlagSet.CONST_FLAG_Set_Flagname2;
Das
obige Code-Muster hat keinen Schutz davor, dass ein konstanter Wert
mehrmals addiert wird. Durch mehrmaliges Addieren kann ein falscher
'Merker' innerhalb des Sets mit den 'Merkern' entstehen.
Ein
Verfahren, bei dem ein mehrmaliges Addieren eines 'Merkers'
verhindert wird ist folgender Code: long
FlagSetName
=
0; application_task_ApplicationFlagSet.addFlagsToFlagSet(FlagSetName,
application_task_ApplicationFlagSet.CONST_FLAG_Set_Flagname1); application_task_ApplicationFlagSet.addFlagsToFlagSet(FlagSetName,
application_task_ApplicationFlagSet.CONST_FLAG_Set_Flagname2);
Zu
Beginn jener Methode, in der weiter Attributswerte oder BO zu einem
BO gemischt werden, kann folgende Abfrage platziert werden:
public
void
mergeVariablexy(long
parmFlagSetName)
{/*
* de:
* Prüfen, ob das
'Dazumischen' überhaupt gefordert wird.
* en:
* Verify
if the merge is requested anyway. */ if
(!
application_task_ApplicationFlagSet.areFlagsInFlagSet(parmFlagSetName,
application_task_ApplicationFlagSet.CONST_FLAG_Set_Flagname1))
return;
|
Dokument |
Inhalt |
|
Dieser
Leitfaden enthält die notwendigen Tätigkeiten für
die Entwicklung eines StartFrame (auch als Command-Center
bekannt). |