GloDeveloper
Beispieldateien

Beispiel 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/
################################################################################

Beispiel 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=1552919157
Description=
# The data is located in this subdirectory in the schema directory.
DataPath=FirstGloBase
################################################################################
[Class.GloPersistent]
ClassID=1
SuperClassID=0|
ClassFileName=GloPersistent.h
[GloPersistent.Attribute.m_ObjID]
Table=FirstGloBase
FieldPos=0
Field=ObjID
AccessControl=private:
Type=GloObjId
TypeInfo=
Description=
[GloPersistent.Attribute.m_dtCreateDate]
Table=FirstGloBase
FieldPos=1
Field=CreateDate
AccessControl=private:
Type=time_t
TypeInfo=
Description=
[GloPersistent.Attribute.m_dtLastChange]
Table=FirstGloBase
FieldPos=2
Field=LastChange
AccessControl=private:
Type=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=
Type=GloObjId
TypeInfo=
Description=
[FirstClass.Attribute.FirstAttribute]
Table=FirstClass
FieldPos=1
Field=FirstAttribute
AccessControl=private:
Type=int
TypeInfo=
Description=Wird benötigt um...
################################################################################

GlobalObjects-Schema Basisinformationen

Zwei Schlüssel-Wert-Paare unter einer Sektion [BaseInfo] sind obligatorisch.

