Makrooperator

[Manfred]

Hallo,

hier mal wieder eine Verständnisfrage:

Code: Alles auswählen

METHOD datenbank:fieldsEmpty(objekt)                                            // die Feldvariablen werden geleert
       LOCAL cField
       LOCAL nI, nOldSelect := SELECT()

       DBSELECTAREA(objekt:nArea)                // muß hier rein, weil mit ALIAS() gearbeitet wird und dann
       FOR nI := 1 TO (ALIAS())->(FCOUNT()) -1                                  // -1 wegen des _LOCK Feldes
           cField := (ALIAS())->(FIELDNAME(nI))
           objekt:&(cField) := BLANK(objekt:&(cField),.T.)        // Objekt muß auch verschwinden, aber wie?
//           ::&(cField) := BLANK(::&(cField),.T.)                              // warum klappt das nicht?
       NEXT
       DBSELECTAREA(nOldSelect)
       RETURN self

Das was ausgemarkert ist, klappt so nicht. Ich habe keine Ahnung warum nicht. Ist jemand so nett und erklärt es mir?

Danke....

[brandelh]

HI,

ich bin jetzt zwar nicht der OOP Experte, aber ich meine, dass zwischen ObjectVariable und Methode bzw. Instanzvariable nichts dazwischen darf.
Außerdem meine ich kann man & nicht auf Local-Vars anwenden.

oVar:Methode()
oVar:InstanzVar

warum nicht in dieser Art:

oVar:GetField(xFeld) -> xFeld kann dann Feldnamen oder Feldnummer sein.

[Jan]

Außerdem meine ich kann man & nicht auf Local-Vars anwenden.

Das stimmt (habe ich leidvolle und zeit- und nervenraubende Erfahrungen mit sammeln müssen )

Jan

[Manfred]

Hallo Hubert,

HI,

ich bin jetzt zwar nicht der OOP Experte, aber ich meine, dass zwischen ObjectVariable und Methode bzw. Instanzvariable nichts dazwischen darf.
Außerdem meine ich kann man & nicht auf Local-Vars anwenden.

Das ist richtig, aber die Zeile drüber klappt. Nur das ich dort direkt das Objekt angebe und eine Zeile drunter wohl nur mit dem self arbeite.

oVar:Methode()
oVar:InstanzVar

warum nicht in dieser Art:

oVar:GetField(xFeld) -> xFeld kann dann Feldnamen oder Feldnummer sein.

Im Moment habe ich jetzt wieder den dicken Balken vor dem Blickfeld. Das macht die Variable leer?

[brandelh]

Hallo Manfred,

Im Moment habe ich jetzt wieder den dicken Balken vor dem Blickfeld. Das macht die Variable leer?

Ich bin jetzt zwar nicht ganz sicher was du meinst, aber ich vermute du willst ein Objekt löschen ?

Nun eigentlich gibt es keine leeren Objekte, aber Objekte haben verschiedene Stadien:

oObj // zur Zeit noch nichts zugewiesen also NIL = normale Variable
oObj := MyClass():New() // Variable, welche nun ein Objekt der Classe MyClass() enthält. Die INIT()-Methode wurde schon ausgeführt.
oObj:create() // lädt die Systemresourcen
Wenn nun einfach oObj := NIL gemacht würde, wäre zwar das Opjekt in der Variabel durch NIL ersetzt, aber die Systemreferenzen würden weiter bestehenbleiben, wären aber nicht mehr zugänglich. So entstehen Speicherlecks in Anwendungen.
oObj:destroy() // gibt die Resourcen frei
Man kann oObj jetzt z.B. für ein anderes Objekt dieser Klasse mit :create() wiederbeleben.
Nach destroy kann man auch NIL zuweisen, das macht aber selten Sinn, ist auch nicht nötig.

Mit oObj:status() kann man abfragen in welchem Zustand oObj ist.

Falls du nur die Grundinitialisierung gemeint hast, so ist ein oObj nach INIT immer auf den Vorgabewerten.

[Manfred]

Hallo Hubert,

nee, nee, nee, immer langsam

Ich habe ein Objekt der Datenbank, in dem die Feldvariablen der DB sind.
Ich rufe verschiedene Methoden auf:

1) Einlesen der Feldinhalte der DB
2) mit den Inhalten arbeiten, wenn angezeigt, oder geändert wird
3) oder die Membervariablen mit BLANK() (TOOLS) leeren

um dort die neuen Werte einzugeben. So brauche ich nicht immer alles zu initialisieren. Das geschieht dann anhand der Felder in der DB.

