GlobalObjects-Projektdatei
Diese Datei wird vom GloDeveloper genutzt um GlobalObjects-Projekte zu verwalten.
################################################################################
[Project]
Description=Das ist mein erstes GlobalObjects-Projekt.
################################################################################
[Schema.FirstGloBase]
Schemapath=D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/
Headerpath=D:/Projekte/GlobalObects xx.xx/GloExamples/include/
Sourcepath=D:/Projekte/GlobalObects xx.xx/GloExamples/source/
################################################################################
GlobalObjects-Schemadatei (Ini)
GlobalObjects braucht für jede Objektdatenbank ein Schema, um aus Objektdateien C++ Objekte und aus C++ Objekten Objektdateien bauen zu können. Eine Objektdatenbank wird durch dieses Schema definiert (ist eine einfache Textdatei). Wenn z.B. die Schemadatei in einem Verzeichnis "D:/Projekte/GlobalObects xx.xx/GloExamples/Bases" gespeichert ist, sind die Objektdateien in einem dortigen Unterverzeichnis gespeichert; die Bezeichnung Unterverzeichnisses wird in der Schemadatei festgelegt. Die Bezeichnung des Schemas ist die Bezeichnung der Objektdatenbank.
################################################################################
[BaseInfo]
# Database ID to distinguish classes with same class ID.
ID=0
# The version is the creation time as C++ Type time_t.
# Used to compare server schema to client schema.
Version=1610967417
Description=
# The data is located in this subdirectory in the schema directory.
DataPath=FirstGloBase
################################################################################
[Class.glo::Persistent]
ClassID=1
SuperClassID=0|
ClassFileName=GloPersistent.h
[glo::Persistent.Attribute.m_ObjID]
Table=FirstGloBase
FieldPos=0
Field=ObjID
AccessControl=private:
Type=glo::ObjId
TypeInfo=
Description=
[glo::Persistent.Attribute.m_dtCreateDate]
Table=FirstGloBase
FieldPos=1
Field=CreateDate
AccessControl=private:
Type=std::time_t
TypeInfo=
Description=
[glo::Persistent.Attribute.m_dtLastChange]
Table=FirstGloBase
FieldPos=2
Field=LastChange
AccessControl=private:
Type=std::time_t
TypeInfo=
Description=
################################################################################
[Class.FirstClass]
ClassID=2
SuperClassID=1|
SuperClassInfo= |
ClassFileName=FirstClass.h
[FirstClass.Attribute.m_ObjID]
Table=FirstClass
FieldPos=0
Field=ObjID
AccessControl=private:
Type=glo::ObjId
TypeInfo=
Description=
[FirstClass.Attribute.FirstAttribute]
Table=FirstClass
FieldPos=1
Field=FirstAttribute
AccessControl=private:
Type=int
TypeInfo=
Description=
################################################################################
GlobalObjects-Schema Basisinformationen
Zwei Schlüssel-Wert-Paare unter der Sektion [BaseInfo] sind obligatorisch.
Der Schlüssel Version hat als Wert eine Zahl welche den Erstellungszeitpunkt als C++ Typ time_t darstellt. Wird benötigt, damit ein Vergleich zwischen Client und Server gewährleistet ist und beide mit dem gleichen GlobalObjects-Schema arbeiten.
Der Wert des Schlüssels DataPath ist die Bezeichnung des Unterverzeichnisses, in dem die GlobalObjects-Objektdateien untergebracht sind.
Das Schema kann eine ID haben, welche als Objektdatenbank-ID in glo::ObjID::m_ulBaseID übernommen wird. Das ermöglicht das gleichzeitige agieren mit mehreren Objektdatenbanken, welche Objekte mit gleichen Klasssen-IDs verwalten. Bedingt aber, dass diese ID global eindeutig ist.
Beispiel:
[BaseInfo]
ID=1
Version=1461586766
DataPath=FirstGloBase
GlobalObjects-Schema Klassendefinition
Klassen werden in Sektionen dargestellt.
Für eine Klasse FirstClass würde als solches eine Sektion [Class.FirstClass] angelegt werden. Eine Klassen-Sektion ist immer in eckigen Klammern und der Klassenbezeichnung ist ein Class. vorangestellt.
Folgende Schlüssel-Wert-Paare sind obligatorisch:
-
ClassID Die Klassen-ID als Ganzzahlwert muss eindeutig im Schema sein. Die Basisklasse glo::Persistent, welche in jedem Schema aufgeführt sein muss, hat immer die Klassen-ID 1.
-
SuperClassID Die Klassen-ID der direkten Oberklasse abgeschlossen mit '|'. Bei Mehrfachvererbung kann der Wert z.B. "1|3|" sein.
Folgende Schlüssel-Wert-Paare sind obtional:
-
SuperClassInfo Um eine sogenannte Diamant-Vererbung zu gewährleisten, kann hier zum Beispiel der Wert virtual für eine Vererbung eingetragen werden.
-
FileDescription Eine Dateibeschreibung kann hier abgelegt werden. Zeilenumbrüche müssen mit '\n' gekennzeichnet sein. Wird vom GloDeveloper genutzt, um die Headerdatei z.B. im doxygen-Standard zu beschreiben.
-
ClassDescription Eine Klassenbeschreibung kann hier abgelegt werden. Zeilenumbrüche müssen mit '\n' gekennzeichnet sein. Wird vom GloDeveloper genutzt, um in der Headerdatei die Klasse z.B. im doxygen-Standard zu beschreiben.
Beispiel:
[Class.FirstClass]
ClassID=2
SuperClassID=1|
SuperClassInfo= |
FileDescription=Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
ClassDescription=Aenean commodo ligula eget dolor.
GlobalObjects-Schema Attributdefinition
Attribute werden in Sektionen dargestellt, welche ausschließlich unter jeweiligen Klassendefinition stehen müssen. Es darf eine Attributdefinition einer Klasse nicht unter einer Klassendefinition einer anderen Klasse stehen. Die Reihenfolge der Attributdefinitionen unter der Klassendefinition ist wahlfrei.
Für ein Attribut FirstAttribute der Klasse FirstClass würde als solches eine Sektion unter deren Klassendefinition als [FirstClass.Attribute.FirstAttribute] angelegt werden. Eine Attribut-Sektion ist immer in eckigen Klammern und der Attributbezeichnung ist die jeweilige Klassenbezeichnung abgeschlossen mit einem '.' und der Kennzeichnung Attribute. vorangestellt.
Folgende Schlüssel-Wert-Paare sind obligatorisch:
-
Table Die Tabellenbezeichnung in welcher der Wert dieses Attributes gespeichert wird.
- Achtung
- Es wird vorausgesetzt, dass die Tabellenbezeichnung für alle Attribute einer Klasse die gleiche ist.
-
FieldPos Der Wert dieses Attributs wird in der Tabelle an der angegebenen Spalten-Position gespeichert (Start bei 0).
-
Field Die Tabellenfeld-Bezeichnung, darf von der Attributbezeichnung abweichen.
-
Type Das ist der unterstützte Attributtyp. Siehe auch glo::SchemaTypeString.
Folgende Schlüssel-Wert-Paare sind obtional:
-
TypeInfo Je nach unterstützten Attributtyp eine Information. Siehe auch glo::EnDataTypeGroup.
-
Description Eine Attributbeschreibung kann hier abgelegt werden. Zeilenumbrüche müssen mit '\n' gekennzeichnet sein. Wird vom GloDeveloper genutzt, um in der Headerdatei das Attribut z.B. im doxygen-Standard zu beschreiben.
-
AccessControl Hier kann der Zugriff auf das Attribut angegeben werden (private:, protected: oder public:). Wird vom GloDeveloper genutzt, um in der Headerdatei das Attribut mit dem Zugriffs-Schlüsselword zu kennzeichnen.
- Achtung
- Das Zugriffs-Schlüsselwort ist immer mit abschließenden Doppelpunkt anzugeben.
Beispiel:
[FirstClass.Attribute.FirstAttribute]
Table=FirstClass
FieldPos=1
Field=FirstAttribute
AccessControl=private:
Type=int
TypeInfo=
Description=Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
GlobalObjects-Schema Indexdefinition
Um in Tabellen Objekte schnell über einen Index suchen zu können, kann eine Index-Sektion angelegt werden. Ein Index kann aus mehreren Attributen bestehen (z.B. Nach- und Vorname).
Ein Index ist immer so aufgebaut: "Klassenbezeichnung.Attributbezeichnung[20]|"
Die Klassenbezeichnung muss immer die der Klasse bzw. Oberklasse der zu indizierenden Klasse sein. Die Attributbezeichnung ist das Attribut, welches im Index mit der in eckigen Klammern angebenen Anzahl von Zeichen genutzt wird.
Unterstützte Index-Attributtypen:
-
char
-
unsigned char
-
short
-
unsigned short
-
int
-
unsigned int
-
long
-
unsigned long
-
long long
-
unsigned long long
-
float
-
double
-
long double
-
glo::ObjID
-
time_t
-
std::string
Attributtypen die als Pfad zu einem Index-Attribut genutzt werden können:
-
Eingebettete persistente Objekte
-
Mittels Zeiger referenzierte persistente Objekte
-
Mittels std::shared_ptr referenzierte persistente Objekte
Folgende Schlüssel-Wert-Paare sind obligatorisch:
-
Index Der Aufbau des Index wie oben beschrieben.
-
CaseSensitive Wenn 1, wird im Index Groß- Kleinschreibung nicht unterschieden ("Meier" ist gleich "MEieR"). Wenn 0, wird im Index Groß- Kleinschreibung unterschieden ("Meier" ist ungleich "MEieR").
Folgende Schlüssel-Wert-Paare sind obtional:
-
Type Kann auf unique gesetzt werden.
-
Language Kann auf ein Länderkürzel gesetzt werden. Es werden dann z.B. bei 'de' die Umlaute und das 'ß' nach DIN 5007 Variante 2 gewandelt.
-
Description Eine Indexbeschreibung kann hier abgelegt werden. Zeilenumbrüche müssen mit '\n' gekennzeichnet sein. Wird vom GloDeveloper genutzt.
-
Delimiter Wenn der Index aus mehreren Attributen zusammengesetzt ist, können die Index-Werte entweder einfach (Delimiter=0) oder, getrennt durch ein Zeichen (Delimiter=1), zusammengesetzt im Index abgelegt werden. Weitere Informationen unter GlobalObjects Indexe.
Beispiel:
[FirstClass.Index.FirstIndex]
Index=FirstClass.FirstAttribute[20]|
Type=unique
Language=de
CaseSensitive=0
Delimiter=0
Description=
Eine kommentierte Beispiel-Schemadatei kann hier angesehen werden.
Schemadatei (Ini) mit allen unterstützten Attributen
Eine kommentierte Beispiel-Schemadatei in der die Klasse ExampleClass allen unterstützten Attributtypen hat.
################################################################################
[BaseInfo]
# Database ID to distinguish classes with same class ID.
ID=2
# The version is the creation time as C++ Type time_t.
# Used to compare server schema to client schema.
Version=1553076866
Description=
# The data is located in this subdirectory in the schema directory.
DataPath=SchemaExampleData
################################################################################
[Class.GloPersistent]
ClassID=1
SuperClassID=0|
ClassFileName=GloPersistent.h
[GloPersistent.Attribute.m_ObjID]
Table=SchemaExample
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[GloPersistent.Attribute.m_dtCreateDate]
Table=SchemaExample
FieldPos=1
Field=CreateDate
AccessControl=private:
Type=std::time_t
TypeInfo=
Description=
[GloPersistent.Attribute.m_dtLastChange]
Table=SchemaExample
FieldPos=2
Field=LastChange
AccessControl=private:
Type=std::time_t
TypeInfo=
Description=
################################################################################
[Class.ExampleClass]
ClassID=2
SuperClassID=1|
SuperClassInfo= |
ClassFileName=ExampleClass.h
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @CurrentDate - @CurrentTime\n\copyright © @UserGroupName\n\autor @UserName
ClassDescription=Eine Beispielklasse mit allen unterstützten Attributtypen.\n\copyright © @UserGroupName\n\autor @UserName
ClassModifier=__GLO_EXPORT_DLL
[ExampleClass.Attribute.m_ObjID]
Table=ExampleClass
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=Die Objekt-ID ist die eindeutige Identifikationsnummer eines persistenten Objektes, ist in jeder Tabelle der Hauptindex.
[ExampleClass.Attribute.m_MyBlob]
Table=ExampleClass
FieldPos=1
Field=m_MyBlob
AccessControl=private:
Type=EuBlob
TypeInfo=
Description=Ein Blob wird als Datei gespeichert. In der Datenbank wird der generierte\nDateiname festgehalten.
[ExampleClass.Attribute.m_MyBool]
Table=ExampleClass
FieldPos=2
Field=m_MyBool
AccessControl=public:
Type=bool
TypeInfo=
Description=1 Zeichen in der Datenbank (true => 1, false => 0).
[ExampleClass.Attribute.m_MyChar]
Table=ExampleClass
FieldPos=3
Field=m_MyChar
AccessControl=private:
Type=char
TypeInfo=
Description=Wird als maximal dreistellige Dezimalzahl gespeichert ('A' => 65, 'x' => 120 ).
[ExampleClass.Attribute.m_MyDateTime]
Table=ExampleClass
FieldPos=19
Field=m_MyDateTime
AccessControl=private:
Type=std::time_t
TypeInfo=
Description=Wird als unsigned long gespeichert.
[ExampleClass.Attribute.m_MyDouble]
Table=ExampleClass
FieldPos=13
Field=m_MyDouble
AccessControl=private:
Type=double
TypeInfo=
Description=Wird als 'scientific' abgespeichert (z.B. 1.234000e+001 für 12.34)
[ExampleClass.Attribute.m_MyDouble_2]
Table=ExampleClass
FieldPos=14
Field=m_MyDouble_2
AccessControl=private:
Type=double
TypeInfo=2
Description=Wird wegen TypeInfo = 2 mit zwei Nachkommastellen abgespeichert (z.B. 12.34 für 12.336)
[ExampleClass.Attribute.m_MyEmbedded]
Table=ExampleClass
FieldPos=20
Field=m_MyEmbedded
AccessControl=private:
Type=embedded<ExampleEmbeddedClass>
TypeInfo=
Description=Es wird vom eingebetteten persistenten Objekt die Objekt-ID gespeichert.
[ExampleClass.Attribute.m_MyInteger]
Table=ExampleClass
FieldPos=7
Field=m_MyInteger
AccessControl=private:
Type=int
TypeInfo=
Description=Wird als solches mit Vorzeichen gespeichert.
[ExampleClass.Attribute.m_MyUnsignedInteger]
Table=ExampleClass
FieldPos=8
Field=m_MyUnsignedInteger
AccessControl=private:
Type=int
TypeInfo=unsigned
Description=Wird als solches ohne Vorzeichen gespeichert.
[ExampleClass.Attribute.m_MyDoubleList]
Table=ExampleClass
FieldPos=21
Field=m_MyDoubleList
AccessControl=private:
Type=std::list<double>
TypeInfo=
Description=Es werden die Double-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyIntegerList]
Table=ExampleClass
FieldPos=22
Field=m_MyIntegerList
AccessControl=private:
Type=std::list<int>
TypeInfo=
Description=Es werden die Integer-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyStringList]
Table=ExampleClass
FieldPos=23
Field=m_MyStringList
AccessControl=private:
Type=std::list<std::string>
TypeInfo=
Description=Es werden die String-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyLongInteger]
Table=ExampleClass
FieldPos=9
Field=m_MyLongInteger
AccessControl=private:
Type=long
TypeInfo=
Description=Wird als solches mit Vorzeichen gespeichert.
[ExampleClass.Attribute.m_MyUnsignedLongInteger]
Table=ExampleClass
FieldPos=10
Field=m_MyUnsignedLongInteger
AccessControl=private:
Type=long
TypeInfo=unsigned
Description=Wird als solches ohne Vorzeichen gespeichert.
[ExampleClass.Attribute.m_MyOndemandReference]
Table=ExampleClass
FieldPos=24
Field=m_MyOndemandReference
AccessControl=private:
Type=GloTOndemand<ExampleReferenceClass>
TypeInfo=
Description=Es wird vom 'auf Nachfrage referenzierten' persistenten Objekt die GloObjID gespeichert.
[ExampleClass.Attribute.m_MyOndemandDependReference]
Table=ExampleClass
FieldPos=25
Field=m_MyOndemandDependReference
AccessControl=private:
Type=GloTOndemand<ExampleReferenceClass>
TypeInfo=dependent
Description=Es wird vom 'auf Nachfrage referenzierten' persistenten Objekt die GloObjID gespeichert. Durch die TypInfo 'dependent' wird das referenzierte Objekt i.d.R. mitgespeichert, mitgelöscht, mitgelockt etc..
[ExampleClass.Attribute.m_MyPointerReference]
Table=ExampleClass
FieldPos=26
Field=m_MyPointerReference
AccessControl=private:
Type=pointer<ExampleReferenceClass>
TypeInfo=
Description=Es wird vom 'direkt mit Pointer referenzierten' persistenten Objekt die GloObjID gespeichert.
[ExampleClass.Attribute.m_MyPointerDependReference]
Table=ExampleClass
FieldPos=27
Field=m_MyPointerDependReference
AccessControl=private:
Type=pointer<ExampleReferenceClass>
TypeInfo=dependent
Description=Es wird vom 'direkt mit Pointer referenzierten' persistenten Objekt die GloObjID gespeichert. Durch die TypInfo 'dependent' wird das referenzierte Objekt i.d.R. mitgespeichert, mitgelöscht, mitgelockt etc..
[ExampleClass.Attribute.m_MyOndemandRefSet]
Table=ExampleClass
FieldPos=28
Field=m_MyOndemandRefSet
AccessControl=private:
Type=GloTOndemandSet<ExampleReferenceClass>
TypeInfo=
Description=Es werden die GloObjID's von den 'auf Nachfrage referenzierten' persistenten Objekten in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyOndemandDependRefSet]
Table=ExampleClass
FieldPos=29
Field=m_MyOndemandDependRefSet
AccessControl=private:
Type=GloTOndemandSet<ExampleReferenceClass>
TypeInfo=dependent
Description=Es werden die GloObjID's von den 'auf Nachfrage referenzierten' persistenten Objekten in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten. Durch die TypInfo 'dependent' werden die referenzierten Objekte i.d.R. mitgespeichert, mitgelöscht, mitgelockt etc..
[ExampleClass.Attribute.m_MyStdSharedPointer]
Table=ExampleClass
FieldPos=30
Field=m_MyStdSharedPointer
AccessControl=private:
Type=std::shared_ptr<ExampleReferenceClass>
TypeInfo=
Description=
[ExampleClass.Attribute.m_MyStdSharedDependPointer]
Table=ExampleClass
FieldPos=31
Field=m_MyStdSharedDependPointer
AccessControl=private:
Type=std::shared_ptr<ExampleReferenceClass>
TypeInfo=dependent
Description=
[ExampleClass.Attribute.m_MyPointerRefSet]
Table=ExampleClass
FieldPos=32
Field=m_MyPointerRefSet
AccessControl=private:
Type=GloTPointerSet<ExampleReferenceClass>
TypeInfo=
Description=Es werden die GloObjID's von den 'direkt mit Pointer referenzierten' persistenten Objekten in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyPointerDependeRefSet]
Table=ExampleClass
FieldPos=33
Field=m_MyPointerDependeRefSet
AccessControl=private:
Type=GloTPointerSet<ExampleReferenceClass>
TypeInfo=dependent
Description=Es werden die GloObjID's von den 'direkt mit Pointer referenzierten' persistenten Objekten in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten. Durch die TypInfo 'dependent' werden die referenzierten Objekte i.d.R. mitgespeichert, mitgelöscht, mitgelockt etc..
[ExampleClass.Attribute.m_MyDoubleSet]
Table=ExampleClass
FieldPos=34
Field=m_MyDoubleSet
AccessControl=private:
Type=std::set<double>
TypeInfo=
Description=Es werden die Double-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyIntegerSet]
Table=ExampleClass
FieldPos=35
Field=m_MyIntegerSet
AccessControl=private:
Type=std::set<int>
TypeInfo=
Description=Es werden die Integer-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyStringSet]
Table=ExampleClass
FieldPos=36
Field=m_MyStringSet
AccessControl=private:
Type=std::set<std::string>
TypeInfo=
Description=Es werden die String-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyShortInteger]
Table=ExampleClass
FieldPos=5
Field=m_MyShortInteger
AccessControl=private:
Type=short
TypeInfo=
Description=Wird als solches mit Vorzeichen gespeichert.
[ExampleClass.Attribute.m_MyUnsignedShortInteger]
Table=ExampleClass
FieldPos=6
Field=m_MyUnsignedShortInteger
AccessControl=private:
Type=short
TypeInfo=unsigned
Description=Wird als solches ohne Vorzeichen gespeichert.
[ExampleClass.Attribute.m_MyString]
Table=ExampleClass
FieldPos=17
Field=m_MyString
AccessControl=private:
Type=std::string
TypeInfo=
Description=Zeichenkette mit der maximal systemspezifischen Anzahl von Zeichen wird, wenn möglich direkt in der Datenbank gespeicher. Wenn zu lang, wird der String-Wert in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyString20]
Table=ExampleClass
FieldPos=18
Field=m_MyString20
AccessControl=private:
Type=std::string
TypeInfo=20
Description=Zeichenkette mit der maximalen Anzahl von 20 Zeichen wird, wenn möglich direkt in der Datenbank gespeicher. Wenn zu lang, wird der String-Wert in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyDoubleVector]
Table=ExampleClass
FieldPos=37
Field=m_MyDoubleVector
AccessControl=private:
Type=std::vector<double>
TypeInfo=
Description=Es werden die Double-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyIntegerVector]
Table=ExampleClass
FieldPos=38
Field=m_MyIntegerVector
AccessControl=private:
Type=std::vector<int>
TypeInfo=
Description=Es werden die Integer-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyStringVector]
Table=ExampleClass
FieldPos=39
Field=m_MyStringVector
AccessControl=private:
Type=std::vector<std::string>
TypeInfo=
Description=Es werden die String-Werte in einer Datei gespeichert. In der Datenbank wird der generierte Dateiname festgehalten.
[ExampleClass.Attribute.m_MyGloObjID]
Table=ExampleClass
FieldPos=40
Field=m_MyGloObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[ExampleClass.Attribute.m_MyLongLong]
Table=ExampleClass
FieldPos=11
Field=m_MyLongLong
AccessControl=private:
Type=long long
TypeInfo=
Description=
[ExampleClass.Attribute.m_MyUnsignedLongLong]
Table=ExampleClass
FieldPos=12
Field=m_MyUnsignedLongLong
AccessControl=private:
Type=long long
TypeInfo=unsigned
Description=
[ExampleClass.Attribute.m_MyUnsignedChar]
Table=ExampleClass
FieldPos=4
Field=m_MyUnsignedChar
AccessControl=private:
Type=char
TypeInfo=unsigned
Description=
[ExampleClass.Attribute.m_MyLongDouble]
Table=ExampleClass
FieldPos=15
Field=m_MyLongDouble
AccessControl=private:
Type=long double
TypeInfo=
Description=
[ExampleClass.Attribute.m_MyLongDouble_2]
Table=ExampleClass
FieldPos=16
Field=m_MyLongDouble_2
AccessControl=private:
Type=long double
TypeInfo=2
Description=
[ExampleClass.Attribute.m_MyFloat]
Table=ExampleClass
FieldPos=41
Field=m_MyFloat
AccessControl=private:
Type=float
TypeInfo=0
Description=
[ExampleClass.Index.FirstIndex]
Index=ExampleClass.m_MyString[10]|ExampleClass.m_MyString20[20]|
Type=
Language=2
CaseSensitive=0
Delimiter=0
Description=Description=Index mit zwei Attributen die einfacch in einen Indexstring zusammengezogen werden.
################################################################################
[Class.ExampleEmbeddedClass]
ClassID=3
SuperClassID=1|
SuperClassInfo= |
ClassFileName=ExampleEmbeddedClass.h
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @CurrentDate - @CurrentTime\n\copyright © @UserGroupName\n\autor @UserName
ClassDescription=\copyright © @UserGroupName\n\autor @UserName
[ExampleEmbeddedClass.Attribute.m_ObjID]
Table=ExampleEmbedetClass
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[ExampleEmbeddedClass.Attribute.m_MyValue]
Table=ExampleEmbedetClass
FieldPos=1
Field=m_MyValue
AccessControl=private:
Type=int
TypeInfo=
Description=
################################################################################
[Class.ExampleReferenceClass]
ClassID=4
SuperClassID=1|
SuperClassInfo= |
ClassFileName=ExampleReferenceClass.h
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @CurrentDate - @CurrentTime\n\copyright © @UserGroupName\n\autor @UserName
ClassDescription=\copyright © @UserGroupName\n\autor @UserName
[ExampleReferenceClass.Attribute.m_ObjID]
Table=ExampleReferenceClass
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[ExampleReferenceClass.Attribute.m_MyValue]
Table=ExampleReferenceClass
FieldPos=1
Field=m_MyValue
AccessControl=private:
Type=int
TypeInfo=
Description=
################################################################################
[Class.ExampleBaseClass]
ClassID=5
SuperClassID=1|
SuperClassInfo=virtual|
ClassFileName=ExampleBaseClass.h
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @CurrentDate - @CurrentTime\n\copyright © @UserGroupName\n\autor @UserName
ClassDescription=\copyright © @UserGroupName\n\autor @UserName
[ExampleBaseClass.Attribute.m_ObjID]
Table=ExampleBaseClass
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[ExampleBaseClass.Attribute.m_iBaseValue]
Table=ExampleBaseClass
FieldPos=1
Field=m_iBaseValue
AccessControl=private:
Type=int
TypeInfo=
Description=
[ExampleBaseClass.Index.IDX]
Index=ExampleBaseClass.m_iBaseValue[11]|
Type=
Language=0
CaseSensitive=0
Delimiter=0
Description=
################################################################################
[Class.ExampleSubClass_1]
ClassID=6
SuperClassID=5|
SuperClassInfo= |
ClassFileName=ExampleSubClass_1.h
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @CurrentDate - @CurrentTime\n\copyright © @UserGroupName\n\autor @UserName
ClassDescription=\copyright © @UserGroupName\n\autor @UserName
[ExampleSubClass_1.Attribute.m_ObjID]
Table=ExampleSubClass_1
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[ExampleSubClass_1.Attribute.m_iSub1Value]
Table=ExampleSubClass_1
FieldPos=1
Field=m_iSub1Value
AccessControl=private:
Type=int
TypeInfo=
Description=
################################################################################
[Class.ExampleSubClass_2]
ClassID=7
SuperClassID=5|
SuperClassInfo=virtual|
ClassFileName=ExampleSubClass_2.h
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @CurrentDate - @CurrentTime\n\copyright © @UserGroupName\n\autor @UserName
ClassDescription=\copyright © @UserGroupName\n\autor @UserName
[ExampleSubClass_2.Attribute.m_ObjID]
Table=ExampleSubClass_2
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[ExampleSubClass_2.Attribute.m_iSub2Value]
Table=ExampleSubClass_2
FieldPos=1
Field=m_iSub2Value
AccessControl=private:
Type=int
TypeInfo=
Description=
################################################################################
[Class.ExampleMSubClass]
ClassID=8
SuperClassID=6|7|
SuperClassInfo= | |
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @CurrentDate - @CurrentTime\n\copyright © @UserGroupName\n\autor @UserName
ClassDescription=\copyright © @UserGroupName\n\autor @UserName
[ExampleMSubClass.Attribute.m_ObjID]
Table=ExampleMSubClass
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[ExampleMSubClass.Attribute.m_iMSubValue]
Table=ExampleMSubClass
FieldPos=1
Field=m_iMSubValue
AccessControl=private:
Type=int
TypeInfo=
Description=
################################################################################
[Class.ExampleIndexSubClass]
ClassID=9
SuperClassID=2|
SuperClassInfo= |
[ExampleIndexSubClass.Attribute.m_ObjID]
Table=ExampleIndexSubClass
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
################################################################################
DB.ini
Damit eine Applikation, die GlobalObjects nutzt, weiß wo die Objektdatenbanken zu finden sind, muss im Verzeichnis der Applikation eine "DB.ini" mit folgendem Aufbau gespeichert werden:
[Server]
KnownBases=FirstBase
BasePath=D:/Projekte/GlobalObects xx.xx/GloExamples/Bases
Zwei Schlüssel-Wert-Paare unter der Sektion [Server] sind obligatorisch.
Der Schlüssel KnownBases hat als Wert die Bezeichnung der GlobalObjects-Schemadatei.
Der Wert des Schlüssels BasePath ist die Bezeichnung des Verzeichnisses, in dem die GlobalObjects-Schemadatei und das zugehörige Datenbankverzeichnis untergebracht sind.
Wenn der GloServer eingesetzt wird, muss in dessen Verzeichnis eine "DB.ini" mit folgendem Aufbau gespeichert werden:
[Server]
Port=4000
TcpPackageSize=4096
TimeOutSec=5
KnownBases=FirstBase
BasePath=D:/Projekte/GlobalObects xx.xx/GloExamples/Bases
Schlüssel-Wert-Paare Port, TcpPackageSize und TimeOutSec sollten übernommen werden.
Objektersteller
Damit GlobalObjects aus der Objektdatenbank Objekte erstellen kann, wird eine Objektersteller-Klasse für jede Objektdatenbank benötigt, die weiß, welche Objekte einer Klassen-ID entsprechen und diese instanziieren kann. Die vom GloDeveloper generierte Objektersteller-Datei (z.B. "FirstBaseObjCreator.h") wird in das eigene Projekt eingebunden und sollte vom Nutzer nicht bearbeitet werden. Es werden vom Objektersteller alle persistenten Klassen der jeweiligen Objektdatenbank eingebunden.
#ifndef INC_FIRSTGLOBASEOBJCREATOR_H
#define INC_FIRSTGLOBASEOBJCREATOR_H
#include <EuException.h>
#include <GloTypes.h>
#include <GloObjCreator.h>
#include <GloTAllSet.h>
#include "FirstClass.h"
class FirstGloBaseObjCreator : public glo::ObjCreator
{
public:
const unsigned long ClassID_AllClasses = 0;
const unsigned long ClassID_glo__Persistent = 1;
const unsigned long ClassID_FirstClass = 2;
inline FirstGloBaseObjCreator();
inline virtual ~FirstGloBaseObjCreator();
inline virtual std::string getBaseName() const;
inline virtual bool isKnownClassID( unsigned long ulClassID ) const;
inline virtual int getPersObject( glo::Persistent *& prNewObject, unsigned long ulClassID ) const;
inline virtual unsigned long getClassID( glo::BaseAllSet * pAllSet ) const;
inline virtual ObjCreator * getCopy() const;
};
#define SUPER ObjCreator
FirstGloBaseObjCreator::FirstGloBaseObjCreator()
: SUPER()
{
}
FirstGloBaseObjCreator::~FirstGloBaseObjCreator()
{
}
inline std::string FirstGloBaseObjCreator::getBaseName() const
{
return "FirstGloBase";
}
inline bool FirstGloBaseObjCreator::isKnownClassID( unsigned long ulClassID ) const
{
if (
ulClassID ==1
||
ulClassID ==2
)
{
return true;
}
return false;
}
inline int FirstGloBaseObjCreator::getPersObject( glo::Persistent *& prNewObject, unsigned long ulClassID ) const
{
int t_iErr = 0;
glo::ObjID t_NewObjID( ulClassID, 0, 0 );
switch ( ulClassID )
{
case 1:
{
prNewObject = new glo::Persistent();
break;
}
case 2:
{
prNewObject = new FirstClass();
break;
}
default:
{
t_iErr = glo::ERR_UNKNOWN_CLASSID;
break;
}
}
if ( prNewObject )
{
prNewObject->setGloAttribute( "glo::Persistent.m_ObjID", & t_NewObjID );
}
return t_iErr;
}
inline unsigned long FirstGloBaseObjCreator::getClassID( glo::BaseAllSet * pAllSet ) const
{
unsigned long t_ulRetVal = 0;
glo::TAllSet<glo::Persistent> * t_pCastgloPersistent = dynamic_cast<glo::TAllSet<glo::Persistent>*>(pAllSet);
glo::TAllSet<FirstClass> * t_pCastFirstClass = dynamic_cast<glo::TAllSet<FirstClass>*>(pAllSet);
if ( t_pCastgloPersistent ) t_ulRetVal = 1;
if ( t_pCastFirstClass ) t_ulRetVal = 2;
if ( ! t_ulRetVal )
{
throw eut::ErrorNException( "FirstGloBaseObjCreator::getClassID( BaseAllSet * pAllSet ) const", glo::ERR_UNKNOWN_OBJECT_TYPE, __FILE__, __LINE__ );
}
return t_ulRetVal;
}
inline glo::ObjCreator * FirstGloBaseObjCreator::getCopy() const
{
return new FirstGloBaseObjCreator;
}
#undef SUPER
#endif
FirstClass (Header)
Die vom GloDeveloper generierten Header-Dateien der persistenten Klassen, können weitestgehend vom Nutzer verändert und erweitert werden. Der einzige Bereich, welcher vom GloDeveloper benötigt wird, ist der zwischen den Einträgen "private persistent:" und "private transient:". Wenn die Kommentare beginnend mit "//@@glo" entfernt werden, wird der GloDeveloper diese Bereiche nicht mehr aktualisieren. Es wird empfohlen, diese Kommentare nicht zu entfernen.
Es können vom Nutzer weitere, transiente Attribute und Methoden (wie im Beispiel die Set- und Get-Methode) eingefügt werden. Dieser Bereich wird bei Änderungen durch den GloDeveloper nicht "angefasst".
#ifndef INC_FIRSTCLASS_H
#define INC_FIRSTCLASS_H
namespace glo
{
class Base;
}
#include <GloPersistent.h>
class FirstClass : public glo::Persistent
{
private persistent:
GLO_OBJECT( FirstClass:glo::Persistent );
private:
int FirstAttribute;
private transient:
public:
void setFirstAttribute( int i )
{
FirstAttribute = i;
}
int getFirstAttribute() const
{
return FirstAttribute;
}
};
#endif
FirstClass (Glo-Source)
Eine vom GloDeveloper generierte Source-Datei (z.B. "glo_FirstClass.cpp") der persistenten Klasse FirstClass muss im Softwareprojekt eingebunden werden. Sie enthält Anweisungen für GlobalObjects und sollten vom Nutzer nicht bearbeitet werden.
Methoden der Klasse FirstClass sollten entweder 'inline' oder in einer anderen Source-Datei (i.d.R. "FirstClass.cpp") implementiert werden.
#include "FirstClass.h"
#include "EuException.h"
#include <GloBase.h>
unsigned long FirstClass::getGloClassID() const
{
return 2;
}
int FirstClass::setGloAttribute( const glo::AttributeID & rAttributeID, void * pPara )
{
int t_iErr = 0;
if ( rAttributeID == glo::AttributeID( 2, 1 ) )
{
FirstClass::FirstAttribute = * ( static_cast<int*>( pPara ) );
}
else
{
t_iErr = glo::Persistent::setGloAttribute( rAttributeID, pPara );
}
return t_iErr;
}
int FirstClass::setGloAttribute( const std::string & rstrAttributeName, void * pPara )
{
int t_iErr = 0;
if ( rstrAttributeName == "FirstClass.FirstAttribute" )
{
FirstClass::FirstAttribute = * ( static_cast<int*>( pPara ) );
}
else
{
t_iErr = glo::Persistent::setGloAttribute( rstrAttributeName, pPara );
}
return t_iErr;
}
void * FirstClass::getGloAttribute( const glo::AttributeID & rAttributeID )
{
void * t_pRetVal = 0;
if ( rAttributeID == glo::AttributeID( 2, 1 ) )
{
return & (FirstClass::FirstAttribute);
}
else
{
t_pRetVal = glo::Persistent::getGloAttribute( rAttributeID );
}
return t_pRetVal;
}
void * FirstClass::getGloAttribute( const std::string & rstrAttributeName )
{
void * t_pRetVal = 0;
if ( rstrAttributeName == "FirstClass.FirstAttribute" )
{
return & (FirstClass::FirstAttribute);
}
else
{
t_pRetVal = glo::Persistent::getGloAttribute( rstrAttributeName );
}
return t_pRetVal;
}
void FirstClass::postAssign( glo::Base & rBase )
{
glo::Persistent::postAssign( rBase );
}
Main.cpp
Für den ersten Eindruck, eine kommentierte Main.cpp, in der aus einer Objektdatenbank persistente Objekte gelesen und ein neues persistentes Objekt gespeichert wird. Es werden std::shared_ptr genutzt:
#include <iostream>
#include <GloBase.h>
#include "FirstGloBaseObjCreator.h"
int main( int argc, char* argv[] )
{
int t_iErr = 0;
FirstGloBaseObjCreator t_ObjCreator;
glo::Base t_Base( "LOCAL", "TestClient", t_ObjCreator );
t_iErr = t_Base.openBaseComfortably();
std::cout << "openBaseComfortably -> Err:" << t_iErr << "\n";
if ( ! t_iErr )
{
std::shared_ptr<FirstClass> t_spNewPersObject( new FirstClass(), glo::Forgeter<FirstClass>() );
int t_iValue( 0 );
std::cout << "Bitte eine Zahl eingeben!" << "\n";
std::cin >> t_iValue;
t_spNewPersObject->setFirstAttribute( t_iValue );
t_iErr = t_spNewPersObject->assign( t_Base );
if ( ! t_iErr )
{
std::cout << "Object assigned ->ObjId: " << t_spNewPersObject->getObjID().toString() << "\n";
t_iErr = t_spNewPersObject->store();
if ( ! t_iErr )
{
std::cout << "Object stored ->ObjId: " << t_spNewPersObject->getObjID().toString() << "\n";
}
}
if ( ! t_iErr )
{
std::shared_ptr<FirstClass> t_spShowPersObject;
glo::TAllSet<FirstClass> t_AllSet( t_Base );
std::cout << "Objects in AllSet: " << t_AllSet.size() << "\n" ;
t_iErr = t_AllSet.get( t_spShowPersObject, glo::START );
if ( ! t_iErr )
{
std::cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n";
do
{
std::cout << "From AllSet ObjId: "
<< t_spShowPersObject->getObjID().toString()
<< " FirstClass::FirstAttribute = "
<< t_spShowPersObject->getFirstAttribute()
<< "\n" ;
t_iErr = t_AllSet.get( t_spShowPersObject, glo::NEXT );
} while ( ! t_iErr );
std::cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
}
}
t_iErr = ( t_iErr == glo::ERR_RANGE ? 0 : t_iErr );
t_iErr = t_Base.closeBase();
std::cout << "closeBase -> Err:" << t_iErr << "\n";
}
char key = 0;
std::cout << "Zum beenden bitte Taste und [Enter] druecken" << "\n";
std::cin >> key;
return t_iErr;
}
Wer nicht mit std::shared_ptr arbeiten möchte, hier eine alternative Main.cpp.
#include <iostream>
#include <GloBase.h>
#include "FirstGloBaseObjCreator.h"
int main( int argc, char* argv[] )
{
int t_iErr = 0;
FirstGloBaseObjCreator t_ObjCreator;
glo::Base t_Base( "LOCAL", "TestClient", t_ObjCreator );
t_iErr = t_Base.openBaseComfortably();
std::cout << "openBaseComfortably -> Err:" << t_iErr << "\n";
if ( ! t_iErr )
{
FirstClass * t_pNewPersObject = new FirstClass();
int t_iValue( 0 );
std::cout << "Bitte eine Zahl eingeben!" << "\n";
std::cin >> t_iValue;
t_pNewPersObject->setFirstAttribute( t_iValue );
t_iErr = t_pNewPersObject->assign( t_Base );
if ( ! t_iErr )
{
std::cout << "Object assigned ->ObjId: " << t_pNewPersObject->getObjID().toString() << "\n";
t_iErr = t_pNewPersObject->store();
if ( ! t_iErr )
{
std::cout << "Object stored ->ObjId: " << t_pNewPersObject->getObjID().toString() << "\n";
}
}
t_pNewPersObject->forget();
if ( ! t_iErr )
{
FirstClass * t_pShowPersObject = 0;
glo::TAllSet<FirstClass> t_AllSet( t_Base );
std::cout << "Objects in AllSet: " << t_AllSet.size() << "\n" ;
t_iErr = t_AllSet.get( t_pShowPersObject, glo::START );
if ( ! t_iErr )
{
std::cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n";
do
{
std::cout << "From AllSet ObjId: "
<< t_pShowPersObject->getObjID().toString()
<< " FirstClass::FirstAttribute = "
<< t_pShowPersObject->getFirstAttribute()
<< "\n" ;
t_pShowPersObject->forget();
t_iErr = t_AllSet.get( t_pShowPersObject, glo::NEXT );
} while ( ! t_iErr );
std::cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
}
}
t_iErr = ( t_iErr == glo::ERR_RANGE ? 0 : t_iErr );
t_iErr = t_Base.closeBase();
std::cout << "closeBase -> Err:" << t_iErr << "\n";
}
char key = 0;
std::cout << "Zum beenden bitte Taste und [Enter] druecken" << "\n";
std::cin >> key;
return t_iErr;
}
Persistente Klasse mit allen unterstützten Attributen (Header)
Als Beispiel eine persistente Klasse ExampleClass mit allen unterstützten Attributtypen.
#ifndef INC_EXAMPLECLASS_H
#define INC_EXAMPLECLASS_H
namespace glo
{
class Base;
}
class ExampleEmbeddedClass;
class ExampleReferenceClass;
#include <GloPersistent.h>
#include <EuBlob.h>
#include <list>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "ExampleEmbeddedClass.h"
#include "ExampleReferenceClass.h"
class ExampleClass : public glo::Persistent
{
private persistent:
GLO_OBJECT( ExampleClass:glo::Persistent );
GLO_INDEX( FirstIndex, ExampleClass.m_String[10] & ExampleClass.m_String20[20], USE_DELIMITER | DEU-2 );
private:
eut::Blob m_Blob;
bool m_Bool;
char m_Char;
std::time_t m_DateTime;
double m_Double1;
double m_Double2;
double m_Double3;
std::list<double> m_DoubleList;
std::set<double> m_DoubleSet;
std::vector<double> m_DoubleVector;
float m_Float1;
float m_Float2;
float m_Float3;
int m_Integer;
std::list<int> m_IntegerList;
std::set<int> m_IntegerSet;
std::vector<int> m_IntegerVector;
long m_LongInteger;
long double m_LongDouble1;
long double m_LongDouble2;
long double m_LongDouble3;
long long m_LongLong;
glo::ObjID m_GloObjID;
glo::TOndemand< ExampleReferenceClass > m_OndemandReference;
glo::TOndemand< ExampleReferenceClass > m_OndemandDependReference;
glo::TOndemandSet< ExampleReferenceClass > m_OndemandRefSet;
glo::TOndemandList< ExampleReferenceClass > m_OndemandRefList;
glo::TOndemandSet< ExampleReferenceClass > m_OndemandDependRefSet;
glo::TPointerSet< ExampleReferenceClass > m_PointerRefSet;
glo::TPointerList< ExampleReferenceClass > m_PointerRefList;
glo::TPointerSet< ExampleReferenceClass > m_PointerDependeRefSet;
short m_ShortInteger;
std::shared_ptr< ExampleReferenceClass > m_StdSharedPointer;
std::shared_ptr< ExampleReferenceClass > m_StdSharedDependPointer;
std::string m_String;
std::string m_String20;
std::list<std::string> m_StringList;
std::set<std::string> m_StringSet;
std::vector<std::string> m_StringVector;
unsigned char m_UnsignedChar;
unsigned int m_UnsignedInteger;
unsigned long m_UnsignedLongInteger;
unsigned long long m_UnsignedLongLong;
unsigned short m_UnsignedShortInteger;
ExampleReferenceClass* m_PointerReference;
ExampleReferenceClass* m_PointerDependReference;
ExampleEmbeddedClass m_Embedded;
private transient:
};
#endif
IndexCallBack abgeleitet von glo::CallBack
Ein Beispiel, wie über das Öffnen einer GlobalObjects-Objektdatenbank und das Reindizieren einer GlobalObjects-Objektdatenbank informiert wird.
class IndexCallBack : public glo::CallBack
{
private:
IndexCallBack( const IndexCallBack & rTr );
public:
IndexCallBack(){};
virtual ~IndexCallBack(){};
public:
virtual void notify( glo::NotifyNote & rNote )
{
if ( rNote.m_ulNotifyMode == glo::WNM_INDEX_READ || rNote.m_ulNotifyMode == glo::WNM_INDEX_WRITE )
{
if ( rNote.m_ulNotifyMode == glo::WNM_INDEX_READ ) std::cout << "Read ";
else if ( rNote.m_ulNotifyMode == glo::WNM_INDEX_WRITE ) std::cout << "Write ";
std::cout << "Index:" << rNote.m_strInfo << " ClassID:" << rNote.m_ObjID.getClassID() << " %:" << rNote.m_uiInfo << "\n";
}
else if ( rNote.m_ulNotifyMode == glo::WNM_INDEX_REINDEX )
{
std::cout << "Reindex Index:" << rNote.m_strInfo << " ObjID:" << rNote.m_ObjID.toString() << " Count:" << rNote.m_uiInfo << "\n";
}
};
private:
IndexCallBack & operator= ( const IndexCallBack & );
};
Weitere Informationen zum Thema Glo-Objekte beobachten / benachrichtigen.
Eine Objektdatei
Objektdateien sind in der Regel Textdateien, deren Datenfelder durch ein "Sonderzeichen" getrennt sind. Objektdateien können z.B. durch LibreOffice Calc eingelesen werden.
ObjID|CreateDate|LastChange|
2.0.1| 1553163903| 0|
Blobs und längere Textfelder werden in separate Dateien ausgelagert; der Dateiname wird dann im Datenfeld eingetragen.
1.10.0