{
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at http://mozilla.org/MPL/2.0/
*
* Copyright (C) 2009-2012, Peter Johnson (www.delphidabbler.com).
*
* $Rev$
* $Date$
*
* Provides a container for assisting with common file operations.
}
unit UIOUtils;
interface
uses
// Delphi
SysUtils, Classes, Types;
type
/// <summary>
/// Container for methods that assist with common file operations.
/// </summary>
/// <remarks>
/// TFileIO is used instead of IOUtils.TFile because the assumptions TFile
/// makes about the use of byte order marks with encoded text files are not
/// compatible with the needs of this program.
/// </remarks>
TFileIO = record
strict private
class function CheckBOM(const Bytes: TBytes; const Encoding: TEncoding):
Boolean; static;
/// <summary>
/// Appends whole contents of a byte array to a stream.
/// </summary>
class procedure BytesToStream(const Bytes: TBytes; const Stream: TStream);
static;
/// <summary>
/// Copies content of a whole stream into a byte array.
/// </summary>
class function StreamToBytes(const Stream: TStream): TBytes; static;
public
/// <summary>
/// Writes all the bytes from a byte array to a file.
/// </summary>
/// <param name="FileName">string [in] Name of file.</param>
/// <param name="Bytes">TBytes [in] Array of bytes to be written to file.
/// </param>
class procedure WriteAllBytes(const FileName: string; const Bytes: TBytes);
static;
/// <summary>
/// Writes text to a file.
/// </summary>
/// <param name="FileName">string [in] Name of file.</param>
/// <param name="Content">string [in] Text to be written to file.</param>
/// <param name="Encoding">TEncoding [in] Encoding to be used for text in
/// file.</param>
/// <param name="UseBOM">Boolean [in] Flag indicating whether BOM to be
/// written to file. If Encoding has no BOM then UseBOM has no effect.
/// </param>
class procedure WriteAllText(const FileName, Content: string;
const Encoding: TEncoding; const UseBOM: Boolean = False); static;
/// <summary>
/// Writes lines of text to a text file with lines separated by CRLF.
/// </summary>
/// <param name="FileName">string [in] Name of file.</param>
/// <param name="Lines">array of string [in] Array of lines of text to be
/// written.</param>
/// <param name="Encoding">TEncoding [in] Encoding to be used by file.
/// </param>
/// <param name="UseBOM">Boolean [in] Flag indicating whether BOM to be
/// written to file. If Encoding has no BOM then UseBOM has no effect.
/// </param>
class procedure WriteAllLines(const FileName: string;
const Lines: array of string; const Encoding: TEncoding;
const UseBOM: Boolean = False); static;
/// <summary>
/// Reads all bytes from a file into a byte array.
/// </summary>
/// <param name="FileName">string [in] Name of file.</param>
/// <returns>TBytes array containing the file's contents.</returns>
class function ReadAllBytes(const FileName: string): TBytes; static;
/// <summary>
/// Reads all the text from a text file.
/// </summary>
/// <param name="FileName">string [in] Name of file.</param>
/// <param name="Encoding">TEncoding [in] Text encoding used by file.
/// </param>
/// <param name="HasBOM">Boolean [in] Flag indicating if file has a byte
/// order mark. Ignored if Encoding has no BOM.</param>
/// <returns>String containing contents of file.</returns>
/// <remarks>When HasBOM is true and Encoding has a BOM then the BOM must
/// begin the file, otherwise an exception is raised.</remarks>
class function ReadAllText(const FileName: string;
const Encoding: TEncoding; const HasBOM: Boolean = False): string; static;
/// <summary>
/// Reads all the lines of text from a text file.
/// </summary>
/// <param name="FileName">string [in] Name of file.</param>
/// <param name="Encoding">TEncoding [in] Text encoding used by file.
/// </param>
/// <param name="HasBOM">Boolean [in] Flag indicating if file has a byte
/// order mark. Ignored if Encoding has no BOM.</param>
/// <returns>TStringDynArray containing lines from file.</returns>
/// <remarks>When HasBOM is true and Encoding has a BOM then the BOM must
/// begin the file, otherwise an exception is raised.</remarks>
class function ReadAllLines(const FileName: string;
const Encoding: TEncoding; const HasBOM: Boolean = False):
TStringDynArray; static;
/// <summary>
/// Copies content of one file to another.
/// </summary>
/// <param name="SrcFileName">string [in] Name of file to be copied.
/// </param>
/// <param name="DestFileName">string [in] Name of file to receive
/// contents of file named in SrcFileName.</param>
/// <remarks>SrcFileName and DestFileName must be different. SrcFileName
/// must exist. DestFileName is overwritten if it already exists.</remarks>
class procedure CopyFile(const SrcFileName, DestFileName: string); static;
end;
type
/// <summary>Class of exception raised by UIOUtils code.</summary>
EIOUtils = class(Exception);
implementation
resourcestring
// Error messages
sBadBOM = 'Preamble of file %s does not match expected encoding';
{ TFileIO }
class procedure TFileIO.BytesToStream(const Bytes: TBytes;
const Stream: TStream);
begin
if Length(Bytes) > 0 then
Stream.WriteBuffer(Pointer(Bytes)^, Length(Bytes));
end;
class function TFileIO.CheckBOM(const Bytes: TBytes; const Encoding: TEncoding):
Boolean;
var
Preamble: TBytes;
I: Integer;
begin
Preamble := Encoding.GetPreamble;
if Length(Preamble) = 0 then
Exit(False);
if Length(Bytes) < Length(Preamble) then
Exit(False);
for I := 0 to Pred(Length(Preamble)) do
if Bytes[I] <> Preamble[I] then
Exit(False);
Result := True;
end;
class procedure TFileIO.CopyFile(const SrcFileName, DestFileName: string);
begin
TFileIO.WriteAllBytes(DestFileName, TFileIO.ReadAllBytes(SrcFileName));
end;
class function TFileIO.ReadAllBytes(const FileName: string): TBytes;
var
FS: TFileStream;
begin
FS := TFileStream.Create(FileName, fmOpenRead or fmShareDenyNone);
try
Result := StreamToBytes(FS);
finally
FS.Free;
end;
end;
class function TFileIO.ReadAllLines(const FileName: string;
const Encoding: TEncoding; const HasBOM: Boolean): TStringDynArray;
var
Lines: TStrings;
I: Integer;
begin
Assert(Assigned(Encoding), 'TFileIO.ReadAllLines: Encoding is nil');
Lines := TStringList.Create;
try
Lines.Text := ReadAllText(FileName, Encoding, HasBOM);
SetLength(Result, Lines.Count);
for I := 0 to Pred(Lines.Count) do
Result[I] := Lines[I];
finally
Lines.Free;
end;
end;
class function TFileIO.ReadAllText(const FileName: string;
const Encoding: TEncoding; const HasBOM: Boolean): string;
var
Content: TBytes;
SizeOfBOM: Integer;
begin
Assert(Assigned(Encoding), 'TFileIO.ReadAllBytes: Encoding is nil');
Content := ReadAllBytes(FileName);
if HasBOM then
begin
SizeOfBOM := Length(Encoding.GetPreamble);
if (SizeOfBOM > 0) and not CheckBOM(Content, Encoding) then
raise EIOUtils.CreateFmt(sBadBOM, [FileName]);
end
else
SizeOfBOM := 0;
Result := Encoding.GetString(Content, SizeOfBOM, Length(Content) - SizeOfBOM);
end;
class function TFileIO.StreamToBytes(const Stream: TStream): TBytes;
begin
Stream.Position := 0;
SetLength(Result, Stream.Size);
if Stream.Size > 0 then
Stream.ReadBuffer(Pointer(Result)^, Length(Result));
end;
class procedure TFileIO.WriteAllBytes(const FileName: string;
const Bytes: TBytes);
var
FS: TFileStream;
begin
FS := TFileStream.Create(FileName, fmCreate);
try
BytesToStream(Bytes, FS);
finally
FS.Free;
end;
end;
class procedure TFileIO.WriteAllLines(const FileName: string;
const Lines: array of string; const Encoding: TEncoding;
const UseBOM: Boolean);
var
Line: string;
SB: TStringBuilder;
begin
SB := TStringBuilder.Create;
try
for Line in Lines do
SB.AppendLine(Line);
WriteAllText(FileName, SB.ToString, Encoding, UseBOM);
finally
SB.Free;
end;
end;
class procedure TFileIO.WriteAllText(const FileName, Content: string;
const Encoding: TEncoding; const UseBOM: Boolean);
var
FS: TFileStream;
begin
FS := TFileStream.Create(FileName, fmCreate);
try
if UseBOM then
BytesToStream(Encoding.GetPreamble, FS);
BytesToStream(Encoding.GetBytes(Content), FS);
finally
FS.Free;
end;
end;
end.