So rufe ich einfach nur objekt:oeffnen(), objekt:lesen(), objekt:schreiben() auf und alles paßt immer bei jeder DB und das Objekt weiß, ob anghängt wird, oder nur ausgewechselt. Usw.

Nur klappt es halt mit dem Makrooperator nicht, die Variablen darüber zu durchlaufen.

Ich hoffe ich habe jetzt etwas mehr Licht ins Dunkel gebracht.

[Tom]

Hallo, Manfred.

Roger Donnay macht in seinen Zusatzfunktionen "DC_DBSCATTER" und "DC_DBGATHER" aus der eXPress++-Bibliothek etwas sehr ähnliches, und da funzt es so:

Code: Alles auswählen

// Transfer values from fields to instance variables

FUNCTION DC_DbScatter( oRecord )

LOCAL i, aStruct, xData

aStruct := dbStruct()

FOR i := 1 TO Len(aStruct)
  xData := FieldGet(i)
  oRecord:&(aStruct[i,1]) := xData
NEXT

RETURN oRecord

* --------------

// Write instance variables to database fields

FUNCTION DC_DbGather( oRecord, lNew )

LOCAL i, aStruct, cFieldName, xData

DEFAULT lNew := Eof()

IF lNew
  dbAppend()
ELSEIF !dbRlock()
  RETURN .f.
ENDIF
aStruct := DbStruct()
FOR i := 1 TO Len(aStruct)
  cFieldName := aStruct[i,1]
  IF IsMemberVar(oRecord,cFieldName)
    xData := oRecord:&(cFieldName)
    FieldPut(i,xData)
  ENDIF
NEXT

dbCommit()
dbunlock()

RETURN .t.

[Manfred]

Hi Tom,

hm, ich würde mich eigentlich sehr stark dafür interessieren, warum meine Idee nicht läuft. Es gibt in den Alaska Beispielen auch etwas dadrüber.
Ich dachte hier wäre jemand, der evtl. sofort sehen kann, wo ich meinen Denkfehler habe.

[Martin Altmann]

Hallo Manfred,
sicherlich, weil Du das Objekt nicht mit angegeben hast!
Die Reihenfolge ::& ist fehlerhaft und der Compiler kann das nicht ab.
Warum willst Du das Objekt unbedingt loswerden? Lass' es doch so, wie es ist.

Viele Grüße,
Martin

[Tom]

Hallo, Manfred.

Der Operator "::" steht ja für eine verkürzte Schreibweise von "self:". Probier's doch einfach mal so aus:

Code: Alles auswählen

BLANK(self:&(cField),.T.)

[Manfred]

Hi Martin,

worin liegt denn der Unterschied zwischen dem Objekt und self. :: also self, ist doch für Methoden des Objektes gedacht. Da ist mein Verständnisproblem. Ich möchte nicht ein Objekt verschwinden lassen, ich arbeite ja damit, aber über self. Ich gehe mal davon aus, wenn es über self klappt, dan braucht ich auch nicht das Objekt zu übergeben. Ich übergebe es ja nurdeshalb, weil es nicht über self klappt.
Die Methode gehört der Klasse, die sie auch aufruft.

[Martin Altmann]

Manfred,
probiere doch einfach mal Toms Vorschlag aus.

Viele Grüße,
Martin

[Manfred]

yepp, yepp, yepp,
ich bin gerade dabei. Der Compiler meckert auf jeden Fall schon mal nicht.

muß nur noch eben ein paar Schüppen Kohle nachlegen....

melde mich gleich wieder.

[brandelh]

Hallo Manfred,

METHOD datenbank:fieldsEmpty(objekt)

Ich versuche mal ob ich es verstehe ...

:: oder SELF: (beides ist gleich) beziehen sich hier auf die Klasse DATENBANK
::fieldsEmpty(xxx) würde also sich selbst aufrufen ...

objekt ist ein DBF-Object (?) welches du übergeben hast ...

Wird in deiner Klasse für jedes Feld also z.B. Feldname = Vorname eine Instanzvariable dieses Namens dynamisch erzeugt, sodass du eigentlich diesen Befehl ausführen willst ?

::Vorname := blank(object:vorname,.t.)

nachdem du das Feld selbst gelöscht hast, mit der Zeile

objekt:&(cField) := BLANK(objekt:&(cField),.T.)

Dass diese Zeile funktioniert überrascht mich etwas ... war mit glatt entfallen.
(cField) holt den Inhalt aus der lokal Var und das ist der Feldname, welcher an den & Operator übergeben wird.