Das Schema kann eine ID haben, welche als Objektdatenbank-ID in GloObjID::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.

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.

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 GloPersistent, 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=
ClassDescription=

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 [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 GloRA::SchemaTypeString.

Folgende Schlüssel-Wert-Paare sind obtional:

  • TypeInfo Je nach unterstützten Attributtyp eine Information. Siehe auch GloClassInfoAttribute::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=Das ist ein Integer-Attribut.

GlobalObjects-Schema Indexdefinition

Um in Tabellen Objekte schnell über einen Index suchen zu können, ist eine Index-Sektion erforderlich. 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
  • time_t
  • std::string

Attributtypen die als Pfad zu einem Index-Attribut genutzt werden können:

  • Eingebettete persistente Objekte
  • Mittels Pointer 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 Glo Index.

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.

Beispiel-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
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @AktuellesDatum - @AktuelleZeit\n\copyright © @GruppenName\n\autor @NutzerName
ClassDescription=GloPersistent ist die Basislasse aller persistenter Klassen.\n\copyright © @GruppenName\n\autor @NutzerName
[GloPersistent.Attribute.m_ObjID]
Table=SchemaExample
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.
[GloPersistent.Attribute.m_dtCreateDate]
Table=SchemaExample
FieldPos=1
Field=CreateDate
AccessControl=private:
Type=time_t
TypeInfo=
Description=Der erste Speicherzeitpunkt.
[GloPersistent.Attribute.m_dtLastChange]
Table=SchemaExample
FieldPos=2
Field=LastChange
AccessControl=private:
Type=time_t
TypeInfo=
Description=Der letzte Speicherzeitpunkt.
################################################################################
[Class.ExampleClass]
ClassID=2
SuperClassID=1|
SuperClassInfo= |
ClassFileName=ExampleClass.h
FileDescription=\brief Header für @KlassenName\nGenerated by GloDeveloper: @AktuellesDatum - @AktuelleZeit\n\copyright © @GruppenName\n\autor @NutzerName
ClassDescription=Eine Beispielklasse mit allen unterstützten Attributtypen.\n\copyright © @GruppenName\n\autor @NutzerName
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=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: @AktuellesDatum - @AktuelleZeit\n\copyright © @GruppenName\n\autor @NutzerName
ClassDescription=\copyright © @GruppenName\n\autor @NutzerName
[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: @AktuellesDatum - @AktuelleZeit\n\copyright © @GruppenName\n\autor @NutzerName
ClassDescription=\copyright © @GruppenName\n\autor @NutzerName
[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: @AktuellesDatum - @AktuelleZeit\n\copyright © @GruppenName\n\autor @NutzerName
ClassDescription=\copyright © @GruppenName\n\autor @NutzerName
[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: @AktuellesDatum - @AktuelleZeit\n\copyright © @GruppenName\n\autor @NutzerName
ClassDescription=\copyright © @GruppenName\n\autor @NutzerName
[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: @AktuellesDatum - @AktuelleZeit\n\copyright © @GruppenName\n\autor @NutzerName
ClassDescription=\copyright © @GruppenName\n\autor @NutzerName
[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: @AktuellesDatum - @AktuelleZeit\n\copyright © @GruppenName\n\autor @NutzerName
ClassDescription=\copyright © @GruppenName\n\autor @NutzerName
[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

Wenn der ref GLO_SERVER "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

Beispiel-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 "EuError.h"
#include <GloTypes.h>
#include <GloObjCreator.h>
#include "GloTAllSet.h"
// persistente Klassen includen
#include "GloPersistent.h"
#include "FirstClass.h"
//-----------------------------------------------------------------------------
//BaseVersion:1553768817
//-----------------------------------------------------------------------------
class FirstGloBaseObjCreator : public GloObjCreator
{
public:
FirstGloBaseObjCreator();
virtual ~FirstGloBaseObjCreator();
virtual inline std::string getBaseName() const;
virtual inline bool isKnownClassID( unsigned long ulClassID ) const;
virtual inline int getPersObject( GloPersistent *& prNewObjekt, unsigned long ulClassID ) const;
virtual inline unsigned long getClassID( GloBaseAllSet * pAllSet ) const;
virtual inline GloObjCreator * getCopy() const;
};
//-----------------------------------------------------------------------------
#define SUPER GloObjCreator
//-----------------------------------------------------------------------------
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( GloPersistent *& prNewObjekt, unsigned long ulClassID ) const
{
int t_iErr = 0;
GloObjID t_NeueObjID( ulClassID, 0, 0 );
switch ( ulClassID )
{
case 1: // GloPersistent
{
prNewObjekt = new GloPersistent();
break;
}
case 2: // FirstClass
{
prNewObjekt = new FirstClass();
break;
}
default:
{
t_iErr = GloERR_UNKNOWN_CLASSID;
break;
}
} // END switch ( ulClassID )
if ( prNewObjekt )
{
prNewObjekt->setGloAttribute( "GloPersistent.m_ObjID", & t_NeueObjID );
}
return t_iErr;
}
//-----------------------------------------------------------------------------
inline unsigned long FirstGloBaseObjCreator::getClassID( GloBaseAllSet * pAllSet ) const
{
unsigned long t_ulRetVal = 0;
GloTAllSet<GloPersistent> * t_pCastGloPersistent = dynamic_cast<GloTAllSet<GloPersistent>*>(pAllSet);
GloTAllSet<FirstClass> * t_pCastFirstClass = dynamic_cast<GloTAllSet<FirstClass>*>(pAllSet);
if ( t_pCastGloPersistent ) t_ulRetVal = 1;
if ( t_pCastFirstClass ) t_ulRetVal = 2;
if ( ! t_ulRetVal )
{
throw EuError( "FirstGloBaseObjCreator::getClassID( GloBaseAllSet * pAllSet ) const", GloERR_UNKNOWN_OBJECT_TYPE );
}
return t_ulRetVal;
}
//-----------------------------------------------------------------------------
inline GloObjCreator * FirstGloBaseObjCreator::getCopy() const
{
return new FirstGloBaseObjCreator;
}
//-----------------------------------------------------------------------------
#undef SUPER
//-----------------------------------------------------------------------------
#endif

Beispielklasse FirstClass (Header)

Die vom GloDeveloper generierten Header-Dateien der persistenten Klasse n, 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".

//-----------------------------------------------------------------------------
//@@glofdb_FirstClass
//@@glofde_FirstClass
//-----------------------------------------------------------------------------
#ifndef INC_FIRSTCLASS_H
#define INC_FIRSTCLASS_H
//@@glofwb_FirstClass
//@@glofwe_FirstClass
//@@glosib_FirstClass
#include <GloPersistent.h>
//@@glosie_FirstClass
//@@glorib_FirstClass
//@@glorie_FirstClass
//-----------------------------------------------------------------------------
//@@glocdb_FirstClass
// Glo-BaseVersion:1552919157
class FirstClass : public GloPersistent
//@@glocde_FirstClass
{
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private persistent:
//-------------------------------------------------------------------------
GLO_OBJECT( FirstClass:GloPersistent );
//-------------------------------------------------------------------------
private:
//-------------------------------------------------------------------------
int FirstAttribute; // TableName:FirstClass FieldPos:1
//-------------------------------------------------------------------------
private transient:
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:
void setFirstAttribute( int i )
{
FirstAttribute = i;
}
int getFirstAttribute() const
{
return FirstAttribute;
}
};
//-----------------------------------------------------------------------------
#endif

Beispielklasse 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 "EuError.h"
//-----------------------------------------------------------------------------
//@@glomib_FirstClass
//@@Persistent BaseVersion:1553002747
//-----------------------------------------------------------------------------
unsigned long FirstClass::getGloClassID() const
{
return 2;
}
//-----------------------------------------------------------------------------
int FirstClass::setGloAttribute( const GloAttributeID & rAttributeID, void * pPara )
{
int t_iErr = 0;
if ( rAttributeID == GloAttributeID( 2, 1 ) ) // FirstClass.FirstAttribute
{
FirstClass::FirstAttribute = * ( static_cast<int*>( pPara ) );
}
else
{
// Call in superclass(es) same method
t_iErr = GloPersistent::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
{
// Call in superclass(es) same method
t_iErr = GloPersistent::setGloAttribute( rstrAttributeName, pPara );
}
return t_iErr;
}
//-----------------------------------------------------------------------------
void * FirstClass::getGloAttribute( const GloAttributeID & rAttributeID )
{
void * t_pRetVal = 0;
if ( rAttributeID == GloAttributeID( 2, 1 ) ) // FirstClass.FirstAttribute
{
return & (FirstClass::FirstAttribute);
}
else
{
// Call in superclass(es) same method
t_pRetVal = GloPersistent::getGloAttribute( rAttributeID );
}
return t_pRetVal;
}
//-----------------------------------------------------------------------------
void * FirstClass::getGloAttribute( const std::string & rstrAttributeName )
{
void * t_pRetVal = 0;
if ( rstrAttributeName == "FirstClass.FirstAttribute" )
{
return & (FirstClass::FirstAttribute);
}
else
{
// Call in superclass(es) same method
t_pRetVal = GloPersistent::getGloAttribute( rstrAttributeName );
}
return t_pRetVal;
}
//-----------------------------------------------------------------------------
//@@glomie_FirstClass
//-----------------------------------------------------------------------------

Beispiel Main.cpp

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>
// Die persistenten Klassen werden vom Objekt-Ersteller eingebunden!
#include "FirstGloBaseObjCreator.h"
//----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
int t_iErr = 0;
FirstGloBaseObjCreator t_ObjCreator;
// Die Base wird mit allen notwendigen Informationen instantiiert.
// FirstGloBaseObjCreator wird übergeben, damit Objekte der persistente Klasse instantiiert werden können.
GloBase t_Base( "LOCAL", "TestClient", t_ObjCreator ); // Ohne Server
// Die Base wird geöffnet, wenn kein Index, wird dieser angelegt
t_iErr = t_Base.openBaseComfortably();
std::cout << "openBase -> Err:" << t_iErr << "\n";
if ( ! t_iErr )
{
// Neues Objekt um dieses in Base zu speichern, GloForgeter<FirstClass> muss übergeben werden.
std::shared_ptr<FirstClass> t_spNewPersObject( new FirstClass(), GloForgeter<FirstClass>() );
int t_iValue( 0 );
std::cout << "Bitte eine Zahl eingeben!" << "\n";
std::cin >> t_iValue;
t_spNewPersObject->setFirstAttribute( t_iValue );
// Vor dem Speichern, bei der Base anmelden. Das Objekt bekommt somit eine gültige Objekt-ID (siehe GloObjID).
t_iErr = t_spNewPersObject->assign( t_Base );
if ( ! t_iErr )
{
std::cout << "Object assigned ->ObjId: " << t_spNewPersObject->getObjID().toString() << "\n";
// Neues Objekt in Base speichern
t_iErr = t_spNewPersObject->store();
if ( ! t_iErr )
{
std::cout << "Object stored ->ObjId: " << t_spNewPersObject->getObjID().toString() << "\n";
}
}
// Ein AllSet liefert alle Objekte einer Klasse. Weil der AllSet vor der übergebenen Datenbank
// aus dem Speicher entfernt werden muss (siehe dtor GloBaseAllSet), hier im eigenen Scope.
if ( ! t_iErr )
{
std::shared_ptr<FirstClass> t_spShowPersObject;
GloTAllSet<FirstClass> t_AllSet( t_Base );
std::cout << "Objects in AllSet: " << t_AllSet.size() << "\n" ;
// Alle Objekte des Typs 'FirstClass' in Base anzeigen indem durch den AllSet iteriert wird.
t_iErr = t_AllSet.get( t_spShowPersObject, GloSTART );
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, GloNEXT );
} while ( ! t_iErr );
std::cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
}
}
t_iErr = ( t_iErr == GloERR_RANGE ? 0 : t_iErr );
// Datenbank schliessen damit die Indizes geschrieben werden.
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>
// Die persistenten Klassen werden vom Objekt-Ersteller eingebunden!
#include "FirstGloBaseObjCreator.h"
//----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
int t_iErr = 0;
FirstGloBaseObjCreator t_ObjCreator;
// Die Base wird mit allen notwendigen Informationen instantiiert.
// FirstGloBaseObjCreator wird übergeben, damit Objekte der persistente Klasse instantiiert werden können.
GloBase t_Base( "LOCAL", "TestClient", t_ObjCreator ); // Ohne Server
// Die Base wird geöffnet, wenn kein Index, wird dieser angelegt
t_iErr = t_Base.openBaseComfortably();
std::cout << "openBase -> Err:" << t_iErr << "\n";
if ( ! t_iErr )
{
// Neues Objekt um dieses in Base zu speichern
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 );
// Vor dem Speichern, bei der Base anmelden. Das Objekt bekommt somit eine gültige Objekt-ID (siehe GloObjID).
t_iErr = t_pNewPersObject->assign( t_Base );
if ( ! t_iErr )
{
std::cout << "Object assigned ->ObjId: " << t_pNewPersObject->getObjID().toString() << "\n";
// Neues Objekt in Base speichern
t_iErr = t_pNewPersObject->store();
if ( ! t_iErr )
{
std::cout << "Object stored ->ObjId: " << t_pNewPersObject->getObjID().toString() << "\n";
}
}
// Nicht vergessen; Objekt aus dem Speicher!
t_pNewPersObject->forget();
// Ein AllSet liefert alle Objekte einer Klasse. Weil der AllSet vor der übergebenen Datenbank
// aus dem Speicher entfernt werden muss (siehe dtor GloBaseAllSet), hier im eigenen Scope.
if ( ! t_iErr )
{
FirstClass * t_pShowPersObject = 0;
GloTAllSet<FirstClass> t_AllSet( t_Base );
std::cout << "Objects in AllSet: " << t_AllSet.size() << "\n" ;
// Alle Objekte des Typs 'FirstClass' in Base anzeigen indem durch den AllSet iteriert wird.
t_iErr = t_AllSet.get( t_pShowPersObject, GloSTART );
if ( ! t_iErr )
{
std::cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n";
do
{
std::cout << "From AllSet ObjId: "
<< t_pShowPersObject->getObjID().toString()
<< " FirstClass::FirstAttribute = "
<< t_pShowPersObject->getFirstAttribute()
<< "\n" ;
// Nicht vergessen; Objekt aus dem Speicher!
t_pShowPersObject->forget();
t_iErr = t_AllSet.get( t_pShowPersObject, GloNEXT );
} while ( ! t_iErr );
std::cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
}
}
t_iErr = ( t_iErr == GloERR_RANGE ? 0 : t_iErr );
// Datenbank schliessen damit die Indizes geschrieben werden.
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;
}

Beispielklasse (Header) mit allen unterstützten Attributen

Eine persistente Klasse ExampleClass mit allen unterstützten Attributtypen.

//-----------------------------------------------------------------------------
//@@glofdb_ExampleClass
//@@glofde_ExampleClass
//-----------------------------------------------------------------------------
#ifndef INC_EXAMPLECLASS_H
#define INC_EXAMPLECLASS_H
//@@glofwb_ExampleClass
class ExampleEmbeddedClass;
class ExampleReferenceClass;
//@@glofwe_ExampleClass
//@@glosib_ExampleClass
#include <GloPersistent.h>
//@@glosie_ExampleClass
//@@glorib_ExampleClass
#include <EuBlob.h>
#include <list>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "ExampleEmbeddedClass.h"
#include "ExampleReferenceClass.h"
//@@glorie_ExampleClass
//-----------------------------------------------------------------------------
//@@glocdb_ExampleClass
// Glo-BaseVersion:1571900416
class ExampleClass : public GloPersistent
//@@glocde_ExampleClass
{
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private persistent:
//-------------------------------------------------------------------------
GLO_OBJECT( ExampleClass:GloPersistent );
//-------------------------------------------------------------------------
GLO_INDEX( FirstIndex, ExampleClass.m_String[10] & ExampleClass.m_String20[20], USE_DELIMITER | DEU_2 );
//-------------------------------------------------------------------------
private:
//-------------------------------------------------------------------------
EuBlob m_Blob; // TableName:ExampleClass FieldPos:1
//-------------------------------------------------------------------------
bool m_Bool; // TableName:ExampleClass FieldPos:2
//-------------------------------------------------------------------------
char m_Char; // TableName:ExampleClass FieldPos:3
//-------------------------------------------------------------------------
time_t m_DateTime; // TableName:ExampleClass FieldPos:4
//-------------------------------------------------------------------------
double m_Double1; // TableName:ExampleClass FieldPos:5 TypeInfo:0
//-------------------------------------------------------------------------
double m_Double2; // TableName:ExampleClass FieldPos:6 TypeInfo:2
//-------------------------------------------------------------------------
double m_Double3; // TableName:ExampleClass FieldPos:7 TypeInfo:4
//-------------------------------------------------------------------------
std::list<double> m_DoubleList; // TableName:ExampleClass FieldPos:8
//-------------------------------------------------------------------------
std::set<double> m_DoubleSet; // TableName:ExampleClass FieldPos:9
//-------------------------------------------------------------------------
std::vector<double> m_DoubleVector; // TableName:ExampleClass FieldPos:10
//-------------------------------------------------------------------------
float m_Float1; // TableName:ExampleClass FieldPos:11 TypeInfo:0
//-------------------------------------------------------------------------
float m_Float2; // TableName:ExampleClass FieldPos:12 TypeInfo:2
//-------------------------------------------------------------------------
float m_Float3; // TableName:ExampleClass FieldPos:13 TypeInfo:4
//-------------------------------------------------------------------------
int m_Integer; // TableName:ExampleClass FieldPos:14
//-------------------------------------------------------------------------
std::list<int> m_IntegerList; // TableName:ExampleClass FieldPos:15
//-------------------------------------------------------------------------
std::set<int> m_IntegerSet; // TableName:ExampleClass FieldPos:16
//-------------------------------------------------------------------------
std::vector<int> m_IntegerVector; // TableName:ExampleClass FieldPos:17
//-------------------------------------------------------------------------
long m_LongInteger; // TableName:ExampleClass FieldPos:18
//-------------------------------------------------------------------------
long double m_LongDouble1; // TableName:ExampleClass FieldPos:19
//-------------------------------------------------------------------------
long double m_LongDouble2; // TableName:ExampleClass FieldPos:20 TypeInfo:2
//-------------------------------------------------------------------------
long double m_LongDouble3; // TableName:ExampleClass FieldPos:21 TypeInfo:4
//-------------------------------------------------------------------------
long long m_LongLong; // TableName:ExampleClass FieldPos:22
//-------------------------------------------------------------------------
GloObjID m_GloObjID; // TableName:ExampleClass FieldPos:23
//-------------------------------------------------------------------------
GloTOndemand<ExampleReferenceClass> m_OndemandReference; // TableName:ExampleClass FieldPos:24
//-------------------------------------------------------------------------
GloTOndemand<ExampleReferenceClass> m_OndemandDependReference; // TableName:ExampleClass FieldPos:25 TypeInfo:dependent
//-------------------------------------------------------------------------
GloTOndemandSet<ExampleReferenceClass> m_OndemandRefSet; // TableName:ExampleClass FieldPos:26
//-------------------------------------------------------------------------
GloTOndemandSet<ExampleReferenceClass> m_OndemandDependRefSet; // TableName:ExampleClass FieldPos:27 TypeInfo:dependent
//-------------------------------------------------------------------------
GloTPointerSet<ExampleReferenceClass> m_PointerRefSet; // TableName:ExampleClass FieldPos:28
//-------------------------------------------------------------------------
GloTPointerSet<ExampleReferenceClass> m_PointerDependeRefSet; // TableName:ExampleClass FieldPos:29 TypeInfo:dependent
//-------------------------------------------------------------------------
short m_ShortInteger; // TableName:ExampleClass FieldPos:30
//-------------------------------------------------------------------------
std::shared_ptr<ExampleReferenceClass> m_StdSharedPointer; // TableName:ExampleClass FieldPos:31
//-------------------------------------------------------------------------
std::shared_ptr<ExampleReferenceClass> m_StdSharedDependPointer; // TableName:ExampleClass FieldPos:32 TypeInfo:dependent
//-------------------------------------------------------------------------
std::string m_String; // TableName:ExampleClass FieldPos:33
//-------------------------------------------------------------------------
std::string m_String20; // TableName:ExampleClass FieldPos:34 TypeInfo:20
//-------------------------------------------------------------------------
std::list<std::string> m_StringList; // TableName:ExampleClass FieldPos:35
//-------------------------------------------------------------------------
std::set<std::string> m_StringSet; // TableName:ExampleClass FieldPos:36
//-------------------------------------------------------------------------
std::vector<std::string> m_StringVector; // TableName:ExampleClass FieldPos:37
//-------------------------------------------------------------------------
unsigned char m_UnsignedChar; // TableName:ExampleClass FieldPos:38
//-------------------------------------------------------------------------
unsigned int m_UnsignedInteger; // TableName:ExampleClass FieldPos:39
//-------------------------------------------------------------------------
unsigned long m_UnsignedLongInteger; // TableName:ExampleClass FieldPos:40
//-------------------------------------------------------------------------
unsigned long long m_UnsignedLongLong; // TableName:ExampleClass FieldPos:41
//-------------------------------------------------------------------------
unsigned short m_UnsignedShortInteger; // TableName:ExampleClass FieldPos:42
//-------------------------------------------------------------------------
ExampleReferenceClass* m_PointerReference; // TableName:ExampleClass FieldPos:43
//-------------------------------------------------------------------------
ExampleReferenceClass* m_PointerDependReference; // TableName:ExampleClass FieldPos:44 TypeInfo:dependent
//-------------------------------------------------------------------------
ExampleEmbeddedClass m_Embedded; // TableName:ExampleClass FieldPos:45
//-------------------------------------------------------------------------
private transient:
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
};
//-----------------------------------------------------------------------------
#endif

Beispielklasse IndexCallBack abgeleitet von GloCallBack

Ein Beispiel, wie über das Öffnen einer GlobalObjects-Objektdatenbank und das Reindizieren einer GlobalObjects-Objektdatenbank informiert wird.

//----------------------------------------------------------------------------
// Eine Anzeigeklasse abgeleitet von GloCallBack um ein ggf. ablaufendes
// Indizieren anzuzeigen. In der Methode IndexCallBack::notify(...) werden die
// einzelnen NotifyNotes ausgewertet und angezeigt.
class IndexCallBack : public GloCallBack
{
private:
IndexCallBack( const IndexCallBack & rTr );
public:
IndexCallBack(){};
virtual ~IndexCallBack(){};
public:
// Diese Methode wird aufgerufen, wenn benachrichtigt wird
virtual void notify( GloNotifyNote & rNote )
{
// wenn Index gelesen oder geschrieben wird, anzeigen wie weit...
if ( rNote.m_ulNotifyMode == GloWNM_INDEX_READ || rNote.m_ulNotifyMode == GloWNM_INDEX_WRITE )
{
if ( rNote.m_ulNotifyMode == GloWNM_INDEX_READ ) std::cout << "Read ";
else if ( rNote.m_ulNotifyMode == GloWNM_INDEX_WRITE ) std::cout << "Write ";
std::cout << "Index:" << rNote.m_strInfo << " ClassID:" << rNote.m_ObjID.getClassID() << " %:" << rNote.m_uiInfo << "\n";
}
// wenn Index reindiziert wird, anzeigen wie weit...
else if ( rNote.m_ulNotifyMode == GloWNM_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.

Beispiel für 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 einzelne Dateien ausgelagert; der Dateiname wird dann im Datenfeld geführt