tpsystools_4.04/source/StIniStm.pas

// Upgraded to Delphi 2009: Sebastian Zierer
// FIXME: TStAnsiTextStream

(* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is TurboPower SysTools
 *
 * The Initial Developer of the Original Code is
 * TurboPower Software
 *
 * Portions created by the Initial Developer are Copyright (C) 1996-2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * ***** END LICENSE BLOCK ***** *)

{*********************************************************}
{* SysTools: StIniStm.pas 4.04                           *}
{*********************************************************}
{* SysTools: .INI file-like stream class                 *}
{*********************************************************}

{$include StDefine.inc}

unit StIniStm;


interface

uses
  Windows, SysUtils, Classes, StStrms;

type

  TStIniStream = class(TObject)
  private
    FAnsiStream : TStAnsiTextStream;
    FSections : TStringList;
    procedure GetSecStrings(Strs: TStrings);
  protected
    procedure GotoSection(const Section : String);
    procedure UpdateSections;
    procedure WriteSectionName(const Section : String);
    procedure WriteValue(const Key, Value : String);
  public
    constructor Create(aStream : TStream);
    destructor Destroy; override;

    function SectionExists(const Section : String): Boolean;
    function ReadString(const Section, Ident, Default : String) : String;
    procedure WriteString(const Section, Ident, Value : String);
    procedure WriteSection(const Section : String; Strings: TStrings);
    procedure ReadSection(const Section : String; Strings: TStrings);
    procedure ReadSections(Strings: TStrings);
    procedure ReadSectionValues(const Section : String; Strings: TStrings);
    procedure EraseSection(const Section : String);
    procedure DeleteKey(const Section, Ident : String);
    function ValueExists(const Section, Ident : String): Boolean;
  end;

procedure SplitNameValue(const Line : string; var Name, Value : string); {!!.04}

implementation

{!!.04 - Added }
procedure SplitNameValue(const Line : string; var Name, Value : string);
var
  P : Integer;
begin
  P := Pos('=', Line);
  if P < 1 then begin
    Name := Line;
    Value := '';
    Exit;
  end;

  Name := Copy(Line, 1, P-1);
  Value := Copy(Line, P+1, Length(Line) - P);
end;
{!!.04 - Added End}

function IsHeader(const AString : String) : Boolean;
{ see if passed in text looks like an .INI header }
var
  Temp : String;
begin
  if AString = '' then begin
    Result := False;
    Exit;
  end;

  Temp := Trim(AString);
  Result := (Temp[1] = '[') and (Temp[Length(Temp)] = ']')
end;


{ TStIniStream }

constructor TStIniStream.Create(aStream: TStream);
begin
  inherited Create;
  FAnsiStream := TStAnsiTextStream.Create(aStream);
  FSections := TStringList.Create;
  FSections.Sorted := True;
  FSections.Duplicates := dupIgnore;

  if aStream.Size > 0 then { not an empty stream }
    UpdateSections;
end;

destructor TStIniStream.Destroy;
begin
  FSections.Free;
  FAnsiStream.Free;
  inherited Destroy;
end;


procedure TStIniStream.DeleteKey(const Section, Ident : String);
{ delete specified item from Section }
var
  SecStrs : TStringList;
  SecIdx  : Integer;
  MS : TMemoryStream;
  TS : TStAnsiTextStream;
  i, Idx : Integer;
begin
  SecStrs := TStringList.Create;
  MS := TMemoryStream.Create;
  TS := TStAnsiTextStream.Create(MS);

  try
    { locate and read section }
    GotoSection(Section);
    GetSecStrings(SecStrs);
    Idx := SecStrs.IndexOfName(Ident);

    if Idx > - 1 then begin
      { remove desired key }
      SecStrs.Delete(Idx);

      { locate subsequent section }
      SecIdx := FSections.IndexOf(Section);
      if SecIdx < Pred(FSections.Count) then begin
        GotoSection(FSections[SecIdx+1]);

        { copy remaining sections }
        while not FAnsiStream.AtEndOfStream do
          TS.WriteLine(FAnsiStream.ReadLine);
      end;
      { else this is the last section }

      { seek back and truncate }
      GotoSection(Section);
      FAnsiStream.Size := FAnsiStream.Position;
