jcl-checkins-diff Mailing List for JEDI Code Library (Page 5)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 3792
          http://jcl.svn.sourceforge.net/jcl/?rev=3792&view=rev
Author:   outchy
Date:     2012-05-10 19:34:22 +0000 (Thu, 10 May 2012)
Log Message:
-----------
Mantis 5785: TJclSimpleXMLProps should not use IniFiles.THashedStringList: replace THashedStringList by TStringHash.

Modified Paths:
--------------
    trunk/jcl/source/common/JclSimpleXml.pas

Modified: trunk/jcl/source/common/JclSimpleXml.pas
===================================================================

--- trunk/jcl/source/common/JclSimpleXml.pas	2012-05-07 14:18:53 UTC (rev 3791)
+++ trunk/jcl/source/common/JclSimpleXml.pas	2012-05-10 19:34:22 UTC (rev 3792)
@@ -46,32 +46,70 @@
   JclUnitVersioning,
   {$ENDIF UNITVERSIONING}
   {$IFDEF HAS_UNITSCOPE}
+  {$IFDEF HAS_UNIT_RTLCONSTS}
+  System.RTLConsts,
+  {$ENDIF HAS_UNIT_RTLCONSTS}
   {$IFDEF MSWINDOWS}
   Winapi.Windows, // Delphi 2005 inline
   {$ENDIF MSWINDOWS}
   System.SysUtils, System.Classes,
   System.Variants,
   System.IniFiles,
+  System.Contnrs,
   {$ELSE ~HAS_UNITSCOPE}
+  {$IFDEF HAS_UNIT_RTLCONSTS}
+  RTLConsts,
+  {$ENDIF HAS_UNIT_RTLCONSTS}
   {$IFDEF MSWINDOWS}
   Windows, // Delphi 2005 inline
   {$ENDIF MSWINDOWS}
   SysUtils, Classes,
   Variants,
   IniFiles,
+  Contnrs,
   {$ENDIF ~HAS_UNITSCOPE}
   JclBase, JclStreams;
 
 type
-  TJclSimpleData = class(TObject)
+  TJclSimpleItem = class(TObject)
   private
     FName: string;
+  protected
+    procedure SetName(const Value: string); virtual;
+  public
+    property Name: string read FName write SetName;
+  end;
+
+type
+  TJclSimpleItemHashedList = class(TObjectList)
+  private
+    FNameHash: TStringHash;
+    function GetSimpleItemByName(const Name: string): TJclSimpleItem;
+    function GetSimpleItem(Index: Integer): TJclSimpleItem;
+  protected
+    procedure Notify(Ptr: Pointer; Action: TListNotification); override;
+  public
+    constructor Create;
+    destructor Destroy; override;
+    function Add(Item: TJclSimpleItem): Integer;
+    procedure Clear; override;
+    function IndexOfSimpleItem(Item: TJclSimpleItem): Integer;
+    function IndexOfName(const Name: string): Integer;
+    procedure Insert(Index: Integer; Item: TJclSimpleItem);
+    procedure InvalidateHash;
+    procedure Move(CurIndex, NewIndex: Integer);
+    property SimpleItemByNames[const Name: string]: TJclSimpleItem read GetSimpleItemByName;
+    property SimpleItems[Index: Integer]: TJclSimpleItem read GetSimpleItem;
+  end;
+
+type
+  TJclSimpleData = class(TJclSimpleItem)
+  private
     FValue: string;
     FData: Pointer;
   protected
     function GetBoolValue: Boolean;
     procedure SetBoolValue(const Value: Boolean);
-    procedure SetName(const Value: string); virtual;
     function GetFloatValue: Extended;
     procedure SetFloatValue(const Value: Extended);
     function GetAnsiValue: AnsiString;
@@ -79,10 +117,9 @@
     function GetIntValue: Int64;
     procedure SetIntValue(const Value: Int64);
   public
-    constructor Create; overload; virtual; 
+    constructor Create; overload; virtual;
     constructor Create(const AName: string); overload;
     constructor Create(const AName, AValue: string); overload;
-    property Name: string read FName write SetName;
     property Value: string read FValue write FValue;
     property AnsiValue: AnsiString read GetAnsiValue write SetAnsiValue;
     property IntValue: Int64 read GetIntValue write SetIntValue;
@@ -227,7 +264,7 @@
 
   TJclSimpleXMLElemsProlog = class(TObject)
   private
