himXML (gesprochen himix ML)

[himitsu]

vieleicht hat's ja schon wer vor Ewigkeiten entdeckt ... in den Tools zu himXML existiert ja schon seit einigen Monaten soeine nette und bisher mehr "funktionsunfähige" Klasse :oops:

im Zuge einiger anderer Projekte ist diese inzwischen aber gewachsen :angel2:

sie wird z.B. so eingebunden:

Delphi-Quellcode:

Uses OptionsSelect, himXML_Tools;

Procedure TMainForm.FormCreate(Sender: TObject);
  Begin
    _Options := TXMLProjectOptions.Create;
    _Options.AutorOrCompany   := 'FNS Enterprize''s';
    _Options.Project          := 'SearchSameFiles';
    _Options.OptionsVersion   := '1.0';
    _Options.AllowedLocations := [xpoSession, xpoAppDir, xpoLocalAppDataC];
    _Options.FileName         := 'SearchSameFiles.xml';
    _Options.OnSelectLocation := SelectLocation;
    _Options.Open;
    If _Options.Exists('window') Then Begin
      Left   := _Options.Value['window\left'];
      Top    := _Options.Value['window\top'];
      Width  := _Options.Value['window\width'];
      Height := _Options.Value['window\height'];
    End;
    If not _Options.Exists('view') Then ComboBox1.ItemIndex := 1
    Else ComboBox1.ItemIndex := _Options.Value['view'];
  End;

Procedure TMainForm.FormDestroy(Sender: TObject);
  Begin
    _Options.Free;
  End;

da ich keinen eigenen Auswahldialog eingebunden hab, falls keine Datei gefunden wurde und eine Location gewählt werden muß,
kommt dann z.B. noch sowas dazu:
dieses nutzt den Dialog aus dem Anhang

Delphi-Quellcode:

Procedure TMainForm.SelectLocation(Sender: TXMLProjectOptions; Var Location: TXMLPOLocation);
  Var OSel: TOptionsSelectForm;
    L:      TXMLPOLocation;
    S, S2:  String;

  Begin
    OSel := TOptionsSelectForm.Create(Self);
    Try
      For L := Low(TXMLPOLocation) to High(TXMLPOLocation) do
        If L in Sender.AllowedLocations Then Begin
          Case L of
            xpoSession: Begin
              S  := 'session';
              S2 := 'the options are not saved' + sLineBreak + 'and are only valid for this runtime';
            End;
            xpoDirect: Begin
              S  := 'direct';
              S2 := 'the location is determined by the program';
            End;
            xpoAppDir: Begin
              S  := 'application path';
              S2 := 'the options are saved in the same directory where the program is';
            End;
            xpoLocalAppDataCP, xpoLocalAppDataP, xpoLocalAppDataC, xpoLocalAppData: Begin
              S  := 'local application data';
              S2 := 'the options are saved in a directory that serves as a data repository for local (nonroaming) applications';
            End;
            xpoRoamingAppDataCP, xpoRoamingAppDataP, xpoRoamingAppDataC, xpoRoamingAppData: Begin
              S  := 'roaming application data';
              S2 := 'the options are saved in a directory that serves as a common repository for application-specific data';
            End;
            xpoAllUserAppDataCP, xpoAllUserAppDataP, xpoAllUserAppDataC, xpoAllUserAppData: Begin
              S  := 'all users application data';
              S2 := 'the options are saved in a directory containing application data for all users';
            End;
            Else Begin
              S  := 'unknown';
              S2 := 'unknown';
            End;
          End;
          OSel.AddDir(S, Sender.GetPath(L), S2, Ord(L), L = Location);
        End;
      If OSel.ShowModal = mrOk Then Location := TXMLPOLocation(OSel.Tag);
    Finally
      OSel.Free;
    End;
  End;

diese Funktion kann sich ja dann jeder gestalten wie er sill ... selbst eine Auswahl durch das Programm ist hier möglich, falls man den User nicht "nerven" möchte ... meiner Klasse ist es ja egal wie und wo die Auswahl getroffen wird :nerd:

im Beispiel wird einfach eine Form angezeigt, die möglichen/erlaubten Verzeichnisse werden angezeigt und der User darf dann wählen.


ja und so werden dann z.B. in SearchSameFiles die Einstellungen für den dortigen Verzeichnisauswahldialog geladen:

Delphi-Quellcode:

// auslesen
i2 := _Options.Value['directory\count'];
For i := 0 to i2 - 1 do
  Start.AddDir(_Options.Value[Format('directory\name%d', [i])]);
Start.Edit2.Text        := _Options.Value['mask'];
Start.CheckBox1.Checked := _Options.Value['fullCompare'];
Start.CheckBox2.Checked := _Options.Value['fileCache'];
If Start.ShowModal = mrOk Then Begin
...

// ändern
_Options.BeginUpdate;
_Options.Value['directory\count'] := Length(Dirs);
For i := 0 to High(Dirs) do
  _Options.Value[Format('directory\name%d', [i])] := UTF8ToWideString(Dirs[i]);
_Options.Value['mask']        := UTF8ToWideString(Mask);
_Options.Value['fullCompare'] := Start.CheckBox1.Checked;
_Options.Value['fileCache']   := Start.CheckBox2.Checked;
_Options.EndUpdate;

nötige Dateien sind in der Beta-Version im Post 1# zu finden

und die Klasse selber ist aktuell so aufgebaut

Delphi-Quellcode:

Type TXMLPOLocation   = (xpoSession, xpoDirect, xpoAppDir,
    xpoLocalAppDataCP, xpoLocalAppDataP, xpoLocalAppDataC, xpoLocalAppData,
    xpoRoamingAppDataCP, xpoRoamingAppDataP, xpoRoamingAppDataC, xpoRoamingAppData,
    xpoAllUserAppDataCP, xpoAllUserAppDataP, xpoAllUserAppDataC, xpoAllUserAppData);
TXMLPOLocations       = Set of TXMLPOLocation;
TXMLPOSelectLocation  = Procedure(Sender: TXMLProjectOptions; Var Location: TXMLPOLocation) of Object;

TXMLProjectOptions = Class
  Constructor Create;
  Destructor  Destroy;

  Property  AutorOrCompany:    String;
  Property  Project:           String;
  Property  OptionsVersion:    String;

  Property  AllowedLocations:  TXMLPOLocations;
  Property  FileName:          TWideString;
  Property  Protection:        AnsiString;

  Function  ExistingLocations: TXMLPOLocations;
  Function  PossibleLocations: TXMLPOLocations;

  Procedure Open;
  Procedure Open    (Location: TXMLPOLocation);
  Property  ActiveLocation:    TXMLPOLocation;

  Procedure BeginUpdate;
  Property  Value       [Name: String]: Variant;
  Property  SerializeObj[Name: String]: TObject;
  Property  Protect     [Name: String]: Boolean;
  Function  Exists      (Name: String): Boolean;
  Procedure DeleteValue (Name: String);
  Procedure EndUpdate;

  Procedure Save    (Location: TXMLPOLocation; DeleteOther: Boolean);
  Procedure Close;
  Procedure Delete  (Location: TXMLPOLocation);
  Procedure DeleteAllOptionFiles;

  Property  OnSelectLocation:  TXMLPOSelectLocation;

  Function  GetPath (Location: TXMLPOLocation): String;

  Property  Tag: Integer;
