GloDeveloper
Lade ...
Suche ...
Keine Treffer
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 glo::ObjCreator 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 oder verschieben.

In diesem Beispiel 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 auch eine Beschreibung verfasst werden.

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

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

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


Objektdatenbank 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/FirstGloBase" 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 glo::Persistent angelegt.

Persistente Klasse anlegen

Jetzt kann die erste persistente Klasse angelegt werden.

Die Klasse 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 glo::Persistent angelegt.

Persistentes Attribut anlegen

Ein persistentes Attribut, welches die Bezeichnung FirstAttribute bekommt, wird über einen Dialog angelegt. 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 übernehmen

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.

Objektdatenbank speichern

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

Die Ausgabe sieht ungefähr so aus:

-------------------------------------------------------------------------------
Class [GloPersistent]
Test ClassAttributes
Attribute [GloObjID m_ObjID] ok
Attribute [time_t m_dtCreateDate] ok
Attribute [time_t m_dtLastChange] ok
-------------------------------------------------------------------------------
Class [GloPersistent]
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 Dateien 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:

-------------------------------------------------------------------------------
Class [GloPersistent]
Test ClassAttributes
Attribute [GloObjID m_ObjID] ok
Attribute [time_t m_dtCreateDate] ok
Attribute [time_t m_dtLastChange] ok
-------------------------------------------------------------------------------
Class [GloPersistent]
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 glo::AttributeID & 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 glo::AttributeID & 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
-------------------------------------------------------------------------------

Dateien des Projektes "FirstGloProject"

Im folgenden werden die resultierenden Dateien des Projektes "FirstGloProject" aufgezeigt und ihre Bedeutung beschrieben.

Projekt-Datei des Projektes "FirstGloProject"

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.

Schema-Datei der Objektdatenbank "FirstGloBase"

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 von "FirstBaseObjCreator"

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 der Klasse "FirstClass"

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".

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

Source-Datei der Klasse "FirstClass"

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

GlobalObjects Initialisierungsdatei

Damit die zu erstellende Applikation weiß, wo die Objektdatenbank zu finden ist, muss im Verzeichnis der Applikation 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" im Verzeichniss des GloServer stehen und 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 bzw. des GloServer gespeichert werden, dieses geht nicht über den GloDeveloper.

GlobalObjects Objektdatendateien

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.
    Zu beachten
    Die Umgebungsvariable "EUCPPDIR" hält den Pfad zum Verzeichnis "Src", siehe auch GlobalObjects Umgebungsvariablen und Setup GlobalObjects C++ Header.
  • Das Bibliotheks-Verzeichnisse mit der aktuellen GlobalObjects-DLL GLOAvXXXXXXXX.dll muss eingebunden sein. Siehe auch Setup Biblioteken (LIBs und DLLs).
  • glo_FirstClass.cpp wird mit kompiliert.
  • DB.ini ist im Ausführungsverzeichnis. Wenn der GloServer genutzt wird, muss in dessen Ausführungsverzeichnis eine entsprechende DB.ini vorhanden sein.

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

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

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

...
// 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;
glo::Base t_Base( "LOCAL", "TestClient", t_ObjCreator ); // Ohne Server

bzw.

glo::Base 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 glo::Base::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 glo::TAllSet die richtige Klasse. Der AllSet wird mit dem Template-Parameter der gewünschten Klasse und mit der geöffneten Objektdatenbank als Parameter instanziiert.

glo::TAllSet<FirstClass> t_AllSet( t_Base );

Folgende Zeile holt das erste gespeicherte Objekt im übergebenen Parameter "t_spShowPersObject" aus der Objektdatenbank.

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

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 glo::BasePersistent::forget() aus dem Speicher entfernt werden darf, wird ein entsprechender "Deleter" mit übergeben:

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

Es können die Werte im Objekt gesetzt werden. Bevor das Objekt gespeichert werden kann, muss dieses eine eindeutige Objekt-ID (siehe auch glo::ObjID) bekommen. Dieses wird mit dem Anmelden an die Objektdatenbank erledigt. Ein persistentes Objekt muss nur einmal, 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!