-    FElems: THashedStringList;
+    FElems: TJclSimpleItemHashedList;
     function GetCount: Integer;
     function GetItem(const Index: Integer): TJclSimpleXMLElem;
     function GetEncoding: string;
@@ -275,14 +312,14 @@
   end;
   {$ENDIF SUPPORTS_FOR_IN}
 
-  TJclSimpleXMLNamedElems = class(TObject)
+  TJclSimpleXMLNamedElems = class(TJclSimpleItem)
   private
     FElems: TJclSimpleXMLElems;
-    FName: string;
     function GetCount: Integer;
   protected
     FItems: TList;
     function GetItem(const Index: Integer): TJclSimpleXMLElem;
+    procedure SetName(const Value: string); override;
   public
     constructor Create(AElems: TJclSimpleXMLElems; const AName: string);
     destructor Destroy; override;
@@ -308,7 +345,6 @@
     property Elems: TJclSimpleXMLElems read FElems;
     property Item[const Index: Integer]: TJclSimpleXMLElem read GetItem; default;
     property Count: Integer read GetCount;
-    property Name: string read FName;
   end;
 
   {$IFDEF SUPPORTS_FOR_IN}
@@ -333,15 +369,16 @@
     function GetItemNamed(const Name: string): TJclSimpleXMLElem;
     function GetNamedElems(const Name: string): TJclSimpleXMLNamedElems;
   protected
-    FElems: THashedStringList;
+    FElems: TJclSimpleItemHashedList;
     FCompare: TJclSimpleXMLElemCompare;
-    FNamedElems: THashedStringList;
+    FNamedElems: TJclSimpleItemHashedList;
     function GetItem(const Index: Integer): TJclSimpleXMLElem;
     procedure AddChild(const Value: TJclSimpleXMLElem);
     procedure AddChildFirst(const Value: TJclSimpleXMLElem);
     procedure InsertChild(const Value: TJclSimpleXMLElem; Index: Integer);
     procedure DoItemRename(Value: TJclSimpleXMLElem; const Name: string);
     procedure CreateElems;
+    function SimpleCompare(Elems: TJclSimpleXMLElems; Index1, Index2: Integer): Integer;
   public
     constructor Create(AParent: TJclSimpleXMLElem);
     destructor Destroy; override;
@@ -641,20 +678,11 @@
   cBufferSize = 8192;
 
 var
-  GlobalSorts: TList = nil;
-
   GlobalXMLVariant: TXMLVariant = nil;
 
   PreparedNibbleCharMapping: Boolean = False;
   NibbleCharMapping: array [Low(Char)..High(Char)] of Byte;
 
-function GSorts: TList;
-begin
-  if not Assigned(GlobalSorts) then
-    GlobalSorts := TList.Create;
-  Result := GlobalSorts;
-end;
-
 function XMLVariant: TXMLVariant;
 begin
   if not Assigned(GlobalXMLVariant) then
@@ -974,6 +1002,98 @@
   SimpleXMLDecode(Result, False);
 end;
 