Offensichtlich ist es nicht direkt erlaubt self aufzurufen (PreProzessor Beschränkung ?), aber was hindert dich eine eigene Var für :: self: anzulegen :

Code: Alles auswählen

METHOD datenbank:fieldsEmpty(objekt)
      local MyLocalSelf := self
      ...
      objekt:&(cField) := BLANK(objekt:&(cField),.T.)                // wenn das geht ...
      MyLocalSelf:&(cField) := BLANK(MyLocalSelf:&(cField),.T.)        // müsste auch das erlaubt sein.

Dennoch würde ich eine andere Lösung suchen, & Macros sind doch etwas suspect

[Manfred]

Hi @all

ich habe mal was eingestellt, vielleicht bringt es uns weiter.

Der Vorschlag von Tom macht auch mucken. Es entsteht ein Laufzeitfehler. Die Schleife wird 1x durchlaufen und bei der 2.Feldvariable kommt eine Fehlermeldung, diese gäbe es nicht. Muß ich mir aber auch nochmal genauer ansehen.

Puh, eigentlich sollte es eine harmlose Frage werden. Naja, ich und meine Fragen....

Code: Alles auswählen

#include "Appevent.ch"
#include "Fileio.ch"
#include "Gra.ch"
#include "xbtsys.ch"
#include "xbp.ch"
#include "dbstruct.ch"
#include "DbfDbe.ch"
#include "..\..\include\inkey.ch"
#pragma Library("XppUi2.lib")                                                   // wird für XbpBrowse() benötigt
********************************************************************************
CLASS datenbank
      PROTECTED:
      CLASS VAR cVerzeichnis,;                                                  // hier kommt das Verzeichnis rein, welches erzeugt werden muß
                lIndexNeu,;                                                     // der wird gesezt, wenn der vorhandene Index mit dem Indexarray nicht übereinstimmt
                nAltSaetze,;
                nPos,;
                nSlashMenge,;                                                   // wird bei der Ermittlung und Erzeugung von Unterverzeichnissen benötigt
                nSlashStelle                                                    // hier wird die Stelle des Backslashes im Verzeichnisname ermittelt
      METHOD erneuereDBStruktur                                                 // hier wird die Struktur der DB angepaßt
      METHOD erzeugeIndex                                                       // Neuaufbau eines Index
      METHOD openDb                                                             // wird doch nur über diese Klasse geregelt
      METHOD openIndex
      METHOD schreibeStruktur
      METHOD vergleicheDbStrukturalt_neu
      METHOD vergleicheIndexStrukturAlt_neu
      EXPORTED:
// Feldvariablen in DB
      CLASS VAR id                                                              // jeder Datensatz bekommt eine ID egel welche DB

// Speichervariablen
      CLASS VAR aIndex                                                          // Indexdateischlüssel
// nochmals prüfen, ob Shared interessant für mich ist
      CLASS VAR aStruktur                                                       // Struktur der jeweiligen DB
      CLASS VAR cAlias,;                                                        // wird gebraucht, weil man die DB´s mehrfach in einem Programm aufmachen können soll
                cDbank,;                                                        // der Datenbankname
                cDbe,;                                                          // kann die Database-Engine aufnehmen
                cPfad,;                                                         // hier komt nur der Dateipfad hinein
                cSuffix,;                                                       // Für Installation .neu -> .dbf
                cDBStrukturDatum,;                                              // Datum als String von wann die Struktur ist. Damit nicht abwärts geändert werden kann
                lBrowseReturn,;                                                 // Wenn das Browse mit RETURN, also Satzübernahme beendet wird
                lBrowseEsc,;                                                    // Wenn das browse abgebrochen wurde mit ESC
                lEdit,;                                                         // wenn gefundene Sätze editiert werden für die Prüffunktionen
                lIndex,;                                                        // wenn Index vorhanden ist
                lMin1Record,;                                                   // wenn die DB nicht leer sein darf
                lNewArea,;                                                      // öffenen in einem neuen Bereich
                lNeu,;                                                          // für die GET Masken um zu unterscheiden
                lReadonly,;                                                     // hier kann der Wert geändert werden, wie eine Datenbank geöffnet wird
                lRecordLock,;                                                   // wenn ein Satz gesperrt werden soll
                lSatzLoeschen,;                                                 // falls ein Datensatz gelöscht werden muß
                lShared,;                                                       // wenn gesetzt, dann Shared, ansonsten Exclusiv
                lSuchen,;                                                       // wird für die Funktionen in den Neueingaben und Änderungen der Datensätze benötigt
                lUnique,;                                                       // für eindeutige Indiezes
                nArea,;                                                         // hier wird SELECT() nach dem Öffnen gemerkt
                nRecordNummer                                                   // man weiß nie...
      CLASS METHOD initClass
      METHOD browseDB                                                           // was früher TBrowse war
      METHOD CloseDb
      METHOD dbOpen
      METHOD erzeugeVerzeichnisse                                               // hier können alle Unterverzeichnisse erzeugt werden
      METHOD fieldsEmpty                                                        // das sollte auch geprüft werden, ob es protected kann
      METHOD readRecord
      METHOD recordLock
      METHOD writeRecord
      METHOD zapDB
