fbintf/client/FBBlob.pas

(*
 *  Firebird Interface (fbintf). The fbintf components provide a set of
 *  Pascal language bindings for the Firebird API. Although predominantly
 *  a new development they include source code taken from IBX and may be
 *  considered a derived product. This software thus also includes the copyright
 *  notice and license conditions from IBX.
 *
 *  Except for those parts dervied from IBX, contents of this file are subject
 *  to the Initial Developer's Public License Version 1.0 (the "License"); you
 *  may not use this file except in compliance with the License. You may obtain a
 *  copy of the License here:
 *
 *    http://www.firebirdsql.org/index.php?op=doc&id=idpl
 *
 *  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 Initial Developer of the Original Code is Tony Whyman.
 *
 *  The Original Code is (C) 2016 Tony Whyman, MWA Software
 *  (http://www.mwasoftware.co.uk).
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): ______________________________________.
 *
*)
unit FBBlob;

{$IFDEF FPC}
{$mode objfpc}{$H+}
{$interfaces COM}
{$ENDIF}

interface

uses
  Classes, SysUtils, IB, FBActivityMonitor, FBTransaction, FBClientAPI;

type

  { TFBBlobMetaData }

  TFBBlobMetaData  = class(TActivityReporter)
  private
    FRelationName: string;
    FColumnName: string;
  protected
    FUnconfirmedCharacterSet: boolean;
    FHasSubType: boolean;
    FSubType: integer;
    FCharSetID: cardinal;
    FSegmentSize: cardinal;
    procedure NeedFullMetadata; virtual; abstract;
    procedure NeedSubType;
  public
    constructor Create(Transaction: TFBTransaction; RelationName, ColumnName: string
      );

  public
    {IBlobMetaData}
   function GetSubType: integer;
   function GetCharSetID: cardinal;
   function GetCodePage: TSystemCodePage;
   function GetSegmentSize: cardinal;
   function GetRelationName: string;
   function GetColumnName: string;
   function GetUnconfirmedCharacterSet: boolean;
  end;

  TFBBlob = class(TActivityReporter)
  private
    FMetaData: IBlobMetaData;
    FAttachment: IAttachment;
    FTransaction: ITransaction;
    FBPB: IBPB;
    FStringData: rawbytestring;
    FStringCached: boolean;
  protected
    FCreating: boolean;
    FBlobID: TISC_QUAD;
    procedure CheckReadable; virtual; abstract;
    procedure CheckWritable; virtual; abstract;
    procedure ClearStringCache;
    function GetIntf: IBlob; virtual; abstract;
    procedure InternalClose(Force: boolean); virtual; abstract;
    procedure InternalCancel(Force: boolean); virtual; abstract;
  public
    constructor Create(Attachment: IAttachment; Transaction: TFBTransaction;
                       MetaData: IBlobMetaData; BPB: IBPB); overload;
    constructor Create(Attachment: IAttachment; Transaction: TFBTransaction;
                       MetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB); overload;
    destructor Destroy; override;
    procedure TransactionEnding(aTransaction: TFBTransaction; Force: boolean);

  public
    {IBlobMetaData}
   function GetSubType: integer;
   function GetCharSetID: cardinal;
   function GetCodePage: TSystemCodePage;
   function GetSegmentSize: cardinal;
   function GetRelationName: string;
   function GetColumnName: string;
   function GetUnconfirmedCharacterSet: boolean;

   {IBlob}
    function GetBPB: IBPB;
    procedure Cancel;
    procedure Close;
    function GetBlobSize: Int64;
    procedure GetInfo(var NumSegments: Int64; var MaxSegmentSize, TotalSize: Int64;
      var BlobType: TBlobType); virtual; abstract;
    function GetBlobID: TISC_QUAD;
    function GetBlobMode: TFBBlobMode;
    function Read(var Buffer; Count: Longint): Longint; virtual; abstract;
    function Write(const Buffer; Count: Longint): Longint;  virtual; abstract;
    function LoadFromFile(Filename: string): IBlob;
    function LoadFromStream(S: TStream) : IBlob;
    function SaveToFile(Filename: string): IBlob;
    function SaveToStream(S: TStream): IBlob;
    function GetAttachment: IAttachment;
    function GetTransaction: ITransaction;
    function GetAsString: rawbytestring;
    procedure SetAsString(aValue: rawbytestring);
    function SetString(aValue: rawbytestring): IBlob;
  end;