End;

[TheJeed]

Tolles Projekt - sehr hilfreich! Danke für Deine Mühe und für das Engagement, das Ergebnis öffentlich zur Verfügung zu stellen! :cheers:

[xZise]

Hallo himitsu,
ein tolles Projekt (auch wenn ich bisher noch nicht nutzen konnte).

Aber ein paar Sachen habe ich da schon.
Als Erstes: Und zwar wozu wurde der RadioButton erfunden? Weil du auf dem Selektionsfenster Buttons verwendest.
Und dann wäre da noch eine Idee: Und zwar die Möglichkeit, eine Default Funktion und eine Try Funktion (Wie StrToIntDef und TryStrToInt).
Und zur Verschlüsselung: Könnte man es einstellen, welche Verschlüsselungsmethode verwendet? Also ein OnEncrypt und OnDecrypt Ereignis?

Zum Zweiten Punkt:

Delphi-Quellcode:

function TXMLProjectOptions.ValueDef(const AName : string; const ADefaultValue : Variant) : Variant;
begin
  if Exists(AName) then
    Result := Value[AName]
  else
    Result := ADefaultValue;
end;

function TXMLProjectOptions.TryValue(const AName : string; out AValue : Variant) : Boolean;
begin
  if Exists(AName) then
  begin
    Result := True;
    AValue := Value[AName]
  end else
    Result := False;
end;

Ob das so geht, weiß ich nicht ;) Aber ich denke, damit dürfte klar sein, was ich damit meinte.

MfG
xZise

[himitsu]

Zitat:

Zitat von xZise

Als Erstes: Und zwar wozu wurde der RadioButton erfunden? Weil du auf dem Selektionsfenster Buttons verwendest.

DER ist häßlich :tongue:

nja, mir gefiel die Optik mit Buttons einfach besser :angel2:

im Anhang ist mal die aktuelle Version des Dialogs verbaut
- reagiert auf Scrollrad, Pfeiltastentasten und bei Doppelkick direkt als Auswahl
- im Popupmenü (der Trees/Dateilisten) wird der Dialog auch zum Ändern der Position wiederverwendet

ja und fülle mal die RadioGroup mit "vielen" Einträgen ... wird sehr unübersichtlich, wenn die anfängt alles übereinanderzumalen :?
die 3 Auswahlfelder sind nicht alle möglichen Verzeichnisse - hab nicht alles im Programm freigeschaltet - und nun verkleinere mal meinen Dialod in seiner Höhe und schau was passiert :)
(würde ebenfalls geschehen, wenn noch mehr Verzeichnisse zur Wahl stünden)

Aber insgesamt ist es ja halb so schlimm, da du in OnSelectLocation ja einbinden kannst, was DU willst :stupid:



Das mit der Defaultfunktion ist klasse ... warum bin ich da nicht selber draufgekommen :wall:
da mach ich in mein Programm einige if-exists-Abfragen und damit würde das Ganze hübscher aussehn :thumb:

Zitat:

Zitat von xZise

Ob das so geht, weiß ich nicht ;) Aber ich denke, damit dürfte klar sein, was ich damit meinte.

sieht beides OK aus und dürfte auch funktionieren ... wird gleich eingebaut

und daas mit der Verschlüsselung ... da gibt es ja schon was in tXMLFile drin und eigentlich wollte ich das auch durchschleifen (hatte ich wohl wieder vergessen)

[edit]
Testprogramm jetzt im anderem Thread erneuert, drum hier entfernt > siehe dort

[BlueStarHH]

Hi himitsu,

erstmal Danke für das tolle Projekt! Ich möchte damit meine eigene Ini-Klasse ersetzen. Meine Ini-Klasse macht erstmal genau das selbe wie Deine TXMLIniFile im Constructor. Ich erzeuge eine Instanz und mache nichts anderes. Dann rufe ich diese Methode auf:

XML.RootNode.Nodes.Exists('Nicht\Da\Nein')

Diese gibt dann true zurück, obwol keine Node von mir erzeut wurde. Warum? Ist das ein Fehler?

[himitsu]

hast du mal ein ausführlicheres Beispiel dafür?

dieses piept jedenfalls nicht.

Delphi-Quellcode:

XML := TXMLFile.Create;
if XML.RootNode.Nodes.Exists('Nicht\Da\Nein') then
  beep;

oder hast du zufällig vorher auf etwas unterhalb dieses Zweiges zugegriffen? (auch lesend)

per Standard (über XML.Options änderbar) werden ja Nodes automatisch erzeugt, wenn man darauf zugreift

Delphi-Quellcode:

S := XML.RootNode.Nodes['Nicht\Da\Nein'].Text;

[BlueStarHH]

Zitat:

Zitat von himitsu

oder hast du zufällig vorher auf etwas unterhalb dieses Zweiges zugegriffen? (auch lesend)

Ja, das wars! Das hat den Zweig angelegt. Sorry, habe ich übersehen!

[himitsu]

Zitat:

Zitat von BlueStarHH

Ja, das wars! Das hat den Zweig angelegt. Sorry, habe ich übersehen!

Du kannst das Verhalten, wie gesagt auch abschalten, aber dann würde mindestens NIL für einen Knoten zurückgegeben, welcher nicht existiert und im schlimmsten Falle gäbe es natürlich Probleme, wenn du auf etwas nichtexistierendes zugreifst.

hier würde im Falle, daß xoNodeAutoCreate nicht definiert wäre und z.B. "Da" nicht existiert, bei .Text eine Exception ala "Zugriff auf Adresse $0000000x" auftreten, da ja TXMLNode(nil).Text nicht ginge

Delphi-Quellcode:

S := XML.RootNode.Nodes['Nicht\Da\Nein'].Text;

S := XML.RootNode.Nodes['Nich'].Nodes['Da'].Nodes['Nein'].Text;
beim Letzen wäre die Exception sogar schon bei .Nodes['Nein'], da ja dann Nodes['Da'] das NIL zurückgeben würde.

[himitsu]