//      FAnsiStream.SetSize(FAnsiStream.Position);

      { write updated section }
      WriteSectionName(Section);
      for i := 0 to Pred(SecStrs.Count) do
        FAnsiStream.WriteLine(SecStrs[i]);
      FAnsiStream.Stream.Seek(0, soFromEnd);

      { append saved subsequent sections }
      TS.SeekLine(0);
      while not TS.AtEndOfStream do
        FAnsiStream.WriteLine(TS.ReadLine);

    end; { if Ident > -1 }
    { else the Ident doesn't exist so don't alter anything }

  finally
    SecStrs.Free;
    TS.Free;
    MS.Free;
  end;
end;

procedure TStIniStream.EraseSection(const Section : String);
{ erase specified section from Ini data }
var
  SecIdx  : Integer;
  MS : TMemoryStream;
  TS : TStAnsiTextStream;
begin
  MS := TMemoryStream.Create;
  TS := TStAnsiTextStream.Create(MS);

  { locate section }
  SecIdx := FSections.IndexOf(Section);

  { if section found }
  if SectionExists(Section) then begin
    try
      { if this is not the last section }
      if (SecIdx < Pred(FSections.Count)) then begin
        { locate subsequent section }
        GotoSection(FSections[SecIdx+1]);

        { copy remaining sections to temporary stream}
        while not FAnsiStream.AtEndOfStream do
          TS.WriteLine(FAnsiStream.ReadLine);
      end;
      { else this is the last section }

      { locate section to delete and truncate }
      GotoSection(Section);
      FAnsiStream.Size := FAnsiStream.Position;