implementation

uses FBMessages;

{ TFBBlob }

procedure TFBBlob.ClearStringCache;
begin
  FStringData := '';
  FStringCached := false;
end;

constructor TFBBlob.Create(Attachment: IAttachment;
  Transaction: TFBTransaction; MetaData: IBlobMetaData; BPB: IBPB);
begin
  inherited Create(Transaction);
  FAttachment := Attachment;
  FTransaction := Transaction;
  FMetaData := MetaData;
  FBPB := BPB;
  FCreating := true;
end;

constructor TFBBlob.Create(Attachment: IAttachment;
  Transaction: TFBTransaction; MetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB);
begin
  Create(Attachment,Transaction,MetaData,BPB);
  FBlobID := BlobID;
  FCreating := false;
end;

destructor TFBBlob.Destroy;
begin
  if FCreating then
    Cancel
  else
    Close;
  inherited Destroy;
end;

procedure TFBBlob.TransactionEnding(aTransaction: TFBTransaction;
  Force: boolean);
begin
  if aTransaction <> FTransaction then
    Exit;
  if FCreating then
    InternalCancel(Force)
  else
    InternalClose(Force);
end;

function TFBBlob.GetSubType: integer;
begin
  Result := FMetaData.GetSubType;
end;

function TFBBlob.GetCharSetID: cardinal;
begin
  Result := FMetaData.GetCharSetID;
end;

function TFBBlob.GetCodePage: TSystemCodePage;
begin
  Result := FMetaData.GetCodePage;
end;

function TFBBlob.GetSegmentSize: cardinal;
begin
  Result := FMetaData.GetSegmentSize;
end;

function TFBBlob.GetRelationName: string;
begin
  Result := FMetaData.GetRelationName;
end;

function TFBBlob.GetColumnName: string;
begin
  Result := FMetaData.GetColumnName;
end;

function TFBBlob.GetUnconfirmedCharacterSet: boolean;
begin
  Result := (FMetadata as TFBBlobMetadata).GetUnconfirmedCharacterSet;
end;

function TFBBlob.GetBPB: IBPB;
begin
  Result := FBPB;
end;

procedure TFBBlob.Cancel;
begin
  InternalCancel(false);
end;

procedure TFBBlob.Close;
begin
  InternalClose(false);
end;

function TFBBlob.GetBlobSize: Int64;
var NumSegments: Int64;
    MaxSegmentSize: Int64;
    BlobType: TBlobType;
begin
  GetInfo(NumSegments,MaxSegmentSize,Result,BlobType);
end;

function TFBBlob.GetBlobID: TISC_QUAD;
begin
  Result := FBlobID;
end;

function TFBBlob.GetBlobMode: TFBBlobMode;
begin
  if FCreating then
    Result := fbmWrite
  else
    Result := fbmRead;
end;

function TFBBlob.LoadFromFile(Filename: string): IBlob;
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead);
  try
    Result := LoadFromStream(Stream);
  finally
    Stream.Free;
  end;
end;

const BufSize = 8 * 1024;

function TFBBlob.LoadFromStream(S: TStream): IBlob;
var Buffer: array [0..BufSize-1] of char;
    BytesRead: integer;
begin
  CheckWritable;
  S.Position := 0;
  repeat
    BytesRead := S.Read(Buffer,BufSize);
    Write(Buffer,BytesRead);
  until BytesRead = 0;
  Close;
  Result := GetIntf;
end;

function TFBBlob.SaveToFile(Filename: string): IBlob;
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmCreate);
  try
    Result := SaveToStream(Stream);
  finally
    Stream.Free;
  end;
end;

function TFBBlob.SaveToStream(S: TStream): IBlob;
var Buffer: array [0..BufSize-1] of char;
    BytesRead: integer;
begin
  CheckReadable;
  repeat
    BytesRead := Read(Buffer,BufSize);
    S.Write(Buffer,BytesRead);
  until BytesRead = 0;
  Close;
  Result := GetIntf;