Hab den Dialog jetzt mit ins Projekt eingefügt, allerdings fehlt dazu noch eine Demo
(aber da gibt's ja weiter oben wenigstens ein paar Beispiele)

Die meißten Änderungen gab es vorallem in den Tools, wo die eine Klasse nun so aussieht:

Delphi-Quellcode:

TXMLProjectOptions = Class
  Constructor Create;
  Destructor  Destroy;

  Property  AutorOrCompany:     String;
  Property  Project:            String;
  Property  OptionsVersion:     String;

  Property  AllowedLocations:   TXMLPOLocations;
  Property  FileName:           TWideString;
  Property  Protection:         AnsiString;

  Function  ExistingLocations:  TXMLPOLocations;
  Function  PossibleLocations:  TXMLPOLocations;

  Function  Open:                                Boolean;
  Function  Open     (Location: TXMLPOLocation): Boolean;
  Property  ActiveLocation:     TXMLPOLocation;

  Property  ReadOnly:           Boolean;

  Procedure BeginUpdate;
  Property  Value        [Name: String]:               Variant;
  Property  ValueFmt     [Name: String; Fmt: Variant]: Variant;
  Procedure SaveObject   (Name: String;     Value:   TObject);
  Procedure LoadObject   (Name: String;     Value:   TObject);
  Property  Protect      [Name: String]: Boolean;
  Function  Exists       (Name: String): Boolean;
  Function  GetValueDef  (Name: String;     Default:           Variant): Variant;
  Function  GetValueDef  (Name: String;     Default, Min, Max: Variant): Variant;
  Function  TryGetValue  (Name: String; Var Value:             Variant): Boolean;
  Function  TryLoadObject(Name: String;     Value:             TObject): Boolean;
  Procedure DeleteValue  (Name: String);
  Procedure EndUpdate;

  Procedure Save     (Location: TXMLPOLocation; DeleteOther: Boolean);
  Procedure Close;
  Procedure Delete   (Location: TXMLPOLocation);
  Procedure DeleteAllOptionFiles;

  Property  OnSelectLocation:   TXMLPOSelectLocation;
  Property  OnException:        TXMLPOErrorProc;

  Function  GetPath  (Location: TXMLPOLocation): String;

  Property  Tag:                Integer;
End;

Vorallem die ...Def- und Try...-Funktionen würden überarbeitet/erweitert und es gab Änderungen in der Verzeichnisbehandlung.

Delphi-Quellcode:

Self.Left := Options.GetValueDef('window\left', Left);
ComboBox1.ItemIndex := Options.GetValueDef('view', 1, 0, ComboBox1.Items.Count - 1);

Als nächstes wird der SAX-Parser überarbeitet
und es wird eine Umkehrklasse dazu entstehen, also so das man auch sehr sehr große XML-Dateien effektiv erstellen kann.

[add]

Delphi-Quellcode:

Options.ValueFmt['directory\name%d', i]

hatte ich vergessen zu erwähnen ... dort kann man einen Parameter (aktuell leider nur String oder Integer) angeben, welcher dann via Format eingefügt wird ... wollte mir damit etwas das Leben erleichtern, da ich vorher soetwas hatte :shock:

Delphi-Quellcode:

Options.ValueFmt['directory\name' + IntToStr(i)]

[franktron]

Wie kann man den die Werte dieser XML Datei laden

XML-Code:

<?xml version="1.0"?>
<config>
   <port>35353</port>
  <username>frank</username>
   <password>12345</password>
   <server>lserv</server>
   <db>devtest</db>
   <dbport>3306</dbport>
</config>

Das ist mein Versuch

Delphi-Quellcode:

  XML:=TXMLFile.Create(nil);
  XML.LoadFromFile(FConfigPath+'config.xml');
  With XML.RootNode.Node['config'] do
  Begin
    FDB.Port:=StrToIntDef(Node['port'].Text,35353);
    FDB.Server:=Node['server'].Text;
    FDB.Username:=Node['username'].Text;
    FDB.Password:=Node['password'].Text;
    FDB.Database:=Node['db'].Text;
  End;

da kommt aber nie ein Text raus was mach ich falsch

[himitsu]

Der <config> ist bei dir schon der RootNode (es kann ja nur Einen geben :lol: )

Also einfach das .Node['config'] danach weglassen.

Ansonsten müßtest du über XML.Nodes gehen, da sind die ganzen Wurzelelemente drin enthalten.
> XML.Nodes.Node['config']



PS: RootNode gibt immer den ersten und einzigen Daten-Knoten der Datei zurück.

[franktron]

Danke jetzt gehts :D

[himitsu]

Zitat:

Zitat von franktron

Danke jetzt gehts :D

PS: wenn etwas nicht gefunden wird, kannst du auch mal xoNodeAutoCreate aus XML.Options entfernen, dann werden Exceptions geworfen.

in deinem Fall war es so, daß du auf Nodes zugreifen wolltest, welche nicht existierten und deßhalb automatisch angelegt wurden.

XML-Code:

<?xml version="1.0"?>
<config>
  <config>      
    <port\>
    <username\>
    <password\>
    <server\>
    <db\>
    <dbport\>
  </config>
  <port>35353</port>
  <username>frank</username>
  <password>12345</password>
  <server>lserv</server>
  <db>devtest</db>
  <dbport>3306</dbport>
</config>

[xZise]

Hallo,
ich wollte QuickDownload etwas umschreiben und deine Lib benutzen.

Nun habe ich folgendes:

Delphi-Quellcode:

procedure TForm4.Button1Click(Sender: TObject);
var
  XML : TXMLFile;
begin
  if SDSave.Execute then
  begin
    XML := TXMLFile.Create;
    try
      XML.Encoding := 'UTF-8';
      XML.RootNode.Name := 'qd2';
      XML.RootNode.AddNode('file');
      XML.RootNode.AddNode('file\filename').Text := EFilename.Text;
      XML.RootNode.AddNode('file\source').Text := ESource.Text;
      XML.RootNode.AddNode('file\description', xtCData).Text := MDescription.Text;
      XML.RootNode.AddNode('file\size').Text := SESize.Value;
// FLAGS      XML.RootNode.AddNode('file\').Text := SESize.Value;
      XML.RootNode.AddNode('file\destination').Text := SESize.Value;
      XML.SaveToFile(SDSave.FileName);
    finally
      XML.Free;
    end;
  end;
end;

Aber er meckert rum, wenn er versucht die Beschreibung zu speichern :)

Und könntest du nicht ein kleines Tutorial schreiben ;)

MfG
xZise

[himitsu]

Zitat:

Zitat von xZise

Aber er meckert rum, wenn er versucht die Beschreibung zu speichern :)

wer meckert wo rum?

Zitat:

text node can't constain subnodes

besagt ja sozusagen, das Problem ... CDATA ist ein Node, welcher keine anderen Geschwister-Nodes haben darf.

nun möchte dieser Code

Code:

