GlobalObjects
Schnelleinstieg

Schnelleinstieg Einleitung

Damit GlobalObjects arbeiten kann, sind einige Vorbereitungen zu treffen. Es werden hier alle benötigten Dateien und Einstellungen angesprochen, welche GlobalObjects benötigt um Objekte speichern, lesen und löschen zu können. Dieses kann durch das GlobalObjects-Tool GloDeveloper erledigt werden. Der GloDeveloper ist die Anwendung, mit der GlobalObjects-Objektdatenbanken erstellt und alle benötigten Header- und Source-Dateien für Klassen persistenter Objekte erstellt bzw. gewartet werden.

Der GloDeveloper ist eine typische MDI-Anwendung. Die eigenständig zu bearbeitenden Objekte, wie z.B. Klassen, werden in eigenen Dokumentfenstern bearbeitet, nur abhängige Objekte, wie z.B. Attribute, werden in Dialogen bearbeitet.

GloDeveloper nach dem ersten Start.

Hinweis: Der GloDeveloper kann mit der Übergabe einer Projektdatei (z.B.: GloDeveloper.exe "D:\Projekte\GlobalObects xx.xx\GloExamples\Bases\FirstGloProject.prj") gestartet werden, welche dann eingelesen wird.

Benötigte Dateien

  • Eine Datei welche das GlobalObjects-Schema enthält, also für GlobalObjects festhält, welche Klassen es gibt und wie die einzelnen Attribute dieser Klassen behandelt werden sollen, wird vom GloDeveloper erstellt.
  • Eine C++ Headerdatei welche einen Objekt-Ersteller abgeleitet von GloObjCreator definiert, der Objekte der persistenten Klassen bauen kann, wird vom GloDeveloper erstellt.
  • Die GlobalObjects Objektdateien in denen die Daten der Objekte gespeichert sind, werden vom GloDeveloper erstellt.
  • Und nicht zuletzt die Header- und Source-Dateien der persistenten Klassen, werden vom GloDeveloper erstellt.
  • Eine GlobalObjects-Initialisierungsdatei, welche GlobalObjects informiert, wo die GlobalObjects-Objektdateien zu finden sind und ggf., wenn ein GloServer eingesetzt werden soll, noch einige Server-Informationen.
    Zu beachten
    Diese Datei muss selbst im Arbeitsverzeichnis der zu erstellenden Applikation gespeichert werden, dieses geht nicht über den GloDeveloper.

GlobalObjects-Projekt im GloDeveloper

Objektdatenbanken werden in Projekten angelegt. Der GloDeveloper kann mehrere Objektdatenbanken in einem Projekt verwalten. Das ist z.B. hilfreich, wenn eine Klasse in mehreren Objektdatenbanken vorkommen soll; man kann diese von einer Objektdatenbank in eine andere kopieren.

Es soll die Objektdatenbank bzw. das GlobalObjects-Schema im Verzeichnis "D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/" angelegt werden.

Projekt anlegen

Nach dem Start des GloDeveloper kann ein Projekt angelegt werden. Es kann eine Beschreibung verfasst werden.

Das neue Projekt wird unter dem Namen "FirstGloProjekt"...

...gespeichert. Die Ausgabe sieht ungefähr so aus:

Projekt: 'D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/FirstGloProject.prj' erfolgreich gespeichert.


Datenbank anlegen

Nun können wir eine Objektdatenbank (bzw. ein GlobalObjects-Schema,) anlegen.

Zu beachten
Die Menüleiste wird im GloDeveloper kontextabhängig angezeigt. Datenbanken können nur angelegt werden, wenn der Projektkatalog den Fokus hat. Wenn also die Menüleiste die Auswahl Neu / Neue Datenbank nicht anbietet, einfach auf den Bereich des Projektkatalogs klicken. Weitere Informationen zur Fensteraufteilung des GloDeveloper sind hier.

Die Bezeichnung der Objektdatenbank ist FirstGloBase.

Das GlobalObjects-Schema wird im Verzeichnis "D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/" abgelegt.

Im Daten-Unterverzeichnis "D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/data" werden später die Daten gespeichert.

Die zu generierenden Header- und Source-Dateien der einzelnen Klassen werden in die Verzeichnisse "D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/include/" und "D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/source/" gespeichert.

Wenn der Dialog mit [OK] bestätigt, wird die Datenbank mit der Basisklasse GloPersistent angelegt.

Persistente Klasse anlegen

Jetzt kann die erste persistente Klasse angelegt werden.

Diese bekommt die Bezeichnung FirstClass. Wenn das Eingabefeld "Klassen-Name" zum ersten mal nach der Eingabe einer Bezeichnung verlassen wird, wird diese als "Objektdatei-Name" und als "Headerdatei-Name" übernommen; wir belassen es bei diesen Bezeichnungen (könnten aber überschrieben werden). Diese Klasse wurde automatisch als Unterklasse von GloPersistent angelegt.