+//=== { TJclSimpleItem } =====================================================
+
+procedure TJclSimpleItem.SetName(const Value: string);
+begin
+  FName := Value;
+end;
+
+//=== { TJclSimpleItemHashedList } ===========================================
+
+procedure TJclSimpleItemHashedList.Clear;
+begin
+  InvalidateHash;
+  inherited Clear;
+end;
+
+constructor TJclSimpleItemHashedList.Create;
+begin
+  inherited Create(True);
+end;
+
+destructor TJclSimpleItemHashedList.Destroy;
+begin
+  FreeAndNil(FNameHash);
+  inherited Destroy;
+end;
+
+function TJclSimpleItemHashedList.Add(Item: TJclSimpleItem): Integer;
+begin
+  Result := inherited Add(Item);
+  if FNameHash <> nil then
+    FNameHash.Add(Item.Name, Result);
+end;
+
+function TJclSimpleItemHashedList.GetSimpleItem(Index: Integer): TJclSimpleItem;
+begin
+  Result := TJclSimpleItem(GetItem(Index));
+end;
+
+function TJclSimpleItemHashedList.GetSimpleItemByName(const Name: string): TJclSimpleItem;
+var
+  I: Integer;
+begin
+  I := IndexOfName(Name);
+  if I >= 0 then
+    Result := TJclSimpleItem(Items[I])
+  else
+    Result := nil;
+end;
+
+function TJclSimpleItemHashedList.IndexOfSimpleItem(Item: TJclSimpleItem): Integer;
+begin
+  Result := IndexOf(Item);
+end;
+
+function TJclSimpleItemHashedList.IndexOfName(const Name: string): Integer;
+var
+  I: Integer;
+begin
+  if FNameHash = nil then
+  begin
+    FNameHash := TStringHash.Create(8);
+    for I := 0 to Count - 1 do
+      FNameHash.Add(TJclSimpleData(Items[I]).Name, I);
+  end;
+
+  Result := FNameHash.ValueOf(Name);
+end;
+
+procedure TJclSimpleItemHashedList.Insert(Index: Integer; Item: TJclSimpleItem);
+begin
+  InvalidateHash;
+  inherited Insert(Index, Item);
+end;
+
+procedure TJclSimpleItemHashedList.InvalidateHash;
+begin
+  FreeAndNil(FNameHash);
+end;
+
+procedure TJclSimpleItemHashedList.Move(CurIndex, NewIndex: Integer);
+begin
+  InvalidateHash;
+  inherited Move(CurIndex, NewIndex);
+end;
+
+procedure TJclSimpleItemHashedList.Notify(Ptr: Pointer; Action: TListNotification);
+begin
+  if (Action = lnDeleted) and (FNameHash <> nil) then
+    FNameHash.Remove(TJclSimpleItem(Ptr).Name);
+  inherited Notify(Ptr, Action);
+end;
+
 //=== { TJclSimpleData } =====================================================
 
 constructor TJclSimpleData.Create;
@@ -1036,11 +1156,6 @@
   FValue := IntToStr(Value);
 end;
 
-procedure TJclSimpleData.SetName(const Value: string);
-begin
-  FName := Value;
-end;
-
 //=== { TJclSimpleXMLData } ==================================================
 
 function TJclSimpleXMLData.FullName: string;
@@ -1573,13 +1688,12 @@
   Stream.Write(Buf, J);
 end;
 
-function TJclSimpleXMLElem.GetChildIndex(
-  const AChild: TJclSimpleXMLElem): Integer;
+function TJclSimpleXMLElem.GetChildIndex(const AChild: TJclSimpleXMLElem): Integer;
 begin
   if FItems = nil then
     Result := -1
   else
-    Result := FItems.FElems.IndexOfObject(AChild);
+    Result := FItems.FElems.IndexOfSimpleItem(AChild);
 end;
 
 function TJclSimpleXMLElem.GetChildsCount: Integer;
@@ -1846,6 +1960,11 @@
   FItems.Move(CurIndex, NewIndex);
 end;
 
+procedure TJclSimpleXMLNamedElems.SetName(const Value: string);
+begin
+  raise EJclSimpleXMLError.CreateRes(@SReadOnlyProperty);
+end;
+
 //=== { TJclSimpleXMLElemsEnumerator } =======================================
 
 {$IFDEF SUPPORTS_FOR_IN}
@@ -1936,13 +2055,13 @@
   if Assigned(Value.Parent) then
     Value.Parent.Items.Notify(Value, opRemove);
 
-  FElems.AddObject(Value.Name, Value);
+  FElems.Add(Value);
 
   if FNamedElems <> nil then
   begin
-    NamedIndex := FNamedElems.IndexOf(Value.Name);
+    NamedIndex := FNamedElems.IndexOfName(Value.Name);
     if NamedIndex >= 0 then
-      TJclSimpleXMLNamedElems(FNamedElems.Objects[NamedIndex]).FItems.Add(Value);
+      TJclSimpleXMLNamedElems(FNamedElems.SimpleItems[NamedIndex]).FItems.Add(Value);
   end;
 
   Notify(Value, opInsert);
@@ -1958,13 +2077,13 @@
   if Assigned(Value.Parent) then
     Value.Parent.Items.Notify(Value, opRemove);
 
-  FElems.InsertObject(0, Value.Name, Value);
+  FElems.Insert(0, Value);
 
   if FNamedElems <> nil then
   begin
-    NamedIndex := FNamedElems.IndexOf(Value.Name);
+    NamedIndex := FNamedElems.IndexOfName(Value.Name);
     if NamedIndex >= 0 then
-      TJclSimpleXMLNamedElems(FNamedElems.Objects[NamedIndex]).FItems.Insert(0, Value);
+      TJclSimpleXMLNamedElems(FNamedElems.SimpleItems[NamedIndex]).FItems.Insert(0, Value);
   end;
 
   Notify(Value, opInsert);