XML.RootNode.Name := 'qd2';
XML.RootNode.AddNode('file');
XML.RootNode.AddNode('file\filename').Text := EFilename.Text;
XML.RootNode.AddNode('file\source').Text := ESource.Text;
[color=#ff0000]XML.RootNode.AddNode('file\description', xtCData)[/color].Text := MDescription.Text;
XML.RootNode.AddNode('file\size').Text := SESize.Value;
XML.RootNode.AddNode('file\destination').Text := SESize.Value;

soeine XML erstellen (welches natürlich nicht XML-konform wäre)

Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<qd2>
  <file>
    <filename>C:\EFilename.Text</filename>
    <source>ESource.Text</source>
    [color=#ff0000]<![CDATA[MDescription.Text]]>[/color]
    <size>SESize.Value</size>
    <destination>SESize.Value</destination>
  </file>
</qd2>

du möchtests aber eigentlich Dieses

Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<qd2>
  <file>
    <filename>C:\EFilename.Text</filename>
    <source>ESource.Text</source>
    [color=#ff0000]<description><![CDATA[MDescription.Text]]></description>[/color]
    <size>SESize.Value</size>
    <destination>SESize.Value</destination>
  </file>
</qd2>

nun gibt es mehrere Wege ... z.B.:

Delphi-Quellcode:

XML.RootNode.AddNode('file\description').AddNode('', xtCData).Text := MDescription.Text;

XML.RootNode.AddNode('file\description\', xtCData).Text := MDescription.Text;

Node := XML.RootNode.AddNode('file\description');
Node.asCDATA(True);
Node.Text := MDescription.Text;

ein Leername '' zum Erstellen, da der CDATA-Naode ja namenslos ist
(OK, eigentlich ist der Name dieses Nodes "CDATA", aber das ist ja egal und ich unterstützt diesbezüglich auch keine anderen Namen, drum der Leername, da hier der Name den Typ des Inhalts angibt und laut XML-Spec eh nur dieser Typ vordefiniert ist)

aber dank xoNodeAutoCreate und da UTF-8 eh Standard ist, würde ich es einfach nur so machen :stupid:

Delphi-Quellcode:

XML := TXMLFile.Create;
try
  XML.RootNode.Name := 'qd2';
  XML.Node['file\filename'].Text := EFilename.Text;
  XML.Node['file\source'].Text := ESource.Text;
  XML.Node['file\description'].asCDATA(True);
  XML.Node['file\description'].Text := MDescription.Text;
  XML.Node['file\size'].Text := SESize.Value;
  XML.Node['file\destination'].Text := SESize.Value;
  XML.SaveToFile(SDSave.FileName);
finally
  XML.Free;
end;

Zitat:

Und könntest du nicht ein kleines Tutorial schreiben

Mal sehn, ich versuche nebenbei mir endlich mal wieder eine Webseite auszubauen und in die dort enstehende Befehlsreferenz + kleine Hilfe könnte man bestimmt ein paar Beispiele und Dergleichen mit einbauen.
Aber erstmal muß die Webseite entstehen :?



Noch 'ne andere Frage.

Eigentlich hatte ich ja angefangen diese Klassen auch mit auf Interaces umzustellen,
nur gibt es da ein kleines Problem :?

Egal was ich Versuche, es bleibt dennoch ein Mischmasch aus Interfaces und Objekten,
sei es durch Verwendung von TStream und der ObjektSerialisierung und die Variants passen auch nicht so ganz mit den Interface-Philosophi zusammen.

Ja, es gibt IStream, aber das ist in Delphi komplett unabhngig von TStream und auch wenn ich mit dafür eigene Objekte erstellen, dann brauch ich auch noch einen Umweg zum normalen TStream, um auch diesen zu unterstützen.


Das Problem war gerade, daß ich nun mal endgültig auf Interfaces umstellen wollte, aber dieses einfach nicht komplett möglich ist :wall:

Nun bleibt also noch der andere Weg:
ich entferne die Interfaces wieder komlett raus und lasse alles einheitlich auf Objekten (dürfte auch etwas übersichtlich werden)



Würde sich also jemand drann stören, wenn ich nun doch zukünftig keine Objekte mehr anbieten werde?
(hatte ja eh immernoch das besch*** Problem mit der nicht richtig funktionierenden Referenzzählung)

Der Hauptgrund für die Interfaces war ja, daß ich ich mal sehr große XML-Dateien unterstützen wollte, ohne das man diese in den RAM kopieren muß (wenn es überhaupt möglich wäre).
Allerdings gibt es ja zum Lesen schon den SAX-Parser und demnächst entsteht auch noch ein SAX-Writer als Gegenstück ... und mit den Beiden wären ja ein sequentieller lesender oder schreibender Zugriff auf Dateien bis in den ExaBeyte-Bereich (64 Bit) möglich.

Außerdem sind schon Pläne für einen bedingt Schreibenden und Lesenden XML-LogFile-Writer vorhanden.
Welcher dann sozusagen und unter Bestimmten Bedinungen speichersparend (RAM) in beliebig große Dateien neue Daten/Nodes einfügen könnte.

Also meinerseits gibt es nun/bald keinen wichtigen Grund mehr für Interfaces. :freak:

[Satty67]

Zitat:

Zitat von himitsu

Würde sich also jemand drann stören, wenn ich nun doch zukünftig keine Objekte mehr anbieten werde?
[...]
Also meinerseits gibt es nun/bald keinen wichtigen Grund mehr für Interfaces.

:gruebel:

[himitsu]

ups ...

Zitat:

Würde sich also jemand drann stören, wenn ich nun doch zukünftig keine Interfaces mehr anbieten werde?

nja, aktuell ist es so, das man das ganze Projekt als Objekt-Version oder als Interface-Version kompilieren kann

TXMLFile, TXMLNode und Co.
oder
IXMLFile, IXMLNode und Co.

Weil ja Interfaces soooowas von "cool" sind, hatte ich mal angefangen alles auf Diese umzustellen
(aktuell noch umschaltbar)

Nur läßt sich einfach nicht alles nach diesem Schema nutzen und es wäre immer ein Mischmasch,
drum plane ich, die Interface-Version wieder rauszunehmen
und dafür alles durchweg komplett als mit Klassen zu machen.


Aktuell ist die Version mit Interfaces eh nicht so richtig nutzbar, aber könnte ja sein, daß wer darauf spekuliert hat, dieses später man nutzen zu können :angel2:

[Satty67]

Also ich kann auf Interfaces verzichten, hab' lieber was in der Hand ;)

Aber mich darf man nicht als Maß nehmen, bin sowieso mehr rustikal eingestellt...

[holliesoft]

Also auf die Interfaces kann auch ich verzichten.
Bin mit den Objekten zufrieden :-)

Bin sehr zufrieden mit himXML, würde gerne was spenden. Himitsu, hast Du ein Paypal Konto? Schreib doch evtl. eine kurze PM.

Gruß
Patrick

[himitsu]

Zitat:

Zitat von holliesoft

Bin sehr zufrieden mit himXML, würde gerne was spenden. Himitsu, hast Du ein Paypal Konto?

ein Link steht ganz oben mit in den Dateiheadern (falls ich den nicht ausversehn kaputtgemacht hab, beim Versuch die neue Webseite zu basteln)
[edit] ok, der geht gleich wieder ... nur noch schnell die HTML neu hochladen ._.

[xZise]

Ach ich dachte nicht das CData ein eigener Node ist. Danke :P

MfG
xZise

[franktron]

Ich habe ein seltsames Problem.

Und zwar bekomme ich unter Linux (Wine) immer eine Zugriffverletzung (Runtimer error 216) wenn in einem Project deine XML lib drin ist, sie muss auch nur eingebunden sein um das zu verursachen..

Was kann das sein.

[himitsu]

Dann wird es wohl ein Problem in der Initialisierung sein. :gruebel:

Da ich kein Linux bei mir und auch keine Erfahrungen mit Wine hab...

Könntest du es irgendwie debuggen?



Da es schon alleine beim Einfügen probleme gibt, dürfte das Problem wohl in der Prozedur TXMLFile.Initialize (in himXML.pas) zu suchen sein.

Dort werden im Problemfall einige Windows Funktionen verwendet.


Von den dort verwendeten Funktionen sollten TRTLCriticalSection, CopyMemory, ZeroMemory und CompareMem wohl keine Probleme machen und auch unter Wine laufen

CharLowerBuffW dürfte hottendlich auch keine Probleme machen, aber wenn es da Probleme beim Unicode (also bei den konvertierten Zeichen) gibt, wird versucht eine Log-Datei auf dem Desktop anzulegen,
wofür SHGetSpecialFolderLocation, SHGetPathFromIDList, CoTaskMemFree verwendet wird (um den Desktop zu finden).

Vielleicht weiß ja wer, ob es mit einigen der genannten Funktionen Probleme gibt.

Die Zugriffsverletzung könnte ja darauf hindeuten, daß es z.B. beim AssignFile oder schon bei der Ermittlng des Desktop-Verzeichnisses irgendwas nicht stimmt. (schon klar, da Linux ja 'nen anderen Ordneraufbau hat ... und ich schreibe ja für Windows :roll: )




*überleg* ich versuch mal ein kleines Testprojekt zu basteln, wird aber noch ein paar Minütchen dauern.


[add]
im Anhang ein Testprojekt - ist 'ne Konsolenanwendung, welche nur die Initialisierung enthält



[add]
ansonten kann ich nur erwähnen ... ich weiß aber nicht, wie lande ich noch benötigt ... daß ich fast das ganze Projekt grad umstelle und viele stellen überarbeite bzw. neu schreibe.

Das Interface der meißten Klasse bleibt aber soweit erhalten und es sollten demnach in der Verwendung keine großen Änderungen geben (hoff ich mal)

[franktron]

Das ist das Ergebnis

:1
:2
:3
:4
:5
Exception: Initialize 1

[pertzschc]

Hallo himitsu,
kannst Du abschätzen, ob und wann Du es noch für eine D7 verfügbar machen kannst?
Danke+Gruß,
Christoph

[himitsu]

Also das mit dem Wine war es dann erstmal (in der aktuellen Version werde ich das nicht mehr ändern)
werde aber versuchen es in Nächsten zu umgehen

Der Fehler tritt also hier auf und das weißt das woll auf eine kranke/bescheuerte/defekte UnicodeTabelle seiten Linux oder Wine hin.
Genauer gesagt auf eine Doppel/-belegung oder anders ausgerückt Groß- und Kleinschreibung stimmen nicht überein.

Delphi-Quellcode:

// copy uppercase chars + check for lower/upper collisions + create check char list
// + fill non-upper/lower chars (#0)
For C := Low(Chars) to High(Chars) do Begin
  If Chars2[C] <> C Then
    If Chars[C] = 0 Then Chars[C] := Chars2[C]
    Else Raise Exception.Create('Initialize 1');
  Chars2[C] := C;
  If Chars[C] = 0 Then Chars[C] := C;
End;

Aber nochmal zu dem Runtimfehler 216:
hast du die SysUtils vor himXML in dein Projekt eingefügt, oder erst danach, bzw. garnicht?


Und das mit dem Delphi 7 werd' ich dann sehn, aber jedenfalls werden (wenn es denn klappt) dort einige Funktionen verschwinden, da ich nicht alles so umschreiben kann/will, daß es dann auch da läuft (das wäre einfach zuviel Aufwand).

[franktron]

SysUtils ist als erstes im Project

P.S. wenn ich disen Block raus nehme läuft alles

[himitsu]

Zitat:

Zitat von franktron

P.S. wenn ich disen Block raus nehme läuft alles

Das Problem ist nur, daß über diese Blöcke die Groß-/Kleinschreibung im Projekt geregelt wird
und ohne diese die Stringvergleiche nicht mehr richtig arbeiten.

Ausdiesem Grunde wird ja auch in dieser Init-Prozedur so viel Verglichen und vorallem kontrolliert,
da es sonst zu unvorhersehbaren Problemen kommen kann,
wenn die Vergleichstabellen fehlerhaft sind.

Daß heißt ich muß erstmal eine alternative schaffen, da die Unicode-Tabelle definitiv defekt ist und sich auf diesen Wege da also nix machen läßt.

Das Einzige, welches du solange machen kannst, wäre zumindestens die fehlerhalften Werte zu übernehmen,
dann läuft dann wenigstens ein Großteil noch,

Delphi-Quellcode:

If Chars[C] = 0 Then Chars[C] := Chars2[C]
;//Else Raise EXMLException.CreateEx(....

aber wenn du dann eines der fehlerhaften Zeichen in deinen Texten hast (wie z.B. im Node-Text oder den Node-/Attribut-Namen), dann beschwere dich bitte nicht, wenn dort dann z.B. Einiges nicht gefunden wird oder es andersweitige Vergleichsprobleme gibt.

[himitsu]

OK, hier mal eine Protierung der neuen Prozedur (ich hoffe es läuft auch so)

Delphi-Quellcode:

.
    Class Procedure TXMLFile.Initialize;
      Procedure OpenLog(Var F: TextFile);
        Var i:  Integer;
          PIDL: Pointer;
          Path: Array[1..MAX_PATH] of Char;

        Begin
          If Succeeded(SHGetSpecialFolderLocation(0, 0{CSIDL_DESKTOP}, PIDL)) Then Begin
            If SHGetPathFromIDList(PIDL, @Path) Then Begin
              Try
                i := Length(ParamStr(0));
                While (i > 0) and (ParamStr(0)[i] <> '\') do Dec(i);
                AssignFile(F, String(PChar(@Path)) + '\' + Copy(ParamStr(0), i + 1, 888) + '.log');
                Try
                  {$i+}
                  Rewrite(F);
                Except
                  Raise EXMLException.Create(Self, 'Initialize', @SInternalError, [3]);
                End;
              Finally
                CoTaskMemFree(PIDL);
              End;
            End Else Begin
              CoTaskMemFree(PIDL);
              Raise EXMLException.Create(Self, 'Initialize', @SInternalError, [2]);
            End;
          End Else Raise EXMLException.Create(Self, 'Initialize', @SInternalError, [1]);
        End;

      Const toHex: Array[0..15] of Char = '0123456789ABCDEF';

      Var Chars, Chars2: Array[Word] of Word;
        C: Word;
        F: TextFile;
        i: Integer;

      Begin
        __DefaultOptions        := XMLDefaultOptions;
        __DefaultTextIndent     := '  ';
        __DefaultLineFeed       := sLineBreak;
        __DefaultValueSeperator := '=';
        __DefaultValueQuotation := '"';
        __PathDelimiter         := '\';

        InitializeCriticalSection(__ArrC_Lock);

        // create lower char list
        ZeroMemory(@Chars, SizeOf(Chars));
        For C := Low(Chars) to High(Chars) do Chars2[C] := C;
        CharLowerBuffW(@Chars2, Length(Chars));
        // copy lower blocks
        CopyMemory(@__LowerBlock0, @Chars2[Low(__LowerBlock0)], SizeOf(__LowerBlock0));
        CopyMemory(@__LowerBlock1, @Chars2[Low(__LowerBlock1)], SizeOf(__LowerBlock1));
        CopyMemory(@__LowerBlock2, @Chars2[Low(__LowerBlock2)], SizeOf(__LowerBlock2));
        CopyMemory(@__LowerBlock3, @Chars2[Low(__LowerBlock3)], SizeOf(__LowerBlock3));
        CopyMemory(@__LowerBlock4, @Chars2[Low(__LowerBlock4)], SizeOf(__LowerBlock4));
        CopyMemory(@__LowerBlock5, @Chars2[Low(__LowerBlock5)], SizeOf(__LowerBlock5));
        CopyMemory(@__LowerBlock6, @Chars2[Low(__LowerBlock6)], SizeOf(__LowerBlock6));
        CopyMemory(@__LowerBlock7, @Chars2[Low(__LowerBlock7)], SizeOf(__LowerBlock7));
        CopyMemory(@__LowerBlock8, @Chars2[Low(__LowerBlock8)], SizeOf(__LowerBlock8));
        CopyMemory(@__LowerBlock9, @Chars2[Low(__LowerBlock9)], SizeOf(__LowerBlock9));
        CopyMemory(@__LowerBlockA, @Chars2[Low(__LowerBlockA)], SizeOf(__LowerBlockA));
        // copy lowercase chars
        For C := Low(Chars) to High(Chars) do Begin
          If Chars2[C] <> C Then Chars[C] := Chars2[C];
          Chars2[C] := C;
        End;
        // create upper char list
        For C := Low(Chars) to High(Chars) do Chars2[C] := C;
        CharUpperBuffW(@Chars2, Length(Chars));
        // copy uppercase chars + check for lower/upper collisions + create check char list
        // + fill non-upper/lower chars (#0)
        For C := Low(Chars) to High(Chars) do Begin
          If Chars2[C] <> C Then
            If Chars[C] <> 0 Then Begin
              __CompareBlock0[Low(__CompareBlock0)] := #0;
              OpenLog(F);
              Try
                WriteLn(F, '>>> himXML - initialize error <<<');
                WriteLn(F, 'please contact the software distributor');
                WriteLn(F, 'file:');
                WriteLn(F, '  ', ParamStr(0));
                WriteLn(F, 'date:');
                WriteLn(F, '  ', DateTimeToStr(Now));
                WriteLn(F, 'info:');
                WriteLn(F, '  C         = #', Ord(C));
                WriteLn(F, '  Chars2[C] = #', Ord(Chars2[C]));
                WriteLn(F, '  Chars[C]  = #', Ord(Chars[C]));
                WriteLn(F);
                WriteLn(F, '*end*');
              Finally
                CloseFile(F);
              End;
              Exit;
            End Else Chars[C] := Chars2[C];
          Chars2[C] := C;
          If Chars[C] = 0 Then Chars[C] := C;
        End;
        // copy upper/lower blocks
        CopyMemory(@__CompareBlock0, @Chars[Low(__CompareBlock0)], SizeOf(__CompareBlock0));
        CopyMemory(@__CompareBlock1, @Chars[Low(__CompareBlock1)], SizeOf(__CompareBlock1));
        CopyMemory(@__CompareBlock2, @Chars[Low(__CompareBlock2)], SizeOf(__CompareBlock2));
        CopyMemory(@__CompareBlock3, @Chars[Low(__CompareBlock3)], SizeOf(__CompareBlock3));
        CopyMemory(@__CompareBlock4, @Chars[Low(__CompareBlock4)], SizeOf(__CompareBlock4));
        CopyMemory(@__CompareBlock5, @Chars[Low(__CompareBlock5)], SizeOf(__CompareBlock5));
        CopyMemory(@__CompareBlock6, @Chars[Low(__CompareBlock6)], SizeOf(__CompareBlock6));
        CopyMemory(@__CompareBlock7, @Chars[Low(__CompareBlock7)], SizeOf(__CompareBlock7));
        CopyMemory(@__CompareBlock8, @Chars[Low(__CompareBlock8)], SizeOf(__CompareBlock8));
        CopyMemory(@__CompareBlock9, @Chars[Low(__CompareBlock9)], SizeOf(__CompareBlock9));
        CopyMemory(@__CompareBlockA, @Chars[Low(__CompareBlockA)], SizeOf(__CompareBlockA));
        // "delete" upper/lower blocks from char list
        CopyMemory(@Chars2[Low(__CompareBlock0)], @__CompareBlock0, SizeOf(__CompareBlock0));
        CopyMemory(@Chars2[Low(__CompareBlock1)], @__CompareBlock1, SizeOf(__CompareBlock1));
        CopyMemory(@Chars2[Low(__CompareBlock2)], @__CompareBlock2, SizeOf(__CompareBlock2));
        CopyMemory(@Chars2[Low(__CompareBlock3)], @__CompareBlock3, SizeOf(__CompareBlock3));
        CopyMemory(@Chars2[Low(__CompareBlock4)], @__CompareBlock4, SizeOf(__CompareBlock4));
        CopyMemory(@Chars2[Low(__CompareBlock5)], @__CompareBlock5, SizeOf(__CompareBlock5));
        CopyMemory(@Chars2[Low(__CompareBlock6)], @__CompareBlock6, SizeOf(__CompareBlock6));
        CopyMemory(@Chars2[Low(__CompareBlock7)], @__CompareBlock7, SizeOf(__CompareBlock7));
        CopyMemory(@Chars2[Low(__CompareBlock8)], @__CompareBlock8, SizeOf(__CompareBlock8));
        CopyMemory(@Chars2[Low(__CompareBlock9)], @__CompareBlock9, SizeOf(__CompareBlock9));
        CopyMemory(@Chars2[Low(__CompareBlockA)], @__CompareBlockA, SizeOf(__CompareBlockA));
        // check for chars out of upper/lower blocks
        If not CompareMem(@Chars, @Chars2, SizeOf(Chars)) Then Begin
          __CompareBlock0[Low(__CompareBlock0)] := #0;
          OpenLog(F);
          Try
            WriteLn(F, '>>> himXML - initialize error <<<');
            WriteLn(F, 'please contact the software distributor');
            WriteLn(F, 'file:');
            WriteLn(F, '  ', ParamStr(0));
            WriteLn(F, 'date:');
            WriteLn(F, '  ', DateTimeToStr(Now));
            WriteLn(F, 'chars:');
            For C := Low(Chars) to High(Chars) do
              If Chars[C] <> Chars2[C] Then Begin
                Write(F, '  ');
                For i := 3 downto 0 do Write(F, toHex[(C shr (i * 4)) and $0F]);
                Write(F, ' [', C:5, ']: ');
                For i := 3 downto 0 do Write(F, toHex[(Ord(Chars[C]) shr (i * 4)) and $0F]);
                Write(F, ' ');
                For i := 3 downto 0 do Write(F, toHex[(Ord(Chars2[C]) shr (i * 4)) and $0F]);
                WriteLn(F);
              End;
            WriteLn(F);
            WriteLn(F, '*end*');
          Finally
            CloseFile(F);
          End;
        End;
      End;

> hab nur die wichtigen Teile rübergezogen und in die alte Initprozedur eingefügt
> und konnte es jetzt noch nicht testen

[himitsu]

Ich glaub mein neuer XML-Reader ist fast fertig.

Hab das Parsen der Datei aus TXMLFile rausgelöst und werde die nächsten Tage in die anderen Klassen dann den Reader einbinden ... somit haben dann alle Klassen (vorallem TXMLFile und TSAXFile) den selben Parser im Hintergrund und nicht jeder seine eigene Version.

Dieser parst allerdings nur die Datei und ihn interessiert die Verschachtelung überhaupt nicht.

Im Ganzen hochladen kann/möchte ich das Projekt jetzt nicht, da dort noch zuviel nicht wieder geht bzw. einfach schlimm aussieht.

Die EXE im Anhang enthält diesen Code

Delphi-Quellcode:

Var C: LongWord;
  S: WideString;
  R: TXReader;
  F: TStream;
  SL: TStringList;

C := GetTickCount;
S := '';
F := TFileStream.Create('test.xml', fmOpenRead);
R := TXReader.Create(F, [], #13#10);
SL := TStringList.Create;
Try
  While R.Parse do Begin
    Case R.DataType of
      xdInstruction:  Begin
                        SL.Add(S + 'xdInstruction:   Name="' + R.Name + '"');
                        Insert('  ', S, 1);
                      End;
      xdTypedef:      Begin
                        SL.Add(S + 'xdTypedef:   Name="' + R.Name + '"');
                        Insert('  ', S, 1);
                      End;
      xdElement:      Begin
                        SL.Add(S + 'xdElement:   Name="' + R.Name + '"');
                        Insert('  ', S, 1);
                      End;
      xdCData:        Begin
                        SL.Add(S + 'xdCData:   Name="' + R.Name + '"');
                        Insert('  ', S, 1);
                      End;
      xdComment:      Begin
                        SL.Add(S + 'xdComment:   -');
                        Insert('  ', S, 1);
                      End;
      xdAttribute:    SL.Add(S + 'xdAttribute:   Name="' + R.Name + '"   Value="' + R.Value + '"');
      xdEndAttribute: SL.Add(S + 'xdEndAttribute:   -');
      xdText:         SL.Add(S + 'xdText:   Value="' + R.Value + '"');
      xdClose:        Begin
                        Delete(S, 1, 2);
                        SL.Add(S + 'xdClose:   Name="' + R.Name + '"');
                      End;
      xdCloseSingle:  Begin
                        Delete(S, 1, 2);
                        SL.Add(S + 'xdCloseSingle:   -');
                      End;
    End;
    If GetTickCount - C > 15000 Then Begin
      SL.Add('> TimeOut <');
      Break;
    End;
  End;
  SL.Add('> ' + IntToStr(GetTickCount - C) + ' ms <');
  //Memo1.Lines.Assign(SL);
  Memo1.Lines.BeginUpdate;
  Try
    c := GetTickCount;
    i := 0;
    While i < SL.Count do Begin
      Memo1.Lines.Add(SL[i]);
      If (GetTickCount - C > 45000) and (i + 20 < SL.Count) Then Begin
        Memo1.Lines.Add('');
        Memo1.Lines.Add('...');
        Memo1.Lines.Add('');
        For i := SL.Count - 20 to SL.Count - 1 do
          Memo1.Lines.Add(SL[i]);
        Break;
      End;
      Inc(i);
    End;
  Finally
    Memo1.Lines.EndUpdate
  End;
Finally
  SL.Free;
  R.Free;
  F.Free;
End;

und macht aus dem

XML-Code:

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet href="selfxml.xsl" type="text/xsl" ?>
<Programm>
  <Information>
    <Name>Hans Wurst</Name>
    <Datum>01.10.2009</Datum>
  </Information>
</Programm>

dieses hier

Code:

xdInstruction:   Name="xml"
  xdAttribute:   Name="version"   Value="1.0"
  xdAttribute:   Name="encoding"   Value="ISO-8859-1"
xdCloseSingle:   -
xdInstruction:   Name="xml-stylesheet"
  xdAttribute:   Name="href"   Value="selfxml.xsl"
  xdAttribute:   Name="type"   Value="text/xsl"
xdCloseSingle:   -
xdElement:   Name="Programm"
  xdEndAttribute:   -
  xdElement:   Name="Information"
    xdEndAttribute:   -
    xdElement:   Name="Name"
      xdEndAttribute:   -
      xdText:   Value="Hans Wurst"
    xdClose:   Name="Name"
    xdElement:   Name="Datum"
      xdEndAttribute:   -
      xdText:   Value="01.10.2009"
    xdClose:   Name="Datum"
  xdClose:   Name="Information"
xdClose:   Name="Programm"
> 0 ms <

(eine 29 MB-Datei wird bei mir innerhalb von 2375 ms in die StringListe eingelesen)

falls wer zufällig erkennt, daß da bei seinen Dateien (es wird eine Datei Namens "test.xml" im Programmverzeichnis geladen) irgendwas nicht stimmen kann, so möge er/sie sich bitte melden.

[edit]
ich merk grad, daß bei Kommentaren und Dergleichen der Text falsch gelesen wird :shock:
[edit2]
ich hoff der Fehler ist jetzt behoben
[edit3]
die Gesamtlaufzeit ist auf eine Minute begrenzt wurden
maximal 15 Sekunden Lesen und 45 Sekunden zum füllen des Memos (nicht daß das Programm "ewig" läuft)

[himitsu]

!!! ACHTUNG !!!
In der aktuellen Version gibt es einen Bug, welcher bei Dateien über 32 KB (der internen Puffergröße) Auftritt.

Bisher dachte ich, dieses liegt an einer meiner Testdateien, welche womöglich inkorrekte Daten enthält (welche ich jedoch nie fand),
da sich bisher sonst noch keiner über diesen Fehler beschwerte.

Bei der Umstellung der Codes stellte sich aber raus, daß es doch ein Bug beim Nachladen des Puffers ist,
welcher Auftritt, wenn rein zufällig der Text eines Attributes über die Puffergrenze ragt und an dieser Stelle nachgeladen werden mußte.


In den neuen Codes ist der Fehler nun behoben (es dauert aber noch etwas, bis es fertig zum Hochladen ist),
aber leider finde ich die betreffende Stelle nicht im alten/aktuellen Code.


Also unter 32 KB gibt es diesbezüglich keine Probleme und bei größeren Dateien tritt er wohl recht selten auf.
Wenn ich das auf meine über 312 MB an Testdateien beziehe, dann werden über 95% davon, trotzt Bug, erfolgreich gelesen.
Außerdem existiert dieser Bug schon von Anfang an und es gab dennoch keine beschwerden. :nerd:

[himitsu]

Der neue interne Parser (TXReader) und sein Gegenstück (TXWriter) sind hoffentlich fertig.

- TXMLFile und Co. scheint, nach dem Umbau, nun auch wieder zu laufen
- hab dort unter Anderem das Parsen ausgebaut und in extra Klassen verlagert
- so kann ich demnächst (möchte nur noch einige Tests machen) diesen gemeinsamen Parser auch in TSAXFile einbauen und es hat dann nicht mehr jeder seine eigene Parser-Version
- TSAXFile läuft aber aktuell nicht, da ich wegen nun fehlender Strukturen so Einiges auskommentieren mußte
- die ganzen Interfaces und zugeförige Codes/Umleitungen wurden entfernt
- die Tools wurden in eigene Units ausgelagert
- die mindestens benötigten Hauptunits wären: himXML.pas, himXML_Lang.pas und himXMLCheck.inc

- nja, werd' noch etwas Zeit benötigen, bis wieder alles richtig läuft ... ist halt viel geändert wurden,
aber an den öffentlichen Interfaces der Hauptklassen wurde kaum was verändert :angel:
- nur bei der Record-Serialisierung wurde das InfoRecord durch eine Klasse ersetzt, welche sich nun selbst verwaltet und dafür entfiehl der InfoRecord-Creator aus/in der Demo
- und der letztens erwähnte Bug is weg (na mal sehn, welche Neuen dafür nun reingekommen sind :nerd: )

Anhang (Beta) zum Reinschnuppern liegt im 1. Beitrag

[himitsu]

kleine Fehler behoben (Dateien siehe Post #1)

* so wurden z.B. die Texte von Kommentaren und CDATA-Bereichen als Extra-Node gespeichert
* die ParsedSingleTags werden auch wieder unterstützt, auch wenn die wohl keiner nutzt,
da man sowas wie
(aus HTML und nicht als geschlossener EinzelTag gekenneichnet, also nicht als
) in XML normalerweise nicht antrifft
* und andere Kleinigkeiten



Nun noch der Hauptgrund dieses Posts ... mal eine Frage

Und zwar suche ich einen/zwei Namen für neue Properties,
welche in Verbindung mit der Textformatierung und der grad eingebauten Normalisierung stehen.

einmal suche ich einen Namen für diese Formatierung, wo jedes Attribut eines Nodes in einer eigenen Zeile steht

XML-Code:

<node
  attr1 = "text"
  attr2 = "text"
  attr3 = "text">

statt

<node attr1="text" attr2="text" attr3="text">

und ein Name fpr eine Option, wo der NodeText in eine eigene Zeile rutscht

XML-Code:

<node>
  text
</node>

statt

<node>text</node>

(diese Opionen können dann für jeden Node getrennt zugeschaltet werden)

praktisch wie man es von hier kennt, damit die Dateien dann eventuell menschenlesbarer werden

Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
  <assemblyIdentity
    [color=#0000ff]version="0.0.0.0"
    processorArchitecture="X86"
    name="Private.Unbekannt.MeineBeispielApp"
    type="Win32"[/color]/>
  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
    <security>
      <requestedPrivileges>
        <requestedExecutionLevel
          [color=#0000ff]level="asInvoker"
          uiAccess="false"[/color]/>
      </requestedPrivileges>
    </security>
  </trustInfo>
  <dependency>
    <dependentAssembly>
      <assemblyIdentity
        [color=#0000ff]type="win32"
        name="Microsoft.Windows.Common-Controls"
        version="6.0.0.0"
        publicKeyToken="6595b64144ccf1df"
        language="*"
        processorArchitecture="*"[/color]/>
    </dependentAssembly>
  </dependency>
</assembly>

[Hawkeye219]

Hallo himitsu,

was hältst du von "WrapAttributes" und "WrapText"?

Gruß Hawkeye

[himitsu]

hmmm, klingt schonmal nicht schlecht,
wobei WrapText irgendwie nach einer weiteren noch unbekannten Option klingt, welche ebenfallt fehlt :oops:

Es gibt ja Editoren (dazu gehört auch Delphi's IDE), welche nicht mit zu langen Zeilen klarkommen (z.B. maximal 1024 Zeichen) und dafür bräuchte ich auch noch eine Option, um dieses zu (de)aktivieren.

[holliesoft]

Hi,

wie wäre es mit IndendNodeText?

Bin schon gespannt auf die Version mit den neuen Optionen. Werde dann auch nochmal Paypal bemühen :thumb:

Grüße
Patrick

[GerMan62]

Hallo,

geht die neue Beta auch für Delphi 7 oder Delphi 2007

[himitsu]

Für 2007 dürfte sie gehn

Hab es nicht nochmal getestet, aber Turbo, 2006, 2007 und 2009 sollte (hoffentlich) gehn.
Für 2010 fehlen noch einige Sachen der neuen RTTI.
Bei 2005 hab ich absolut keine Ahnung, ob es geht ... kann, muß aber nicht.
Und vor 2006 gab es einige verwendete Sprachkonstrukte noch nicht, daraum geht es aktuell nicht, da es noch nicht für alles eine "Alternative" eingebaut ist.

Wenn es Probleme mit dem Record TIndex gibt, dann läßt sich dieser abschalten.
(einfach den Compilerschalter hxExcludeTIndex in den Projektoptionen eintragen)


Bin grad etwas mit PHP ausgelastet ... mal sehn wann/ob meine Webseite fertig ist, wo dann eine Online-Hilfe eingebaut wird.

[GerMan62]

Hallo,

beim Kompilieren der neuen Beta Version mit Delphi 2007 meldet er folgende Kompileranweisungen als unbekannt.

{$POINTERMATH OFF}
{$STRINGCHECKS OFF}

Wenn ich sie auskommentiere bringt er z.B. hier einen Fehler.

{$IF Declared(UnicodeString)}
----> varUString, varUString or varByRef: Begin
_Attributes['variant'] := 'WideString';
If TVarData(V).VType and varByRef = 0 Then
Text_S := UnicodeString(TVarData(V).VUString)
Else Text_S := PUnicodeString(TVarData(V).VPointer)^;
End;
{$IFEND}

[DCC Fehler] himXML.pas(5110): E2003 Undefinierter Bezeichner: 'varUString'


Insgesammt bringt er so ca. 28 Fehler.

Kannst Du mir da bitte etwas helfen.

Danke

[himitsu]

{$POINTERMATH OFF} kennt 2007 das nicht?
ich dachte das wäre schon vor unzähligen Jahren eingeführt worden :gruebel:

{$STRINGCHECKS OFF} ok, das ist in D2009/D2010 neu und wird prompt behoben

{$IF Declared(UnicodeString)}
ich wollte schon sagen "häääää? das geht doch nicht", da UnicodeString erst ab D2009 existiert und demnach es vom Compiler hätte ignoriert werden müssen,
aber da bin ich selber dran Schuld und werd' mir dann mal was ausdenken müssen :oops:

das Letzte ist aktuell soein ähnliches Problem, warum himXML noch nicht im D2010 läuft

wird aber ein paar Minuten dauern (werd's wohl morgen geändert haben ... mach erstmal was anderes fertig, nicht daß ich noch durcheinanderkomm)