Persistentes Attribut anlegen

Ein persistentes Attribut wird über einen Dialog angelegt, welches die Bezeichnung FirstAttribute bekommt. Wenn das Eingabefeld "Attribut-Name" zum ersten mal nach der Eingabe einer Bezeichnung verlassen wird, wird diese als "Objektdatei-Feldname" übernommen (könnten aber überschrieben werden). Zusätzlich bekommt das Attribut eine Beschreibung.

Zu beachten
Nicht persistente Attribute können wie gewohnt in der resultierenden Header-Datei deklariert werden.

Klasse in Schema

Noch ist die neue Klasse nicht im GlobalObjects-Schema. Das wird mit den Button [Übernehmen] bzw. [OK] erreicht.

Die neue Klasse wird im Projekt-Katalog angezeigt.

Datenbank Speichern

Die Datenbank bzw. das Datenbankschema kann jetzt oder später gespeichert werden.

Die Ausgabe sieht ungefähr so aus:

-------------------------------------------------------------------------------
Test ClassAttributes
Attribute [GloObjID m_ObjID] ok
Attribute [time_t m_dtCreateDate] ok
Attribute [time_t m_dtLastChange] ok
-------------------------------------------------------------------------------
Test ClassIndex
No index
-------------------------------------------------------------------------------
Class [FirstClass]
Test ClassAttributes
Attribute [GloObjID m_ObjID] ok
Attribute [int FirstAttribute] ok
-------------------------------------------------------------------------------
Class [FirstClass]
Test ClassIndex
No index
-------------------------------------------------------------------------------
0 Errors
-------------------------------------------------------------------------------
Projekt: 'D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/FirstGloProject.prj' erfolgreich gespeichert.
Datenbankschema: 'FirstGloBase' erfolgreich gespeichert.

Alle Files generieren

Um alle benötigten Dateien zu generieren, muss das Menü Erzeugen / Alle Files des selektierten Objekts generieren sichtbar werden. Dafür reicht ein rechter Maus-Klick im Projekt-Katalog. Damit alle Dateien für die Objektdatenbank generiert werden, muss der Eintrag FirstGloBase bzw. der darunter liegende Eintrag Klassen selektiert sein.

Es wird in der Ausgabe angezeigt, was gemacht wurde. Wenn das Erstellen der Dateien zum ersten mal angestoßen wird, sieht die Ausgabe ungefähr so aus:

-------------------------------------------------------------------------------
Test ClassAttributes
Attribute [GloObjID m_ObjID] ok
Attribute [time_t m_dtCreateDate] ok
Attribute [time_t m_dtLastChange] ok
-------------------------------------------------------------------------------
Test ClassIndex
No index
-------------------------------------------------------------------------------
Class [FirstClass]
Test ClassAttributes
Attribute [GloObjID m_ObjID] ok
Attribute [int FirstAttribute] ok
-------------------------------------------------------------------------------
Class [FirstClass]
Test ClassIndex
No index
-------------------------------------------------------------------------------
0 Errors
-------------------------------------------------------------------------------
Datenbankschema 'FirstGloBase' erfolgreich gespeichert.
-------------------------------------------------------------------------------
Write new header-file -> D:/Projekte/GlobalObects xx.xx/GloExamples/include/FirstClass.h
-------------------------------------------------------------------------------
Update read header-file -> D:/Projekte/GlobalObects xx.xx/GloExamples/include/FirstClass.h
-------------------------------------------------------------------------------
Insert file-description for class FirstClass
Insert base-class: GloPersistent
Insert class-decl: class FirstClass : public GloPersistent
-------------------------------------------------------------------------------
Insert attribute: int FirstClass::FirstAttribute
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
Update write header-file -> D:/Projekte/GlobalObects xx.xx/GloExamples/include/FirstClass.h
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
Write new source-file -> D:/Projekte/GlobalObects xx.xx/GloExamples/source/glo_FirstClass.cpp
-------------------------------------------------------------------------------
Update read source-file -> D:/Projekte/GlobalObects xx.xx/GloExamples/source/glo_FirstClass.cpp
-------------------------------------------------------------------------------
Insert ID-method: unsigned long FirstClass::unsigned long getGloClassID()
-------------------------------------------------------------------------------
Insert set-method: int FirstClass::setGloAttribute( const GloAttributeID & rAttributeID, void * pPara )
set-attribut: GloObjID m_ObjID
set-attribut: int FirstAttribute
-------------------------------------------------------------------------------
Insert set-method: int FirstClass::setGloAttribute( const std::string & rstrAttributName, void * pPara )
set-attribut: GloObjID m_ObjID
set-attribut: int FirstAttribute
-------------------------------------------------------------------------------
Insert get-method: void * FirstClass::getGloAttribute( const GloAttributeID & rAttributeID )
get-attribut: int FirstAttribute
-------------------------------------------------------------------------------
Insert get-method: void * FirstClass::getGloAttribute( const std::string & rstrAttributName )
get-attribut: int FirstAttribute
-------------------------------------------------------------------------------
Update write source-file -> D:/Projekte/GlobalObects xx.xx/GloExamples/source/glo_FirstClass.cpp
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
Write new header- and source-file -> D:/Projekte/GlobalObects xx.xx/GloExamples/include/FirstGloBaseObjCreator.h
-------------------------------------------------------------------------------