@@ -2027,28 +2146,11 @@
 end;
 
 procedure TJclSimpleXMLElems.Clear;
-var
-  I: Integer;
 begin
   if FElems <> nil then
-  begin
-    for I := 0 to FElems.Count - 1 do
-    begin
-      // TJclSimpleXMLElem(FElems.Objects[I]).Clear; // (p3) not needed -called in Destroy
-      FElems.Objects[I].Free;
-      FElems.Objects[I] := nil;
-    end;
     FElems.Clear;
-  end;
   if FNamedElems <> nil then
-  begin
-    for I := 0 to FNamedElems.Count - 1 do
-    begin
-      FNamedElems.Objects[I].Free;
-      FNamedElems.Objects[I] := nil;
-    end;
     FNamedElems.Clear;
-  end;
 end;
 
 constructor TJclSimpleXMLElems.Create(AParent: TJclSimpleXMLElem);
@@ -2060,7 +2162,7 @@
 procedure TJclSimpleXMLElems.CreateElems;
 begin
   if FElems = nil then
-    FElems := THashedStringList.Create;
+    FElems := TJclSimpleItemHashedList.Create;
 end;
 
 procedure TJclSimpleXMLElems.Delete(const Index: Integer);
@@ -2070,23 +2172,22 @@
 begin
   if (FElems <> nil) and (Index >= 0) and (Index < FElems.Count) then
   begin
-    Elem := TJclSimpleXMLElem(FElems.Objects[Index]);
+    Elem := TJclSimpleXMLElem(FElems.SimpleItems[Index]);
     if FNamedElems <> nil then
     begin
-      NamedIndex := FNamedElems.IndexOf(Elem.Name);
+      NamedIndex := FNamedElems.IndexOfName(Elem.Name);
       if NamedIndex >= 0 then
-        TJclSimpleXMLNamedElems(FNamedElems.Objects[NamedIndex]).FItems.Remove(Elem);
+        TJclSimpleXMLNamedElems(FNamedElems.SimpleItems[NamedIndex]).FItems.Remove(Elem);
     end;
     FElems.Delete(Index);
     FreeAndNil(Elem);
-    
   end;
 end;
 
 procedure TJclSimpleXMLElems.Delete(const Name: string);
 begin
   if FElems <> nil then
-    Delete(FElems.IndexOf(Name));
+    Delete(FElems.IndexOfName(Name));
 end;
 
 destructor TJclSimpleXMLElems.Destroy;
@@ -2100,25 +2201,17 @@
 
 procedure TJclSimpleXMLElems.DoItemRename(Value: TJclSimpleXMLElem; const Name: string);
 var
-  I: Integer;
   NamedIndex: Integer;
 begin
   if FNamedElems <> nil then
   begin
-    NamedIndex := FNamedElems.IndexOf(Value.Name);
+    NamedIndex := FNamedElems.IndexOfName(Value.Name);
     if NamedIndex >= 0 then
-      TJclSimpleXMLNamedElems(FNamedElems.Objects[NamedIndex]).FItems.Remove(Value);
-  end;
+      TJclSimpleXMLNamedElems(FNamedElems.SimpleItems[NamedIndex]).FItems.Remove(Value);
 
-  I := FElems.IndexOfObject(Value);
-  if I <> -1 then
-    FElems.Strings[I] := Name;
-
-  if FNamedElems <> nil then
-  begin
-    NamedIndex := FNamedElems.IndexOf(Name);
+    NamedIndex := FNamedElems.IndexOfName(Name);
     if NamedIndex >= 0 then
-      TJclSimpleXMLNamedElems(FNamedElems.Objects[NamedIndex]).FItems.Add(Value);
+      TJclSimpleXMLNamedElems(FNamedElems.SimpleItems[NamedIndex]).FItems.Add(Value);
   end;
 end;
 
@@ -2154,7 +2247,7 @@
   if (FElems = nil) or (Index > FElems.Count) then
     Result := nil
   else
-    Result := TJclSimpleXMLElem(FElems.Objects[Index]);
+    Result := TJclSimpleXMLElem(FElems.SimpleItems[Index]);
 end;
 
 function TJclSimpleXMLElems.GetItemNamedDefault(const Name, Default: string): TJclSimpleXMLElem;