end;

function TFBBlob.GetAttachment: IAttachment;
begin
  Result := FAttachment;
end;

function TFBBlob.GetTransaction: ITransaction;
begin
   Result := FTransaction;
end;

function TFBBlob.GetAsString: rawbytestring;
var ss: TStringStream;
begin
  if FStringCached then
  begin
    Result := FStringData;
    Exit;
  end;

  ss := TStringStream.Create('');
  try
    SaveToStream(ss);
    Result :=  ss.DataString;
    if (GetSubType = 1) and (FBPB = nil) then
      SetCodePage(Result,GetCodePage,false);
  finally
    ss.Free;
  end;
  FStringData := Result;
  FStringCached := true;
end;

procedure TFBBlob.SetAsString(aValue: rawbytestring);
var
  ss: TStringStream;
begin
  {if GetUnconfirmedCharacterSet then
    IBError(ibxeNoDefaultCharacterSet,[nil]);}

  if (GetSubType = 1) and  (StringCodePage(aValue) <> GetCodePage) and
           (GetCodePage <> CP_NONE) and (FBPB = nil) then
    SetCodePage(aValue,GetCodePage,true);
  ss := TStringStream.Create(aValue);
  try
    LoadFromStream(ss);
  finally
    ss.Free;
  end;
  FStringData := aValue;
  FStringCached := true;
end;

function TFBBlob.SetString(aValue: rawbytestring): IBlob;
begin
  SetAsString(aValue);
  Result := GetIntf;
end;

{TFBBlobMetaData}

procedure TFBBlobMetaData.NeedSubType;
begin
  if not FHasSubType then
  begin
    NeedFullMetadata;
    FHasSubType := true;
  end;
end;

constructor TFBBlobMetaData.Create(Transaction: TFBTransaction; RelationName,
  ColumnName: string);
begin
  inherited Create(Transaction);
//  if (RelationName = '') or (ColumnName = '') then
 //   IBError(ibxeMissingColumnName,[]);
  FRelationName := RelationName;
  FColumnName := ColumnName;
  FSegmentSize := 80;
end;

function TFBBlobMetaData.GetSubType: integer;
begin
  NeedSubType;
  Result := FSubType;
end;

function TFBBlobMetaData.GetCharSetID: cardinal;
begin
  NeedFullMetadata;
  Result := FCharSetID;
end;

function TFBBlobMetaData.GetCodePage: TSystemCodePage;
begin
  FirebirdClientAPI.CharSetID2CodePage(GetCharSetID,Result);
end;

function TFBBlobMetaData.GetSegmentSize: cardinal;
begin
  NeedFullMetadata;
  Result := FSegmentSize;
end;

function TFBBlobMetaData.GetRelationName: string;
begin
  Result := FRelationName;
end;

function TFBBlobMetaData.GetColumnName: string;
begin
  Result := FColumnName;
end;

function TFBBlobMetaData.GetUnconfirmedCharacterSet: boolean;
begin
  NeedFullMetadata;
  Result := FUnconfirmedCharacterSet;
end;


end.