Umgang mit den Dateien

Im folgenden werden die teils erstellten Dateien aufgezeigt und ihre Bedeutung beschrieben.

Die Projekt-Datei

Die vom GloDeveloper erstellte Projektdatei "FirstGloProject.prj" kann für eine weitere Verarbeitung vom diesem wieder geladen werden. Sie sollte vom Nutzer nicht direkt bearbeitet werden.

So sieht die FirstGloProject.prj aus.

Die Schema-Datei

GlobalObjects braucht für jede Objektdatenbank eine GlobalObjects-Schemadatei, um aus Objektdateien C++ Objekte und aus C++ Objekten Objektdateien bauen zu können. Die Datei "FirstGloBase.ini", erstellt vom GloDeveloper, ist der Vollständigkeit halber hier mit aufgeführt und sollte vom Nutzer nicht bearbeitet werden.

Weitere Informationen zur GlobalObjects-Schemadatei

Header-Datei Objekt-Ersteller

Damit GlobalObjects aus der Objektdatenbank Objekte erstellen kann, wird eine Objektersteller-Klasse benötigt, die weiß, welche Objekte einer Klassen-ID entsprechen und diese instanziieren kann. Die im angegebenen Header-Verzeichnis vom GloDeveloper generierte Datei "FirstBaseObjCreator.h" wird in das eigene Projekt eingebunden und sollte vom Nutzer nicht direkt bearbeitet werden. Es werden vom Objektersteller alle persistenten Klassen eingebunden.

Beispiel der FirstBaseObjCreator.h

Header-Datei Klasse

Die im angegebenen Header-Verzeichnis, vom GloDeveloper generierte Header-Datei "FirstClass.h" der persistenten Klasse FirstClass, kann 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.

Bitte fügen sie ,wie unten zu sehen, zusätzlich eine Get- und Set-Methode ein, um im anschließenden Programm das Attribut "FirstClass.FirstAttribute" lesen und setzen zu können. 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

Source-Datei Klasse

Die vom GloDeveloper im angegebenen Source-Verzeichnis generierte Source-Datei "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.

Beispiel der glo_FirstClass.cpp

Die GlobalObjects-Initialisierungsdatei

Damit die zu erstellende Applikation weiß, wo die Objektdatenbank zu finden ist, muss in deren Verzeichnis eine DB.ini mit folgendem Inhalt erstellt werden:

[Server]
KnownBases=FirstBase
BasePath=D:/Projekte/GlobalObects xx.xx/GloExamples/Bases

Wenn der GloServer ausprobiert werden soll, sollte die DB.ini so aussehen:

[Server]
Port=4000
TcpPackageSize=4096
TimeOutSec=5
KnownBases=FirstBase
BasePath=D:/Projekte/GlobalObects xx.xx/GloExamples/Bases
Zu beachten
GlobalObjects-Initialisierungsdateien müssen selbst im Arbeitsverzeichnis der zu erstellenden Applikation gespeichert werden, dieses geht nicht über den GloDeveloper.

GlobalObjects Objektdateien

Für jede persistente Klasse wird vom GloDeveloper eine Objektdatei angelegt, in welche die Werte der einzelnen Attribute geschrieben werden.

Applikation mit MyFirstBase erstellen

Im folgenden wird beschrieben, wie Objekte der persistenten Klasse FirstClass in die Objektdatenbanken gespeichert und aus dieser wieder gelesen werden.

Voraussetzungen:

  • Die Include-Verzeichnisse "$(EUCPPDIR)/GlobalObjects/include", "$(EUCPPDIR)/EuTools/include", "$(EUCPPDIR)/PtlContainer/include" und "D:/Projekte/GlobalObects xx.xx/GloExamples/Bases/include" müssen eingebunden sein.
  • Das Bibliotheks-Verzeichnisse mit der aktuellen GlobalObjects-DLL GLOAvXXXXXXXX.dll muss eingebunden sein.
  • glo_FirstClass.cpp wird mit übersetzt.
  • DB.ini ist im Ausführungsverzeichnis. Wenn der GloServer genutzt wird, muss in dessen Ausführungsverzeichnis eine äquivalente DB.ini vorhanden sein.