@@ -2164,9 +2257,9 @@
   Result := nil;
   if FElems <> nil then
   begin
-    I := FElems.IndexOf(Name);
+    I := FElems.IndexOfName(Name);
     if I <> -1 then
-      Result := TJclSimpleXMLElem(FElems.Objects[I])
+      Result := TJclSimpleXMLElem(FElems.SimpleItems[I])
     else
     if Assigned(Parent) and Assigned(Parent.SimpleXML) and (sxoAutoCreate in Parent.SimpleXML.Options) then
       Result := Add(Name, Default);
@@ -2181,19 +2274,19 @@
   NamedIndex: Integer;
 begin
   if FNamedElems = nil then
-    FNamedElems := THashedStringList.Create;
-  NamedIndex := FNamedElems.IndexOf(Name);
+    FNamedElems := TJclSimpleItemHashedList.Create;
+  NamedIndex := FNamedElems.IndexOfName(Name);
   if NamedIndex = -1 then
   begin
     Result := TJclSimpleXMLNamedElems.Create(Self, Name);
-    FNamedElems.AddObject(Name, Result);
+    FNamedElems.Add(Result);
     if FElems <> nil then
-      for NamedIndex := 0 to FElems.Count - 1 do                 
-        if FElems.Strings[NamedIndex] = Name then
-          Result.FItems.Add(FElems.Objects[NamedIndex]);
+      for NamedIndex := 0 to FElems.Count - 1 do
+        if FElems.SimpleItems[NamedIndex].Name = Name then
+          Result.FItems.Add(FElems.SimpleItems[NamedIndex]);
   end
   else
-    Result := TJclSimpleXMLNamedElems(FNamedElems.Objects[NamedIndex]);
+    Result := TJclSimpleXMLNamedElems(FNamedElems.SimpleItems[NamedIndex]);
 end;
 
 function TJclSimpleXMLElems.GetItemNamed(const Name: string): TJclSimpleXMLElem;
@@ -2273,7 +2366,7 @@
                   CreateElems;
                   Notify(lElem,opInsert);
                   lElem.LoadFromStringStream(StringStream);
-                  FElems.AddObject(lElem.Name, lElem);
+                  FElems.Add(lElem);
                 end;
                 Break;
               end
@@ -2331,15 +2424,14 @@
             CreateElems;
             Notify(lElem, opInsert);
             lElem.LoadFromStringStream(StringStream);
-            FElems.AddObject(lElem.Name, lElem);
+            FElems.Add(lElem);
           end;
         end;
     end;
   end;
 end;
 
-procedure TJclSimpleXMLElems.Notify(Value: TJclSimpleXMLElem;
-  Operation: TOperation);
+procedure TJclSimpleXMLElems.Notify(Value: TJclSimpleXMLElem; Operation: TOperation);
 var
   NamedIndex: Integer;
 begin
@@ -2349,11 +2441,11 @@
       begin
         if FNamedElems <> nil then
         begin
-          NamedIndex := FNamedElems.IndexOf(Value.Name);
+          NamedIndex := FNamedElems.IndexOfName(Value.Name);
           if NamedIndex >= 0 then
-            TJclSimpleXMLNamedElems(FNamedElems.Objects[NamedIndex]).FItems.Remove(Value);
+            TJclSimpleXMLNamedElems(FNamedElems.SimpleItems[NamedIndex]).FItems.Remove(Value);
         end;
-        FElems.Delete(FElems.IndexOfObject(Value));
+        FElems.Remove(Value);
         Value.FParent := nil;
         Value.FSimpleXML := nil;
       end;
@@ -2367,7 +2459,7 @@
 
 function TJclSimpleXMLElems.Remove(Value: TJclSimpleXMLElem): Integer;
 begin
-  Result := FElems.IndexOfObject(Value);
+  Result := FElems.IndexOfSimpleItem(Value);
   Notify(Value, opRemove);
 end;
 
@@ -2380,6 +2472,12 @@
     Item[I].SaveToStringStream(StringStream, Level);
 end;
 
+function TJclSimpleXMLElems.SimpleCompare(Elems: TJclSimpleXMLElems; Index1,
+  Index2: Integer): Integer;
+begin
+  Result := CompareText(Elems.Item[Index1].Name, Elems.Item[Index2].Name);
+end;
+
 function TJclSimpleXMLElems.Value(const Name, Default: string): string;
 var
   Elem: TJclSimpleXMLElem;