Revision:	45
Committed:	Tue Dec 6 10:33:46 2016 UTC (8 years ago) by tony
Content type:	text/x-pascal
Original Path:	*ibx/trunk/fbintf/client/FBBlob.pas*
File size:	10081 byte(s)
Log Message:	Committing updates for Release R2-0-0
#	Content
1	(*
2	* Firebird Interface (fbintf). The fbintf components provide a set of
3	* Pascal language bindings for the Firebird API. Although predominantly
4	* a new development they include source code taken from IBX and may be
5	* considered a derived product. This software thus also includes the copyright
6	* notice and license conditions from IBX.
7	*
8	* Except for those parts dervied from IBX, contents of this file are subject
9	* to the Initial Developer's Public License Version 1.0 (the "License"); you
10	* may not use this file except in compliance with the License. You may obtain a
11	* copy of the License here:
12	*
13	* http://www.firebirdsql.org/index.php?op=doc&id=idpl
14	*
15	* Software distributed under the License is distributed on an "AS
16	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
17	* implied. See the License for the specific language governing rights
18	* and limitations under the License.
19	*
20	* The Initial Developer of the Original Code is Tony Whyman.
21	*
22	* The Original Code is (C) 2016 Tony Whyman, MWA Software
23	* (http://www.mwasoftware.co.uk).
24	*
25	* All Rights Reserved.
26	*
27	* Contributor(s): ______________________________________.
28	*
29	*)
30	unit FBBlob;
31
32	{$IFDEF FPC}
33	{$mode objfpc}{$H+}
34	{$interfaces COM}
35	{$ENDIF}
36
37	interface
38
39	uses
40	Classes, SysUtils, IB, FBActivityMonitor, FBTransaction, FBClientAPI;
41
42	type
43
44	{ TFBBlobMetaData }
45
46	TFBBlobMetaData = class(TActivityReporter)
47	private
48	FRelationName: string;
49	FColumnName: string;
50	protected
51	FUnconfirmedCharacterSet: boolean;
52	FHasSubType: boolean;
53	FSubType: integer;
54	FCharSetID: cardinal;
55	FSegmentSize: cardinal;
56	procedure NeedFullMetadata; virtual; abstract;
57	procedure NeedSubType;
58	public
59	constructor Create(Transaction: TFBTransaction; RelationName, ColumnName: string
60	);
61
62	public
63	{IBlobMetaData}
64	function GetSubType: integer;
65	function GetCharSetID: cardinal;
66	function GetCodePage: TSystemCodePage;
67	function GetSegmentSize: cardinal;
68	function GetRelationName: string;
69	function GetColumnName: string;
70	function GetUnconfirmedCharacterSet: boolean;
71	end;
72
73	TFBBlob = class(TActivityReporter)
74	private
75	FMetaData: IBlobMetaData;
76	FAttachment: IAttachment;
77	FTransaction: ITransaction;
78	FBPB: IBPB;
79	FStringData: rawbytestring;
80	FStringCached: boolean;
81	protected
82	FCreating: boolean;
83	FBlobID: TISC_QUAD;
84	procedure CheckReadable; virtual; abstract;
85	procedure CheckWritable; virtual; abstract;
86	procedure ClearStringCache;
87	function GetIntf: IBlob; virtual; abstract;
88	procedure InternalClose(Force: boolean); virtual; abstract;
89	procedure InternalCancel(Force: boolean); virtual; abstract;
90	public
91	constructor Create(Attachment: IAttachment; Transaction: TFBTransaction;
92	MetaData: IBlobMetaData; BPB: IBPB); overload;
93	constructor Create(Attachment: IAttachment; Transaction: TFBTransaction;
94	MetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB); overload;
95	destructor Destroy; override;
96	procedure TransactionEnding(aTransaction: TFBTransaction; Force: boolean);
97
98	public
99	{IBlobMetaData}
100	function GetSubType: integer;
101	function GetCharSetID: cardinal;
102	function GetCodePage: TSystemCodePage;
103	function GetSegmentSize: cardinal;
104	function GetRelationName: string;
105	function GetColumnName: string;
106	function GetUnconfirmedCharacterSet: boolean;
107
108	{IBlob}
109	function GetBPB: IBPB;
110	procedure Cancel;
111	procedure Close;
112	function GetBlobSize: Int64;
113	procedure GetInfo(var NumSegments: Int64; var MaxSegmentSize, TotalSize: Int64;
114	var BlobType: TBlobType); virtual; abstract;
115	function GetBlobID: TISC_QUAD;
116	function GetBlobMode: TFBBlobMode;
117	function Read(var Buffer; Count: Longint): Longint; virtual; abstract;
118	function Write(const Buffer; Count: Longint): Longint; virtual; abstract;
119	function LoadFromFile(Filename: string): IBlob;
120	function LoadFromStream(S: TStream) : IBlob;
121	function SaveToFile(Filename: string): IBlob;
122	function SaveToStream(S: TStream): IBlob;
123	function GetAttachment: IAttachment;
124	function GetTransaction: ITransaction;
125	function GetAsString: rawbytestring;
126	procedure SetAsString(aValue: rawbytestring);
127	function SetString(aValue: rawbytestring): IBlob;
128	end;
129
130
131
132	implementation
133
134	uses FBMessages;
135
136	{ TFBBlob }
137
138	procedure TFBBlob.ClearStringCache;
139	begin
140	FStringData := '';
141	FStringCached := false;
142	end;
143
144	constructor TFBBlob.Create(Attachment: IAttachment;
145	Transaction: TFBTransaction; MetaData: IBlobMetaData; BPB: IBPB);
146	begin
147	inherited Create(Transaction);
148	FAttachment := Attachment;
149	FTransaction := Transaction;
150	FMetaData := MetaData;
151	FBPB := BPB;
152	FCreating := true;
153	end;
154
155	constructor TFBBlob.Create(Attachment: IAttachment;
156	Transaction: TFBTransaction; MetaData: IBlobMetaData; BlobID: TISC_QUAD; BPB: IBPB);
157	begin
158	Create(Attachment,Transaction,MetaData,BPB);
159	FBlobID := BlobID;
160	FCreating := false;
161	end;
162
163	destructor TFBBlob.Destroy;
164	begin
165	if FCreating then
166	Cancel
167	else
168	Close;
169	inherited Destroy;
170	end;
171
172	procedure TFBBlob.TransactionEnding(aTransaction: TFBTransaction;
173	Force: boolean);
174	begin
175	if aTransaction <> FTransaction then
176	Exit;
177	if FCreating then
178	InternalCancel(Force)
179	else
180	InternalClose(Force);
181	end;
182
183	function TFBBlob.GetSubType: integer;
184	begin
185	Result := FMetaData.GetSubType;
186	end;
187
188	function TFBBlob.GetCharSetID: cardinal;
189	begin
190	Result := FMetaData.GetCharSetID;
191	end;
192
193	function TFBBlob.GetCodePage: TSystemCodePage;
194	begin
195	Result := FMetaData.GetCodePage;
196	end;
197
198	function TFBBlob.GetSegmentSize: cardinal;
199	begin
200	Result := FMetaData.GetSegmentSize;
201	end;
202
203	function TFBBlob.GetRelationName: string;
204	begin
205	Result := FMetaData.GetRelationName;
206	end;
207
208	function TFBBlob.GetColumnName: string;
209	begin
210	Result := FMetaData.GetColumnName;
211	end;
212
213	function TFBBlob.GetUnconfirmedCharacterSet: boolean;
214	begin
215	Result := (FMetadata as TFBBlobMetadata).GetUnconfirmedCharacterSet;
216	end;
217
218	function TFBBlob.GetBPB: IBPB;
219	begin
220	Result := FBPB;
221	end;
222
223	procedure TFBBlob.Cancel;
224	begin
225	InternalCancel(false);
226	end;
227
228	procedure TFBBlob.Close;
229	begin
230	InternalClose(false);
231	end;
232
233	function TFBBlob.GetBlobSize: Int64;
234	var NumSegments: Int64;
235	MaxSegmentSize: Int64;
236	BlobType: TBlobType;
237	begin
238	GetInfo(NumSegments,MaxSegmentSize,Result,BlobType);
239	end;
240
241	function TFBBlob.GetBlobID: TISC_QUAD;
242	begin
243	Result := FBlobID;
244	end;
245
246	function TFBBlob.GetBlobMode: TFBBlobMode;
247	begin
248	if FCreating then
249	Result := fbmWrite
250	else
251	Result := fbmRead;
252	end;
253
254	function TFBBlob.LoadFromFile(Filename: string): IBlob;
255	var
256	Stream: TStream;
257	begin
258	Stream := TFileStream.Create(FileName, fmOpenRead);
259	try
260	Result := LoadFromStream(Stream);
261	finally
262	Stream.Free;
263	end;
264	end;
265
266	const BufSize = 8 * 1024;
267
268	function TFBBlob.LoadFromStream(S: TStream): IBlob;
269	var Buffer: array [0..BufSize-1] of char;
270	BytesRead: integer;
271	begin
272	CheckWritable;
273	S.Position := 0;
274	repeat
275	BytesRead := S.Read(Buffer,BufSize);
276	Write(Buffer,BytesRead);
277	until BytesRead = 0;
278	Close;
279	Result := GetIntf;
280	end;
281
282	function TFBBlob.SaveToFile(Filename: string): IBlob;
283	var
284	Stream: TStream;
285	begin
286	Stream := TFileStream.Create(FileName, fmCreate);
287	try
288	Result := SaveToStream(Stream);
289	finally
290	Stream.Free;
291	end;
292	end;
293
294	function TFBBlob.SaveToStream(S: TStream): IBlob;
295	var Buffer: array [0..BufSize-1] of char;
296	BytesRead: integer;
297	begin
298	CheckReadable;
299	repeat
300	BytesRead := Read(Buffer,BufSize);
301	S.Write(Buffer,BytesRead);
302	until BytesRead = 0;
303	Close;
304	Result := GetIntf;
305	end;
306
307	function TFBBlob.GetAttachment: IAttachment;
308	begin
309	Result := FAttachment;
310	end;
311
312	function TFBBlob.GetTransaction: ITransaction;
313	begin
314	Result := FTransaction;
315	end;
316
317	function TFBBlob.GetAsString: rawbytestring;
318	var ss: TStringStream;
319	begin
320	if FStringCached then
321	begin
322	Result := FStringData;
323	Exit;
324	end;
325
326	ss := TStringStream.Create('');
327	try
328	SaveToStream(ss);
329	Result := ss.DataString;
330	if (GetSubType = 1) and (FBPB = nil) then
331	SetCodePage(Result,GetCodePage,false);
332	finally
333	ss.Free;
334	end;
335	FStringData := Result;
336	FStringCached := true;
337	end;
338
339	procedure TFBBlob.SetAsString(aValue: rawbytestring);
340	var
341	ss: TStringStream;
342	begin
343	{if GetUnconfirmedCharacterSet then
344	IBError(ibxeNoDefaultCharacterSet,[nil]);}
345
346	if (GetSubType = 1) and (StringCodePage(aValue) <> GetCodePage) and
347	(GetCodePage <> CP_NONE) and (FBPB = nil) then
348	SetCodePage(aValue,GetCodePage,true);
349	ss := TStringStream.Create(aValue);
350	try
351	LoadFromStream(ss);
352	finally
353	ss.Free;
354	end;
355	FStringData := aValue;
356	FStringCached := true;
357	end;
358
359	function TFBBlob.SetString(aValue: rawbytestring): IBlob;
360	begin
361	SetAsString(aValue);
362	Result := GetIntf;
363	end;
364
365	{TFBBlobMetaData}
366
367	procedure TFBBlobMetaData.NeedSubType;
368	begin
369	if not FHasSubType then
370	begin
371	NeedFullMetadata;
372	FHasSubType := true;
373	end;
374	end;
375
376	constructor TFBBlobMetaData.Create(Transaction: TFBTransaction; RelationName,
377	ColumnName: string);
378	begin
379	inherited Create(Transaction);
380	// if (RelationName = '') or (ColumnName = '') then
381	// IBError(ibxeMissingColumnName,[]);
382	FRelationName := RelationName;
383	FColumnName := ColumnName;
384	FSegmentSize := 80;
385	end;
386
387	function TFBBlobMetaData.GetSubType: integer;
388	begin
389	NeedSubType;
390	Result := FSubType;
391	end;
392
393	function TFBBlobMetaData.GetCharSetID: cardinal;
394	begin
395	NeedFullMetadata;
396	Result := FCharSetID;
397	end;
398
399	function TFBBlobMetaData.GetCodePage: TSystemCodePage;
400	begin
401	FirebirdClientAPI.CharSetID2CodePage(GetCharSetID,Result);
402	end;
403
404	function TFBBlobMetaData.GetSegmentSize: cardinal;
405	begin
406	NeedFullMetadata;
407	Result := FSegmentSize;
408	end;
409
410	function TFBBlobMetaData.GetRelationName: string;
411	begin
412	Result := FRelationName;
413	end;
414
415	function TFBBlobMetaData.GetColumnName: string;
416	begin
417	Result := FColumnName;
418	end;
419
420	function TFBBlobMetaData.GetUnconfirmedCharacterSet: boolean;
421	begin
422	NeedFullMetadata;
423	Result := FUnconfirmedCharacterSet;
424	end;
425
426
427	end.
428