//      FAnsiStream.SetSize(FAnsiStream.Position);

      { append saved subsequent sections }
      TS.SeekLine(0);
      while not TS.AtEndOfStream do
        FAnsiStream.WriteLine(TS.ReadLine);

    finally
      TS.Free;
      MS.Free;
    end;
    UpdateSections;
  end;
  { else section doesn't exist, do nothing }
end;

procedure TStIniStream.GetSecStrings(Strs : TStrings);
{ read strings from a section, preserving comments and blanks }
var
  LineVal : String;
begin
  { assume we're at the start of a section }
  FAnsiStream.ReadLine; { skip section header }

  LineVal := FAnsiStream.ReadLine;
  while not (FAnsiStream.AtEndOfStream) and not (IsHeader(LineVal)) do begin
    Strs.Add(LineVal); { add it to the list }
    LineVal := FAnsiStream.ReadLine; { get next line }
  end;
end;

procedure TStIniStream.GotoSection(const Section: String);
{ position stream to requested section header }
var
  Idx : Integer;
begin
 Idx := FSections.IndexOf(Section);
  if Idx > -1 then
    FAnsiStream.SeekLine(Integer(FSections.Objects[Idx]));
end;

procedure TStIniStream.ReadSectionValues(const Section : String;
  Strings: TStrings);
{ return <Name>=<Value> pairs of requested Section in Strings }
var
  Strs : TStringList;
  LineVal : String;
  i : Integer;
begin
  if not Assigned(Strings) then Exit;

  Strs := TStringList.Create;
  if SectionExists(Section) then begin { section exists }
    Strings.Clear;
    try
      { locate section }
      GotoSection(Section);

      { retrieve section contents, comments, blank lines and all }
      GetSecStrings(Strs);

      { iterate section lines looking for entries }
      for i := 0 to Pred(Strs.Count) do begin
        LineVal := Strs[i];
        if (Trim(LineVal) <> '') and (Trim(LineVal[1]) <> ';') and (Pos('=', LineVal) > 0) then {!!.02}
      { not empty and not a comment and at least superficially resembles a
        <Name>=<Value> pair }
        Strings.Add(Trim(LineVal)); { add it to the list }             {!!.02}
      end;
    finally
      Strs.Free;
    end;
  end;
  { else section doesn't exist, do nothing }
end;

procedure TStIniStream.ReadSections(Strings: TStrings);
var
  i : Integer;
begin
  if not Assigned(Strings) then Exit;

  { omit the pseudo section }
  for i := 1 to Pred(FSections.Count) do
    Strings.Add(Trim(FSections[i]));                                   {!!.02}
end;

procedure TStIniStream.ReadSection(const Section : String;
  Strings: TStrings);
{ return Name strings for all entries in requested section }
var
  SecStrs : TStringList;
  i : Integer;
  LineVal, Name : String;
begin
  if not Assigned(Strings) then Exit;

  SecStrs := TStringList.Create;
  try
//    ReadSection(Section, SecStrs);
{!!.02 - Rewritten }
    Strings.Clear;
    { locate section }
    GotoSection(Section);

    { retrieve section contents, comments, blank lines and all }
    GetSecStrings(SecStrs);

    { iterate section lines looking for entries }
    for i := 0 to Pred(SecStrs.Count) do begin
      LineVal := SecStrs[i];
      if (Trim(LineVal) <> '') and (Trim(LineVal[1]) <> ';') and (Pos('=', LineVal) > 0) then begin
      { not empty and not a comment and at least superficially resembles a
      <Name>=<Value> pair }
        SplitNameValue(LineVal, Name, LineVal);
        Strings.Add(Trim(Name));
      end;
    end;

//    for i := 0 to Pred(SecStrs.Count) do
//      Strings.Add(SecStrs.Names[i]);
{!!.02 - Rewritten End }


  finally
    SecStrs.Free;
  end;
end;

function TStIniStream.ReadString(const Section, Ident,
  Default : String) : String;
{
return a particular string selected by Ident from Section
if empty or doesn't exist, return Default
}
var
  SecStrs : TStringList;
begin
  SecStrs := TStringList.Create;
  try
    ReadSectionValues(Section, SecStrs);                            {!!.04}

    Result := SecStrs.Values[Ident];
    if Result = '' then
      Result := Default;

  finally
    SecStrs.Free;
  end;
end;

function TStIniStream.SectionExists(const Section : String): Boolean;
{ returns True if Section exists in section list, False otherwise }
begin
  Result := FSections.IndexOf(Section) > -1;
end;

procedure TStIniStream.UpdateSections;
{ refresh Sections list }
var
  i : Integer;
  Line : String;
begin
  i := 0;
  FSections.Clear;
  FAnsiStream.SeekLine(0);

  { pseudo section to account for any comments or whitespace prior to first
    real section in data }
  FSections.AddObject('[]', TObject(0));

  { iterate data looking for section headers: '[blah]' }
  while not FAnsiStream.AtEndOfStream do begin
    Line := Trim(FAnsiStream.ReadLine);
    { if it looks like a header }
    if IsHeader(Line) then
      { add it to the list with a line index }
      FSections.AddObject(Copy(Line, 2, Length(Line) - 2), TObject(i));
    { go to next line }
    Inc(i);
  end;
end;

function TStIniStream.ValueExists(const Section, Ident : String): Boolean;
{
see if requested section contains requested Ident
implies "<Ident>=" exists in section, not that there's necessarily any
explicit Value associated, i.e. Value may be blank
}
var
  SecStrs : TStringList;
  i : Integer;
begin
  Result := False;
  SecStrs := TStringList.Create;
  try
    { get section }
    ReadSection(Section, SecStrs);

    { see if Ident exists in Names collection }
    for i := 0 to Pred(SecStrs.Count) do
      if SecStrs.Names[i] = Ident then begin
        Result := True;
        Break;
      end;
  finally
    SecStrs.Free;
  end;
end;

procedure TStIniStream.WriteString(const Section, Ident, Value : String);
{ write individual string value to IniStream }
var
  SecStrs : TStringList;
  SecIdx  : Integer;
  MS : TMemoryStream;
  TS : TStAnsiTextStream;
  i : Integer;
begin
  if SectionExists(Section) then begin
    SecStrs := TStringList.Create;
    MS := TMemoryStream.Create;
    TS := TStAnsiTextStream.Create(MS);

    try
      { locate and read section }
      GotoSection(Section);
      GetSecStrings(SecStrs);

      { locate subsequent section }
      SecIdx := FSections.IndexOf(Section);
      if SecIdx < Pred(FSections.Count) then begin
        GotoSection(FSections[SecIdx+1]);

        { copy remaining sections }
        while not FAnsiStream.AtEndOfStream do
          TS.WriteLine(FAnsiStream.ReadLine);
      end;
      { else this is the last section }

      { seek back and truncate }
      GotoSection(Section);
      FAnsiStream.Size := FAnsiStream.Position;

//      FAnsiStream.SetSize(FAnsiStream.Position);

      { insert new value }
      SecStrs.Add(Ident + '=' + Value);

      { write updated section }
      WriteSectionName(Section);
      for i := 0 to Pred(SecStrs.Count) do
        FAnsiStream.WriteLine(SecStrs[i]);
      FAnsiStream.Stream.Seek(0, soFromEnd);

      { append saved subsequent sections }
      TS.SeekLine(0);
      while not TS.AtEndOfStream do
        FAnsiStream.WriteLine(TS.ReadLine);

    finally
      SecStrs.Free;
      TS.Free;
      MS.Free;
    end;

  end
  else begin { no such section exists, append new one }
    FAnsiStream.Seek(0, soFromEnd);
    WriteSectionName(Section);
    WriteValue(Ident, Value);
    UpdateSections;
  end;

end;

procedure TStIniStream.WriteSectionName(const Section: String);
{ write section header at current location }
begin
  FAnsiStream.WriteLine('[' + Section + ']');
end;

procedure TStIniStream.WriteValue(const Key, Value: String);
{ write <Name>=<Value> pair at current location }
begin
  FAnsiStream.WriteLine(Key + '=' + Value);
end;

procedure TStIniStream.WriteSection(const Section: String;
  Strings: TStrings);
{ write entire section described by Strings }
var
  SecStrs : TStringList;
  SecIdx  : Integer;
  MS : TMemoryStream;
  TS : TStAnsiTextStream;
  i : Integer;
  L : LongInt;
  Name : String;
begin
  if not Assigned(Strings) then Exit;

  if SectionExists(Section) then begin
    SecStrs := TStringList.Create;
    MS := TMemoryStream.Create;
    TS := TStAnsiTextStream.Create(MS);

    try
      { locate and read section }
      GotoSection(Section);
      GetSecStrings(SecStrs);

      { locate subsequent section }
      SecIdx := FSections.IndexOf(Section);
      if SecIdx < Pred(FSections.Count) then begin
        GotoSection(FSections[SecIdx+1]);

        { copy remaining sections }
        while not FAnsiStream.AtEndOfStream do
          TS.WriteLine(FAnsiStream.ReadLine);
      end;
      { else this is the last section }

      { seek back and truncate }
      GotoSection(Section);
      FAnsiStream.Size := FAnsiStream.Position;
//      FAnsiStream.SetSize(FAnsiStream.Position);

      { update section }
      for i := 0 to Pred(Strings.Count) do begin
        Name := Strings.Names[i];
        if SecStrs.IndexOfName(Name) > -1 then { entry exists, change value }
          SecStrs.Values[Name] := Strings.Values[Name]
        else { new entry, just append it }
          SecStrs.Add(Strings[i]);
      end;

      { write updated section }
      WriteSectionName(Section);
      for i := 0 to Pred(SecStrs.Count) do
        FAnsiStream.WriteLine(SecStrs[i]);
      FAnsiStream.Stream.Seek(0, soFromEnd);

      { append saved subsequent sections }
      TS.SeekLine(0);
      while not TS.AtEndOfStream do
        FAnsiStream.WriteLine(TS.ReadLine);

    finally
      SecStrs.Free;
      TS.Free;
      MS.Free;
    end;

  end
  else begin { no such section exists, append new one }
    L := FAnsiStream.LineCount;
    FAnsiStream.Seek(0, soFromEnd);
    WriteSectionName(Section);
    FSections.AddObject(Section, TObject(L+1));
    for i := 0 to Pred(Strings.Count) do
      FAnsiStream.WriteLine(Strings[i]);
//    UpdateSections;
  end;
end;

end.
1	// Upgraded to Delphi 2009: Sebastian Zierer
2	// FIXME: TStAnsiTextStream
3
4	(* *** BEGIN LICENSE BLOCK ***
5	* Version: MPL 1.1
6	*
7	* The contents of this file are subject to the Mozilla Public License Version
8	* 1.1 (the "License"); you may not use this file except in compliance with
9	* the License. You may obtain a copy of the License at
10	* http://www.mozilla.org/MPL/
11	*
12	* Software distributed under the License is distributed on an "AS IS" basis,
13	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14	* for the specific language governing rights and limitations under the
15	* License.
16	*
17	* The Original Code is TurboPower SysTools
18	*
19	* The Initial Developer of the Original Code is
20	* TurboPower Software
21	*
22	* Portions created by the Initial Developer are Copyright (C) 1996-2002
23	* the Initial Developer. All Rights Reserved.
24	*
25	* Contributor(s):
26	*
27	* *** END LICENSE BLOCK *** *)
28
29	{*********************************************************}
30	{* SysTools: StIniStm.pas 4.04 *}
31	{*********************************************************}
32	{* SysTools: .INI file-like stream class *}
33	{*********************************************************}
34
35	{$include StDefine.inc}
36
37	unit StIniStm;
38
39
40	interface
41
42	uses
43	Windows, SysUtils, Classes, StStrms;
44
45	type
46
47	TStIniStream = class(TObject)
48	private
49	FAnsiStream : TStAnsiTextStream;
50	FSections : TStringList;
51	procedure GetSecStrings(Strs: TStrings);
52	protected
53	procedure GotoSection(const Section : String);
54	procedure UpdateSections;
55	procedure WriteSectionName(const Section : String);
56	procedure WriteValue(const Key, Value : String);
57	public
58	constructor Create(aStream : TStream);
59	destructor Destroy; override;
60
61	function SectionExists(const Section : String): Boolean;
62	function ReadString(const Section, Ident, Default : String) : String;
63	procedure WriteString(const Section, Ident, Value : String);
64	procedure WriteSection(const Section : String; Strings: TStrings);
65	procedure ReadSection(const Section : String; Strings: TStrings);
66	procedure ReadSections(Strings: TStrings);
67	procedure ReadSectionValues(const Section : String; Strings: TStrings);
68	procedure EraseSection(const Section : String);
69	procedure DeleteKey(const Section, Ident : String);
70	function ValueExists(const Section, Ident : String): Boolean;
71	end;
72
73	procedure SplitNameValue(const Line : string; var Name, Value : string); {!!.04}
74
75	implementation
76
77	{!!.04 - Added }
78	procedure SplitNameValue(const Line : string; var Name, Value : string);
79	var
80	P : Integer;
81	begin
82	P := Pos('=', Line);
83	if P < 1 then begin
84	Name := Line;
85	Value := '';
86	Exit;
87	end;
88
89	Name := Copy(Line, 1, P-1);
90	Value := Copy(Line, P+1, Length(Line) - P);
91	end;
92	{!!.04 - Added End}
93
94	function IsHeader(const AString : String) : Boolean;
95	{ see if passed in text looks like an .INI header }
96	var
97	Temp : String;
98	begin
99	if AString = '' then begin
100	Result := False;
101	Exit;
102	end;
103
104	Temp := Trim(AString);
105	Result := (Temp[1] = '[') and (Temp[Length(Temp)] = ']')
106	end;
107
108
109	{ TStIniStream }
110
111	constructor TStIniStream.Create(aStream: TStream);
112	begin
113	inherited Create;
114	FAnsiStream := TStAnsiTextStream.Create(aStream);
115	FSections := TStringList.Create;
116	FSections.Sorted := True;
117	FSections.Duplicates := dupIgnore;
118
119	if aStream.Size > 0 then { not an empty stream }
120	UpdateSections;
121	end;
122
123	destructor TStIniStream.Destroy;
124	begin
125	FSections.Free;
126	FAnsiStream.Free;
127	inherited Destroy;
128	end;
129
130
131	procedure TStIniStream.DeleteKey(const Section, Ident : String);
132	{ delete specified item from Section }
133	var
134	SecStrs : TStringList;
135	SecIdx : Integer;
136	MS : TMemoryStream;
137	TS : TStAnsiTextStream;
138	i, Idx : Integer;
139	begin
140	SecStrs := TStringList.Create;
141	MS := TMemoryStream.Create;
142	TS := TStAnsiTextStream.Create(MS);
143
144	try
145	{ locate and read section }
146	GotoSection(Section);
147	GetSecStrings(SecStrs);
148	Idx := SecStrs.IndexOfName(Ident);
149
150	if Idx > - 1 then begin
151	{ remove desired key }
152	SecStrs.Delete(Idx);
153
154	{ locate subsequent section }
155	SecIdx := FSections.IndexOf(Section);
156	if SecIdx < Pred(FSections.Count) then begin
157	GotoSection(FSections[SecIdx+1]);
158
159	{ copy remaining sections }
160	while not FAnsiStream.AtEndOfStream do
161	TS.WriteLine(FAnsiStream.ReadLine);
162	end;
163	{ else this is the last section }
164
165	{ seek back and truncate }
166	GotoSection(Section);
167	FAnsiStream.Size := FAnsiStream.Position;
168	// FAnsiStream.SetSize(FAnsiStream.Position);
169
170	{ write updated section }
171	WriteSectionName(Section);
172	for i := 0 to Pred(SecStrs.Count) do
173	FAnsiStream.WriteLine(SecStrs[i]);
174	FAnsiStream.Stream.Seek(0, soFromEnd);
175
176	{ append saved subsequent sections }
177	TS.SeekLine(0);
178	while not TS.AtEndOfStream do
179	FAnsiStream.WriteLine(TS.ReadLine);
180
181	end; { if Ident > -1 }
182	{ else the Ident doesn't exist so don't alter anything }
183
184	finally
185	SecStrs.Free;
186	TS.Free;
187	MS.Free;
188	end;
189	end;
190
191	procedure TStIniStream.EraseSection(const Section : String);
192	{ erase specified section from Ini data }
193	var
194	SecIdx : Integer;
195	MS : TMemoryStream;
196	TS : TStAnsiTextStream;
197	begin
198	MS := TMemoryStream.Create;
199	TS := TStAnsiTextStream.Create(MS);
200
201	{ locate section }
202	SecIdx := FSections.IndexOf(Section);
203
204	{ if section found }
205	if SectionExists(Section) then begin
206	try
207	{ if this is not the last section }
208	if (SecIdx < Pred(FSections.Count)) then begin
209	{ locate subsequent section }
210	GotoSection(FSections[SecIdx+1]);
211
212	{ copy remaining sections to temporary stream}
213	while not FAnsiStream.AtEndOfStream do
214	TS.WriteLine(FAnsiStream.ReadLine);
215	end;
216	{ else this is the last section }
217
218	{ locate section to delete and truncate }
219	GotoSection(Section);
220	FAnsiStream.Size := FAnsiStream.Position;
221	// FAnsiStream.SetSize(FAnsiStream.Position);
222
223	{ append saved subsequent sections }
224	TS.SeekLine(0);
225	while not TS.AtEndOfStream do
226	FAnsiStream.WriteLine(TS.ReadLine);
227
228	finally
229	TS.Free;
230	MS.Free;
231	end;
232	UpdateSections;
233	end;
234	{ else section doesn't exist, do nothing }
235	end;
236
237	procedure TStIniStream.GetSecStrings(Strs : TStrings);
238	{ read strings from a section, preserving comments and blanks }
239	var
240	LineVal : String;
241	begin
242	{ assume we're at the start of a section }
243	FAnsiStream.ReadLine; { skip section header }
244
245	LineVal := FAnsiStream.ReadLine;
246	while not (FAnsiStream.AtEndOfStream) and not (IsHeader(LineVal)) do begin
247	Strs.Add(LineVal); { add it to the list }
248	LineVal := FAnsiStream.ReadLine; { get next line }
249	end;
250	end;
251
252	procedure TStIniStream.GotoSection(const Section: String);
253	{ position stream to requested section header }
254	var
255	Idx : Integer;
256	begin
257	Idx := FSections.IndexOf(Section);
258	if Idx > -1 then
259	FAnsiStream.SeekLine(Integer(FSections.Objects[Idx]));
260	end;
261
262	procedure TStIniStream.ReadSectionValues(const Section : String;
263	Strings: TStrings);
264	{ return <Name>=<Value> pairs of requested Section in Strings }
265	var
266	Strs : TStringList;
267	LineVal : String;
268	i : Integer;
269	begin
270	if not Assigned(Strings) then Exit;
271
272	Strs := TStringList.Create;
273	if SectionExists(Section) then begin { section exists }
274	Strings.Clear;
275	try
276	{ locate section }
277	GotoSection(Section);
278
279	{ retrieve section contents, comments, blank lines and all }
280	GetSecStrings(Strs);
281
282	{ iterate section lines looking for entries }
283	for i := 0 to Pred(Strs.Count) do begin
284	LineVal := Strs[i];
285	if (Trim(LineVal) <> '') and (Trim(LineVal[1]) <> ';') and (Pos('=', LineVal) > 0) then {!!.02}
286	{ not empty and not a comment and at least superficially resembles a
287	<Name>=<Value> pair }
288	Strings.Add(Trim(LineVal)); { add it to the list } {!!.02}
289	end;
290	finally
291	Strs.Free;
292	end;
293	end;
294	{ else section doesn't exist, do nothing }
295	end;
296
297	procedure TStIniStream.ReadSections(Strings: TStrings);
298	var
299	i : Integer;
300	begin
301	if not Assigned(Strings) then Exit;
302
303	{ omit the pseudo section }
304	for i := 1 to Pred(FSections.Count) do
305	Strings.Add(Trim(FSections[i])); {!!.02}
306	end;
307
308	procedure TStIniStream.ReadSection(const Section : String;
309	Strings: TStrings);
310	{ return Name strings for all entries in requested section }
311	var
312	SecStrs : TStringList;
313	i : Integer;
314	LineVal, Name : String;
315	begin
316	if not Assigned(Strings) then Exit;
317
318	SecStrs := TStringList.Create;
319	try
320	// ReadSection(Section, SecStrs);
321	{!!.02 - Rewritten }
322	Strings.Clear;
323	{ locate section }
324	GotoSection(Section);
325
326	{ retrieve section contents, comments, blank lines and all }
327	GetSecStrings(SecStrs);
328
329	{ iterate section lines looking for entries }
330	for i := 0 to Pred(SecStrs.Count) do begin
331	LineVal := SecStrs[i];
332	if (Trim(LineVal) <> '') and (Trim(LineVal[1]) <> ';') and (Pos('=', LineVal) > 0) then begin
333	{ not empty and not a comment and at least superficially resembles a
334	<Name>=<Value> pair }
335	SplitNameValue(LineVal, Name, LineVal);
336	Strings.Add(Trim(Name));
337	end;
338	end;
339
340	// for i := 0 to Pred(SecStrs.Count) do
341	// Strings.Add(SecStrs.Names[i]);
342	{!!.02 - Rewritten End }
343
344
345	finally
346	SecStrs.Free;
347	end;
348	end;
349
350	function TStIniStream.ReadString(const Section, Ident,
351	Default : String) : String;
352	{
353	return a particular string selected by Ident from Section
354	if empty or doesn't exist, return Default
355	}
356	var
357	SecStrs : TStringList;
358	begin
359	SecStrs := TStringList.Create;
360	try
361	ReadSectionValues(Section, SecStrs); {!!.04}
362
363	Result := SecStrs.Values[Ident];
364	if Result = '' then
365	Result := Default;
366
367	finally
368	SecStrs.Free;
369	end;
370	end;
371
372	function TStIniStream.SectionExists(const Section : String): Boolean;
373	{ returns True if Section exists in section list, False otherwise }
374	begin
375	Result := FSections.IndexOf(Section) > -1;
376	end;
377
378	procedure TStIniStream.UpdateSections;
379	{ refresh Sections list }
380	var
381	i : Integer;
382	Line : String;
383	begin
384	i := 0;
385	FSections.Clear;
386	FAnsiStream.SeekLine(0);
387
388	{ pseudo section to account for any comments or whitespace prior to first
389	real section in data }
390	FSections.AddObject('[]', TObject(0));
391
392	{ iterate data looking for section headers: '[blah]' }
393	while not FAnsiStream.AtEndOfStream do begin
394	Line := Trim(FAnsiStream.ReadLine);
395	{ if it looks like a header }
396	if IsHeader(Line) then
397	{ add it to the list with a line index }
398	FSections.AddObject(Copy(Line, 2, Length(Line) - 2), TObject(i));
399	{ go to next line }
400	Inc(i);
401	end;
402	end;
403
404	function TStIniStream.ValueExists(const Section, Ident : String): Boolean;
405	{
406	see if requested section contains requested Ident
407	implies "<Ident>=" exists in section, not that there's necessarily any
408	explicit Value associated, i.e. Value may be blank
409	}
410	var
411	SecStrs : TStringList;
412	i : Integer;
413	begin
414	Result := False;
415	SecStrs := TStringList.Create;
416	try
417	{ get section }
418	ReadSection(Section, SecStrs);
419
420	{ see if Ident exists in Names collection }
421	for i := 0 to Pred(SecStrs.Count) do
422	if SecStrs.Names[i] = Ident then begin
423	Result := True;
424	Break;
425	end;
426	finally
427	SecStrs.Free;
428	end;
429	end;
430
431	procedure TStIniStream.WriteString(const Section, Ident, Value : String);
432	{ write individual string value to IniStream }
433	var
434	SecStrs : TStringList;
435	SecIdx : Integer;
436	MS : TMemoryStream;
437	TS : TStAnsiTextStream;
438	i : Integer;
439	begin
440	if SectionExists(Section) then begin
441	SecStrs := TStringList.Create;
442	MS := TMemoryStream.Create;
443	TS := TStAnsiTextStream.Create(MS);
444
445	try
446	{ locate and read section }
447	GotoSection(Section);
448	GetSecStrings(SecStrs);
449
450	{ locate subsequent section }
451	SecIdx := FSections.IndexOf(Section);
452	if SecIdx < Pred(FSections.Count) then begin
453	GotoSection(FSections[SecIdx+1]);
454
455	{ copy remaining sections }
456	while not FAnsiStream.AtEndOfStream do
457	TS.WriteLine(FAnsiStream.ReadLine);
458	end;
459	{ else this is the last section }
460
461	{ seek back and truncate }
462	GotoSection(Section);
463	FAnsiStream.Size := FAnsiStream.Position;
464
465	// FAnsiStream.SetSize(FAnsiStream.Position);
466
467	{ insert new value }
468	SecStrs.Add(Ident + '=' + Value);
469
470	{ write updated section }
471	WriteSectionName(Section);
472	for i := 0 to Pred(SecStrs.Count) do
473	FAnsiStream.WriteLine(SecStrs[i]);
474	FAnsiStream.Stream.Seek(0, soFromEnd);
475
476	{ append saved subsequent sections }
477	TS.SeekLine(0);
478	while not TS.AtEndOfStream do
479	FAnsiStream.WriteLine(TS.ReadLine);
480
481	finally
482	SecStrs.Free;
483	TS.Free;
484	MS.Free;
485	end;
486
487	end
488	else begin { no such section exists, append new one }
489	FAnsiStream.Seek(0, soFromEnd);
490	WriteSectionName(Section);
491	WriteValue(Ident, Value);
492	UpdateSections;
493	end;
494
495	end;
496
497	procedure TStIniStream.WriteSectionName(const Section: String);
498	{ write section header at current location }
499	begin
500	FAnsiStream.WriteLine('[' + Section + ']');
501	end;
502
503	procedure TStIniStream.WriteValue(const Key, Value: String);
504	{ write <Name>=<Value> pair at current location }
505	begin
506	FAnsiStream.WriteLine(Key + '=' + Value);
507	end;
508
509	procedure TStIniStream.WriteSection(const Section: String;
510	Strings: TStrings);
511	{ write entire section described by Strings }
512	var
513	SecStrs : TStringList;
514	SecIdx : Integer;
515	MS : TMemoryStream;
516	TS : TStAnsiTextStream;
517	i : Integer;
518	L : LongInt;
519	Name : String;
520	begin
521	if not Assigned(Strings) then Exit;
522
523	if SectionExists(Section) then begin
524	SecStrs := TStringList.Create;
525	MS := TMemoryStream.Create;
526	TS := TStAnsiTextStream.Create(MS);
527
528	try
529	{ locate and read section }
530	GotoSection(Section);
531	GetSecStrings(SecStrs);
532
533	{ locate subsequent section }
534	SecIdx := FSections.IndexOf(Section);
535	if SecIdx < Pred(FSections.Count) then begin
536	GotoSection(FSections[SecIdx+1]);
537
538	{ copy remaining sections }
539	while not FAnsiStream.AtEndOfStream do
540	TS.WriteLine(FAnsiStream.ReadLine);
541	end;
542	{ else this is the last section }
543
544	{ seek back and truncate }
545	GotoSection(Section);
546	FAnsiStream.Size := FAnsiStream.Position;
547	// FAnsiStream.SetSize(FAnsiStream.Position);
548
549	{ update section }
550	for i := 0 to Pred(Strings.Count) do begin
551	Name := Strings.Names[i];
552	if SecStrs.IndexOfName(Name) > -1 then { entry exists, change value }
553	SecStrs.Values[Name] := Strings.Values[Name]
554	else { new entry, just append it }
555	SecStrs.Add(Strings[i]);
556	end;
557
558	{ write updated section }
559	WriteSectionName(Section);
560	for i := 0 to Pred(SecStrs.Count) do
561	FAnsiStream.WriteLine(SecStrs[i]);
562	FAnsiStream.Stream.Seek(0, soFromEnd);
563
564	{ append saved subsequent sections }
565	TS.SeekLine(0);
566	while not TS.AtEndOfStream do
567	FAnsiStream.WriteLine(TS.ReadLine);
568
569	finally
570	SecStrs.Free;
571	TS.Free;
572	MS.Free;
573	end;
574
575	end
576	else begin { no such section exists, append new one }
577	L := FAnsiStream.LineCount;
578	FAnsiStream.Seek(0, soFromEnd);
579	WriteSectionName(Section);
580	FSections.AddObject(Section, TObject(L+1));
581	for i := 0 to Pred(Strings.Count) do
582	FAnsiStream.WriteLine(Strings[i]);
583	// UpdateSections;
584	end;
585	end;
586
587	end.