@@ -2403,7 +2501,7 @@
   if FElems = nil then
     Result := -1
   else
-    Result := FElems.IndexOfObject(Value);
+    Result := FElems.IndexOfSimpleItem(Value);
 end;
 
 function TJclSimpleXMLElems.IndexOf(const Name: string): Integer;
@@ -2411,7 +2509,7 @@
   if FElems = nil then
     Result := -1
   else
-    Result := FElems.IndexOf(Name);
+    Result := FElems.IndexOfName(Name);
 end;
 
 procedure TJclSimpleXMLElems.InsertChild(const Value: TJclSimpleXMLElem; Index: Integer);
@@ -2424,13 +2522,13 @@
   if Assigned(Value.Parent) then
     Value.Parent.Items.Notify(Value, opRemove);
 
-  FElems.InsertObject(Index, Value.Name, Value);
+  FElems.Insert(Index, Value);
 
   if FNamedElems <> nil then
   begin
-    NamedIndex := FNamedElems.IndexOf(Value.Name);
+    NamedIndex := FNamedElems.IndexOfName(Value.Name);
     if NamedIndex >= 0 then
-      TJclSimpleXMLNamedElems(FNamedElems.Objects[NamedIndex]).FItems.Add(Value);
+      TJclSimpleXMLNamedElems(FNamedElems.SimpleItems[NamedIndex]).FItems.Add(Value);
   end;
 
   Notify(Value, opInsert);
@@ -2451,34 +2549,45 @@
   InsertChild(Result, Index);
 end;
 
-function SortItems(List: TStringList; Index1, Index2: Integer): Integer;
+procedure QuickSort(Elems: TJclSimpleXMLElems; List: TList; L, R: Integer;
+  AFunction: TJclSimpleXMLElemCompare);
 var
-  I: Integer;
+  I, J, M: Integer;
+  T: Pointer;
 begin
-  Result := 0;
-  for I := 0 to GSorts.Count - 1 do
-    if TJclSimpleXMLElems(GSorts[I]).FElems = List then
-    begin
-      Result := TJclSimpleXMLElems(GSorts[I]).FCompare(TJclSimpleXMLElems(GSorts[I]), Index1, Index2);
-      Break;
-    end;
+  repeat
+    I := L;
+    J := R;
+    M := (L + R) shr 1;
+    repeat
+      while AFunction(Elems, I, M) < 0 do
+        Inc(I);
+      while AFunction(Elems, J, M) > 0 do
+        Dec(J);
+      if I <= J then
+      begin
+        T := List[I];
+        List[I] := List[J];
+        List[J] := T;
+        Inc(I);
+        Dec(J);
+      end;
+    until I > J;
+    if L < J then
+      QuickSort(Elems, List, L, J, AFunction);
+    L := I;
+  until I >= R;
 end;
 
 procedure TJclSimpleXMLElems.CustomSort(AFunction: TJclSimpleXMLElemCompare);
 begin
   if FElems <> nil then
-  begin
-    GSorts.Add(Self);
-    FCompare := AFunction;
-    FElems.CustomSort(SortItems);
-    GSorts.Remove(Self);
-  end;
+    QuickSort(Self, FElems, 0, FElems.Count - 1, AFunction);
 end;
 
 procedure TJclSimpleXMLElems.Sort;
 begin
-  if FElems <> nil then
-    FElems.Sort;
+  CustomSort(SimpleCompare);
 end;
 
 //=== { TJclSimpleXMLPropsEnumerator } =======================================
@@ -3716,7 +3825,7 @@
 begin
   inherited Create;
   FSimpleXML := ASimpleXML;
-  FElems := THashedStringList.Create;
+  FElems := TJclSimpleItemHashedList.Create;
 end;
 
 destructor TJclSimpleXMLElemsProlog.Destroy;
@@ -3727,14 +3836,7 @@
 end;
 
 procedure TJclSimpleXMLElemsProlog.Clear;
-var
-  I: Integer;
 begin
-  for I := 0 to FElems.Count - 1 do
-  begin
-    FElems.Objects[I].Free;
-    FElems.Objects[I] := nil;
-  end;
   FElems.Clear;
 end;
 
@@ -3745,7 +3847,7 @@
 
 function TJclSimpleXMLElemsProlog.GetItem(const Index: Integer): TJclSimpleXMLElem;
 begin