ENDCLASS
********************************************************************************
CLASS METHOD datenbank:initClass
             ::id                 := 0                                          // ist in allen DB. wird für Relationen genutzt.
             ::aStruktur          := {}                                         // Die Werte werden in den jeweiligen Klassen der Datenbanken gesetzt
             ::cAlias             := ""                                         // ich mache es mal einfach wegen Struktuvergleich
             ::cSuffix            := ".dbf"                                     // Standard, wird auch nur beim Setup gegen .neu getauscht
             ::lBrowseReturn      := .F.                                        // wurde ein Datensatz zur Übernahme ausgewählt?
             ::lBrowseEsc         := .F.                                        // oder wurde das browsefenster durch ESC abgebrochen?
             ::lIndex             := .T.                                        // wird pauschal gesetzt und muß nur bei Nichtbenutzung geändert werden
             ::lIndexNeu          := .F.                                        // wird auf false gesetzt, weil es immer wieder neu gesetzt werden muß
             ::lNeu               := .F.                                        // wird dann in den Erfassungs PRG´s gesetzt
             ::lEdit              := .F.                                        // ist für die Prüfroutinen
             ::lSuchen            := .F.                                        // wird später in editieren auf .T. gesetzt
             ::lMin1Record        := .F.                                        // wenn die DB nicht leer sein darf
             ::lNewArea           := .T.                                        // Standardmäßig in einem neuen Bereich
             ::lReadonly          := .F.                                        // Standardwert .F.
             ::lRecordLock        := .F.                                        // Standardwert: nicht sperren
             ::lSatzLoeschen      := .F.
             ::lShared            := .T.                                        // pauschal immer erstmal für Mehrfachzugriff
             ::lUnique            := .F.                                        // generell werden mehrere gleiche Schlüssel pro DB erlaubt
             ::nArea              := 0                                          // wird gebarucht, weil darüber die DB angesprochen werden
             ::nAltSaetze         := 0                                          // Menge der Datensätze vor der Übernahme alt in neu Struktur
             ::nPos               := 0                                          // hier kommt die Position enes Felder der DB rein um sie mit der Position der neuen zu vergleichen
             ::nRecordNummer      := 0
RETURN self
********************************************************************************
METHOD datenbank:readRecord(objekt,lFieldsEmpty,cDatenbank)                     // aktuellen Satz in Feldvariablen einlesen
       LOCAL cField
       LOCAL nI, nOldSelect := SELECT()
       LOCAL nAbzug := 1                                                        // für das _LOCK Feld

       IF PCOUNT() = 3
          DBSELECTAREA(cDatenbank)
       ELSE
          DBSELECTAREA(objekt:nArea)                                            // muß hier rein, weil mit ALIAS() gearbeitet wird und dann
       ENDIF
       IF ::lRecordLock
          ::recordLock()
       ENDIF
       IF FIELDPOS("_LOCK") = 0                                                 // wenn es diese Feld nicht gibt
          nAbzug := 0
       ENDIF
       FOR nI := 1 TO (ALIAS())->( FCOUNT()) - nAbzug                           // -1 wegen des _LOCK Feldes
           cField := (ALIAS())->( FIELDNAME(nI) )
           objekt:&(cField) := (ALIAS())->( FIELDGET(nI) )
//           ::&(cField) := (ALIAS())->( FIELDGET(nI) )                         // warum klappt das nicht?
       NEXT
       IF lFieldsEmpty
          ::fieldsEmpty(objekt)                                                 // objekt muß hier rein, weil ein self falsch ist
       ELSE
          ::nRecordNummer := (ALIAS())->(RECNO())                               // wenn man mal springen muß
       ENDIF
       DBSELECTAREA(nOldSelect)