Es stehen zwei kommentierte Beispiel Main.cpp Dateien zur Verfügung.

Wichtig sind folgende Zeilen, welche hier nochmals erklährt sind:

Um typisierte Objekte aus GlobalObjects lesen bzw. schreiben und ändern zu können, muss eine GloBase mit einem entsprechenden Objektersteller instanziert werden. Siehe auch Beschreibung des Konstruktors von GloBase.

...
// Die Base und der Objekt-Ersteller werden eingebunden
// Die persistenten Klassen werden vom Objekt-Ersteller eingebunden!
#include <GloBase.h>
#include "FirstGloBaseObjCreator.h"
FirstGloBaseObjCreator t_ObjCreator;
GloBase t_Base( "LOCAL", "TestClient", t_ObjCreator ); // Ohne Server

bzw.

GloBase t_Base( "LOCALHOST", "TestClient", t_ObjCreator ); // Mit Server

Noch kann mit der Objektdatenbank nicht gearbeitet werden, dafür muss man sich mit dieser verbinden und öffnen. Dieses wird in der Methode GloBase::openBaseComfortably (...) zusammengefasst.

Der Rückgabewert (int t_iErr) sollte ausgewertet werden.

t_iErr = t_Base.openBaseComfortably();

Um durch die Menge von persistenten Objekten eines Typs zu iterieren ist der GloTAllSet die richtige Klasse. Der AllSet wird mit dem Template-Parameter der gewünschten Klasse und mit der geöffneten Objektdatenbank als Parameter instanziiert.

GloTAllSet<FirstClass> t_AllSet( t_Base );

Folgende Zeile holt die erste (wegen dem zweiten Parameter GloSTART) gespeicherte Klasse im übergebenen Parameter t_spShowPersObject aus der Objektdatenbank.

std::shared_ptr<FirstClass> t_spShowPersObject;
t_iErr = t_AllSet.get( t_spShowPersObject, GloSTART );

Das geladene Objekt ist wie man es erwartet mit seinen Werten im Speicher!

Nun kommen wir zum Anmelden und Speichern eines persistenten Objekts. Dafür wird erst mal ein persistentes Objekt instanziiert. Da ein persistentes Objekt nur über GloBasePersistent::forget() aus dem Speicher entfernt werden darf, wird ein entsprechender "Deleter" mit übergeben:

std::shared_ptr<FirstClass> t_spNewPersObject( new FirstClass(), GloForgeter<FirstClass>() );

Es können die Werte im Objekt gesetzt werden. Bevor das Objekt gespeichert werden kann, muss dieses eine eindeutige Objekt-ID (siehe auch GloObjID) bekommen. Dieses wird mit dem Anmelden an die Objektdatenbank erledigt. Ein persistentes Objekt muss nur vor dem ersten Speichern an die Objektdatenbank angemeldet werden. Danach behält es seine eindeutige Objekt-ID.

t_iErr = t_spNewPersObject->assign( t_Base );

Wenn alles gut, kann das Objekt gespeichert werden.

t_iErr = t_spNewPersObject->store();

Zu guter Letzt muss die Objektdatenbank geschlossen werden, weil unter anderem die aktuellen Indizes geschrieben werden.

t_iErr = t_Base.closeBase();

...das war es auch schon!

persistent
#define persistent
Definition: GloPersistent.h:129
GloPersistent
Die Basisklasse der persistenten Klassen. Von dieser Klasse müssen alle persistenten Objekt abgeleite...
Definition: GloPersistent.h:172
GloObjID
Ein Objekt-ID besteht aus der Klassen-ID, einer Datenbank-ID und der eigentlichen eindeutigen ObjektZ...
Definition: GloObjID.h:72
GloTAllSet
AllSet, welcher Objekte aus der Datenbank liefert. Im AllSets sind alle Instanzen eines Objekttyps in...
Definition: GloTAllSet.h:132
GloPersistent.h
Header für GloPersistent.
GloBase
Diese Klasse ist die Schnittstelle für den Client zu den persistenten Objekten. Hier können "Objekte"...
Definition: GloBase.h:136
GloForgeter
Speziel für GloGenericPersistent oder abgeleitete Klassen von GloPersistent die Forget-Methode für st...
Definition: GloTypes.h:985
GloSTART
@ GloSTART
Definition: GloTypes.h:189
GLO_OBJECT
#define GLO_OBJECT(...)
Es werden die virtuellen Methoden für die Unterklassen deklariert. Beispiele:
Definition: GloPersistent.h:79