-  Result := TJclSimpleXMLElem(FElems.Objects[Index]);
+  Result := TJclSimpleXMLElem(FElems.SimpleItems[Index]);
 end;
 
 procedure TJclSimpleXMLElemsProlog.LoadFromStringStream(StringStream: TJclStringStream);
@@ -3823,7 +3925,7 @@
           else
           if lElem <> nil then
           begin
-            FElems.AddObject(lElem.Name, lElem);
+            FElems.Add(lElem);
             lElem.LoadFromStringStream(StringStream);
             SetLength(St, 0);
             lPos := 0;
@@ -4182,7 +4284,7 @@
     end;
   // (p3) if we get here, an xml header was not found
   Result := TJclSimpleXMLElemHeader.Create(SimpleXML);
-  FElems.AddObject('', Result);
+  FElems.Add(Result);
 end;
 
 function TJclSimpleXMLElemsProlog.AddStyleSheet(const AType, AHRef: string): TJclSimpleXMLElemSheet;
@@ -4192,7 +4294,7 @@
   Result := TJclSimpleXMLElemSheet.Create('xml-stylesheet');
   Result.Properties.Add('type',AType);
   Result.Properties.Add('href',AHRef);
-  FElems.AddObject('xml-stylesheet', Result);
+  FElems.Add(Result);
 end;
 
 function TJclSimpleXMLElemsProlog.AddMSOApplication(const AProgId : string): TJclSimpleXMLElemMSOApplication;
@@ -4201,7 +4303,7 @@
   FindHeader;
   Result := TJclSimpleXMLElemMSOApplication.Create('mso-application');
   Result.Properties.Add('progid',AProgId);
-  FElems.AddObject('mso-application', Result);
+  FElems.Add(Result);
 end;
 
 function TJclSimpleXMLElemsProlog.AddComment(const AValue: string): TJclSimpleXMLElemComment;
@@ -4209,7 +4311,7 @@
   // make sure there is an xml header
   FindHeader;
   Result := TJclSimpleXMLElemComment.Create('', AValue);
-  FElems.AddObject('', Result);
+  FElems.Add(Result);
 end;
 
 function TJclSimpleXMLElemsProlog.AddDocType(const AValue: string): TJclSimpleXMLElemDocType;
@@ -4217,7 +4319,7 @@
   // make sure there is an xml header
   FindHeader;
   Result := TJclSimpleXMLElemDocType.Create('', AValue);
-  FElems.AddObject('', Result);
+  FElems.Add(Result);
 end;
 
 initialization
@@ -4227,7 +4329,6 @@
 
 finalization
   FreeAndNil(GlobalXMLVariant);
-  FreeAndNil(GlobalSorts);
   {$IFDEF UNITVERSIONING}
   UnregisterUnitVersion(HInstance);
   {$ENDIF UNITVERSIONING}

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.





2006	Jan	Feb	Mar	Apr (20)	May (48)	Jun (8)	Jul (23)	Aug (41)	Sep (42)	Oct (22)	Nov (17)	Dec (36)
2007	Jan (43)	Feb (42)	Mar (17)	Apr (39)	May (16)	Jun (35)	Jul (37)	Aug (47)	Sep (49)	Oct (9)	Nov (52)	Dec (37)
2008	Jan (48)	Feb (21)	Mar (7)	Apr (2)	May (5)	Jun (17)	Jul (17)	Aug (40)	Sep (58)	Oct (38)	Nov (19)	Dec (32)
2009	Jan (67)	Feb (46)	Mar (54)	Apr (34)	May (37)	Jun (52)	Jul (67)	Aug (72)	Sep (48)	Oct (35)	Nov (27)	Dec (12)
2010	Jan (56)	Feb (46)	Mar (19)	Apr (14)	May (21)	Jun (3)	Jul (13)	Aug (48)	Sep (34)	Oct (51)	Nov (16)	Dec (32)
2011	Jan (36)	Feb (14)	Mar (12)	Apr (3)	May (5)	Jun (24)	Jul (15)	Aug (30)	Sep (21)	Oct (4)	Nov (25)	Dec (23)
2012	Jan (45)	Feb (42)	Mar (19)	Apr (14)	May (13)	Jun (7)	Jul (3)	Aug (46)	Sep (21)	Oct (10)	Nov (2)	Dec
2013	Jan (5)	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

jcl-checkins-diff Mailing List for JEDI Code Library (Page 5)

jcl-checkins-diff — SVN file check-in notifications with file differences included