RETURN self
********************************************************************************
METHOD datenbank:fieldsEmpty(objekt)                                            // die Feldvariablen werden geleert
       LOCAL cField
       LOCAL nI, nOldSelect := SELECT()

       DBSELECTAREA(objekt:nArea)                                               // muß hier rein, weil mit ALIAS() gearbeitet wird und dann
       FOR nI := 1 TO (ALIAS())->(FCOUNT()) -1                                  // -1 wegen des _LOCK Feldes
           cField := (ALIAS())->(FIELDNAME(nI))
//           objekt:&(cField) := BLANK(objekt:&(cField),.T.)                      // Objekt muß auch verschwinden, aber wie?
//           ::&(cField) := BLANK(::&(cField),.T.)                              // warum klappt das nicht?
           BLANK(::&(cField),.T.)
       NEXT
       DBSELECTAREA(nOldSelect)
       RETURN self
********************************************************************************

[Manfred]

autsch, das war zu lang, mußte den Rest hier reinpacken.

Code: Alles auswählen

********************************************************************************
********************************************************************************
CLASS kunde FROM datenbank
      EXPORTED:
// Feldvariablen in DB
      VAR k_barcode,;
          k_name,;
          k_vorname,;
          k_strasse,;
          k_plz,;
          k_ort,;
          k_tele1,;
          k_tele2,;
          k_fax,;
          k_bem,;
          k_bem2,;
          k_bem3,;
          k_gebdat,;
          k_anrede,;
          k_leihdat,;
          k_eintritt,;
          k_vozz,;
          k_sperre,;
          _lock
      METHOD erzeugestruktur
      METHOD felder
      METHOD init
      METHOD maske
      METHOD pruef
ENDCLASS
********************************************************************************
METHOD kunde:init()
       ::aIndex := {;
                    {"ID","STR(id,8,0)"},;
                    {"EAN8","STR(k_barcode,8,0)"},;
                    {"NAME","EVAL(bKdn)"};
                   }                                            // Indexschlüssel usw.
       ::cDbank := "kunde"                                      // Name der Datenbank, bzw. der Indexdatei
       ::cDBE   := "DBFCDX"
       ::cDBStrukturdatum := "20060314"						// wird für die Prüfung der Struktur benötigt
       ::cPfad  := "..\datenbanken\kunden\"                     // Verzeichnis der Datenbank
       ::lIndex := .T.
RETURN self
********************************************************************************
PROCEDURE main
                   oKd := kunde():new()
                   oKd:openDb()
                   oKd:readFields(oKd,.T.)
RETURN

[Martin Altmann]

Hallo Manfred,

Der Vorschlag von Tom macht auch mucken. Es entsteht ein Laufzeitfehler. Die Schleife wird 1x durchlaufen und bei der 2.Feldvariable kommt eine Fehlermeldung, diese gäbe es nicht. Muß ich mir aber auch nochmal genauer ansehen.

vielleicht habe ich ja Tomaten auf den Augen, aber ich finde die Stelle nicht, an der Du Toms Vorschlag (self:&(cField)) eingearbeitet hast??

Viele Grüße,
Martin

[Manfred]

Hi Martin,

die Tomaten gib mal her, die brauche ich für unsere Meerschweinchenhorde

nach dem ausgemarkterten, das Blank(::&(cField),.T.)

[Martin Altmann]

Hallo Manfred,

nach dem ausgemarkterten, das Blank(::&(cField),.T.)

eben - aber Tom meinte ja:

Code: Alles auswählen

Blank(self:&(cField),.T.)

Viele Grüße,
Martin

[Manfred]

Hi Martin,

aber ich werde noch verrückt:

:: und self: ist doch dasselbe, oder nicht?

[Martin Altmann]

Klar ist es dasselbe!
Aber der Compiler scheint ein Problem mit der Zeichenfolge ::& zu haben - und um das zu umgehen, einfach mal self:& verwenden.

Viele Grüße,
Martin

[Manfred]

hm,

das werde ich jetzt testen und wenn das wirklich einen Unterschied macht, dann werde ich den Alaska Support damit nerven.

Wäre nicht das 1.Mal.

also bis gleich.


grrrrrr

[Manfred]

nö, nüscht,

gleiche Fehlermeldung.

[Martin Altmann]

Und wenn Du jetzt noch dafür sorgst, dass cField nicht als local sondern als private deklariert wird?

Viele Grüße,
Martin

[Manfred]

Die Fehlermeldung sagt aus, das das Objekt keine Membervariablen mit diesem Namen hat.

Das werde ich jetzt nochmal genau nachsehen. Nicht das da ein falsches angepackt wird mit self....