Contributor: NFI EXPERIMENTAL PROGRAMMING
{-----------------------------------------------------------------------------}
{ A dynamic variable length record and array class for Delphi 2.0 }
{ Copyright 1996,97 NFI Experimental Programming. All Rights Reserved. }
{ This component can be freely used and distributed in commercial and private }
{ environments, provided this notice is not modified in any way and there is }
{ no charge for it other than nomial handling fees. Contact NFI directly for }
{ modifications to this agreement. }
{-----------------------------------------------------------------------------}
{ All correspondance concerning this file should be directed to }
{ NFI Experimental Programming, E-Mail }
{ nfi@post1.com }
{-----------------------------------------------------------------------------}
{ Date last modified: March 4, 1997 }
{-----------------------------------------------------------------------------}
{-----------------------------------------------------------------------------}
{ SORRY FOR THE LACK OF COMMENTING, but as this file was initially designed }
{ and documented "in-house" minimal commenting was deemed necessary. It was }
{ only after this file was requested by several individuals that we decided }
{ on releasing in to the general public. Thus commenting has escaped the }
{ grasp of this source. }
{-----------------------------------------------------------------------------}
{ ----------------------------------------------------------------------------}
{ TNFIRecordList v2.1 }
{ ----------------------------------------------------------------------------}
{ Description: }
{ The TNFIRecordList class operates similarly to the traditional Pascal }
{ TCollection object. It creates a list consisting of TNFIRecordItem }
{ objects capable of storing whatever information you require. }
{-----------------------------------------------------------------------------}
{ ----------------------------------------------------------------------------}
{ TNFIVarRec v2.1 }
{ ----------------------------------------------------------------------------}
{ Description: }
{ NOT TO BE CONFUSED WITH BORLANDS TVARREC type for variants!!! TNFIVarRec }
{ is a variable record class that allows easy data access. It does not }
{ store the internal makeup of information you have stored, so if you store }
{ an integer and two strings then you must remember that! }
{ }
{ Storing and retrieving this information from TNFIVarRec is relatively }
{ easy, take for example: }
{ }
{ I want to store an integer and two strings. How do I do this? }
{ STORING: }
{ NFIVarRec.vInteger := AnInteger; }
{ NFIVarRec.vString := AString1; }
{ NFIVarRec.vString := AString2; }
{ RETRIEVAL:
{ NFIVarRec.ResetPointer; // Point to the start of the record. Do NOT }
{ // call "Reset" as this will remove all data }
{ // contained within TNFIVarRec! }
{ AnInteger := NFIVarRec.vInteger; }
{ AString1 := NFIVarRec.vString; }
{ AString2 := NFIVarRec.vString; }
{ }
{ Note that you must read this information in exactly the same order as you }
{ stored it! }
{-----------------------------------------------------------------------------}
{ ----------------------------------------------------------------------------}
{ TLongArray 2.1 }
{ ----------------------------------------------------------------------------}
{ Description: }
{ TLongArray is a dynamic LongInt array object. Information can be accessed }
{ in the same manner as an array, for example LongArray[x] but supports }
{ item-index removal. If you remove the first item then all other items are }
{ brought down one index automatically. }
{ }
{ The biggest problem associated with this object is the fact that it }
{ ONE based, not Zero as is traditional with C/C++ or Delphi. This is }
{ because all in-house work using TLongArray is one based. If someone would }
{ like to post a fix, feel free to contact us and let us know! }
{ ----------------------------------------------------------------------------}
unit NFILists;
interface
uses SysUtils, Classes, Windows;
{=======================================================================}
{ RECORD OBJECT TYPES }
{=======================================================================}
{ TNFIRecordList }
{ This object is the generic record storage object. It maintains a }
{ maximum list of "MaxInt" records of type TNFIRecordItem. }
type
TNFIVarRec = class;
TNFIRecordItem = class(TObject)
private
Buffer: Pointer;
RecordSize: Integer;
public
constructor Create(ARecord: Pointer; ASize: Integer);
destructor Destroy; override;
published
property Data: Pointer read Buffer;
property Size: Integer read RecordSize;
end;
TNFIRecordList = class(TObject)
private
FItems: TList;
RecordCount: Integer;
public
constructor Create;
destructor Destroy; override;
procedure AddRecord(ARecord: Pointer; Size: Integer);
procedure AddTNFIVarRec(ARecord: TNFIVarRec);
procedure InsertRecord(ARecord: Pointer; AtPos, Size: Integer);
procedure RemoveRecord(ARecNum: Integer);
function GetRecord(ARecNum: Integer): Pointer;
function GetTNFIVarRec(ARecNum: Integer; var ARecord: TNFIVarRec): Boolean;
function GetRecordSize(ARecNum: Integer): Integer;
procedure Clear;
published
property Items: TList read FItems;
{property Size: Integer read RecordSize;}
property Count: Integer read RecordCount;
end;
TNFIVarRec = class(TObject)
private
Memory: TMemoryStream;
MemorySize: LongInt;
Ident: Integer;
{ Ident is used as a "Contents Information" identifier }
{ -- As in "What in the heck did I store in this record ?" }
procedure SetMemorySize(ASize: LongInt);
function GetMemory: Pointer;
function GetSize: LongInt;
procedure SetByte(AByte: Byte);
procedure SetShortInt(AShortInt: ShortInt);
procedure SetInteger(AInteger: Integer);
procedure SetWord(AWord: Word);
procedure SetLongInt(ALongInt: LongInt);
procedure SetString(AString: String);
procedure SetTimeStamp(ATime: TDateTime);
function GetByte: Byte;
function GetShortInt: ShortInt;
function GetInteger: Integer;
function GetWord: Word;
function GetLongInt: LongInt;
function GetString: String;
function GetTimeStamp: TDateTime;
public
constructor Create;
destructor Destroy; override;
procedure ResetPointer;
procedure Reset;
procedure Move(Source: Pointer; ASize: LongInt);
{ MOVE: Move converts the buffer to SOURCE, and over-writes existing information }
procedure MoveItem(AnItem: TNFIRecordItem);
{ As with the move above, but uses a TNFIRecordItem object as the source. }
function Append(Source: Pointer; ASize: LongInt): Boolean;
{ APPEND: Appends SOURCE to the end of the current information }
{ THESE BLOBS ARE NOT TRADITIONAL DELPHI DATABASE BLOB OBJECTS. BLOB REFERS TO ANY GENERIC }
{ BINARY OBJECT THAT CAN ONLY BE READ AND WRITTEN FROM MEMORY! IF YOU NEED TO STORE A }
{ BITMAP (FOR INSTANCE), YOU CAN READ AND WRITE IT USING APPENDBLOB AND READBLOBEX! NOTE }
{ THAT TNFIVARREC AUTOMATICALLY STORES THE BLOB SIZE SO WHEN READ THE EQUIVALENT AMOUNT }
{ OF MEMORY IS ALLOCATED. MAXIMUM BLOB SIZE IS 2 GB. }
function AppendBlob(Source: Pointer; ASize: LongInt): Boolean;
{ APPENDBLOB: Appends SOURCE to the end of the current information storing the size of the BLOB}
function ReadBlob(var Buffer: Pointer): LongInt;
{ READBLOB: Reads a BLOB record from the current position within the file. }
{ Buffer SHOULD NOT be assigned as ReadBlob will change it's location !!! }
{ Buffer is in fact set to point to the internal storage area, so prior }
{ to making any changes make sure that you have copied this information }
{ out! }
function ReadBlobEx(var Buffer: Pointer): LongInt;
{ READBLOBEX: Creates a new memory buffer of the appropriate size and copies the }
{ contents of the BLOB into this new buffer. This allows the programmer }
{ to directly perform read/write operations on the buffer, unlike READBLOB }
function AppendPChar(Source: PChar): Boolean;
procedure ReadPChar(Buffer: PChar);
function LoadFromFile(AFileName: String): Boolean;
{ Clears out all information prior to loading and points to START! }
procedure LoadFromStream(AStream: TStream);
procedure SaveToFile(AFileName: String);
procedure SaveToStream(var AStream: TStream);
property vByte: Byte read GetByte write SetByte;
property vShortInt: ShortInt read GetShortInt write SetShortInt;
property vInteger: Integer read GetInteger write SetInteger;
property vWord: Word read GetWord write SetWord;
property vLongInt: LongInt read GetLongInt write SetLongInt;
property vLong: LongInt read GetLongInt write SetLongInt;
property vString: String read GetString write SetString;
property vTime: TDateTime read GetTimeStamp write SetTimeStamp;
property Data: Pointer read GetMemory;
property Size: LongInt read GetSize;
property Capacity: LongInt read MemorySize write SetMemorySize;
property ID: Integer read Ident write Ident default 0; // Set to zero anyway,
end; // but hey...
// TLongArray is one based!
TLongArray = class
private
Buffer: Pointer;
BufferSize, DataSize: LongInt;
procedure Grow; // Conducts a 4k increment
procedure Truncate; // Truncates the buffer at datasize
function GetCount: LongInt;
function GetAtPos(Index: Integer): LongInt;
procedure ReplacePos(Index: Integer; AValue: LongInt);
public
constructor Create;
destructor Destroy; override;
procedure Reset;
procedure Add(ALongInt: LongInt);
procedure Remove(AtPos: LongInt);
procedure Insert(AtPos: LongInt; ALongInt: LongInt);
procedure Replace(AtPos: LongInt; ALongInt: LongInt);
procedure Inc(AtPos, ANum: LongInt);
procedure Dec(AtPos, ANum: LongInt);
property At[Index: Integer]: LongInt read GetAtPos write ReplacePos; default;
property Size: LongInt read DataSize;
property Data: Pointer read Buffer;
property Count: LongInt read GetCount;
end;
implementation
{=======================================================================}
{ ** TNFIRECORDITEM CODE }
{=======================================================================}
constructor TNFIRecordItem.Create(ARecord: Pointer; ASize: Integer);
begin
RecordSize := ASize;
GetMem(Buffer, ASize);
Move(ARecord^, Buffer^, RecordSize);
end;
destructor TNFIRecordItem.Destroy;
begin
FreeMem(Buffer, RecordSize);
end;
{=======================================================================}
{ ** TNFIRECORDLIST CODE }
{=======================================================================}
constructor TNFIRecordList.Create;
begin
RecordCount := 0;
FItems := TList.Create;
end;
destructor TNFIRecordList.Destroy;
begin
if FItems <> nil then Clear;
FItems.Free;
end;
procedure TNFIRecordList.AddRecord(ARecord: Pointer; Size: Integer);
var NewRecord: TNFIRecordItem;
P: Pointer;
begin
NewRecord := TNFIRecordItem.Create(ARecord, Size);
FItems.Add(NewRecord);
Inc(RecordCount);
end;
procedure TNFIRecordList.AddTNFIVarRec(ARecord: TNFIVarRec);
begin
If Assigned(ARecord) Then
AddRecord(ARecord.Data, ARecord.Size);
end;
// Returns a pointer to the data held by a TNFIRecordItem, not a pointer to the
// object itself.
{ The procedure itself uses "ARecord" because without it, the compiler gave }
{ me an error it informs me I shouldn't have. Anyway, it works now so... }
function TNFIRecordList.GetRecord(ARecNum: Integer): Pointer;
var ARecord: TNFIRecordItem;
begin
If (RecordCount = 0) or (ARecNum < 1) or (ARecNum > RecordCount) Then ARecord := nil
Else ARecord := FItems[ARecNum - 1];
If ARecord <> nil Then GetRecord := ARecord.Data Else GetRecord := nil;
end;
function TNFIRecordList.GetTNFIVarRec(ARecNum: Integer; var ARecord: TNFIVarRec): Boolean;
var P: Pointer;
begin
GetTNFIVarRec := False;
If Assigned(ARecord) Then
begin
P := GetRecord(ARecNum);
ARecord.Move(P, GetRecordSize(ARecNum));
GetTNFIVarRec := True;
end;
end;
function TNFIRecordList.GetRecordSize(ARecNum: Integer): Integer;
begin
If (RecordCount = 0) or (ARecNum < 1) or (ARecNum > RecordCount) Then GetRecordSize := -1
Else GetRecordSize := TNFIRecordItem(FItems[ARecNum - 1]).Size;
end;
procedure TNFIRecordList.InsertRecord(ARecord: Pointer; AtPos, Size: Integer);
var NewRecord: TNFIRecordItem;
begin
NewRecord := TNFIRecordItem.Create(ARecord, Size);
FItems.Insert(AtPos - 1, NewRecord); // As this is a 1 based array, subtract
Inc(RecordCount); // one from it as TList is zero-based.
end;
procedure TNFIRecordList.RemoveRecord(ARecNum: Integer);
var ARecord: TNFIRecordItem;
begin
If (RecordCount > 0) and (ARecNum > 0) and (ARecNum <= RecordCount) Then
begin
ARecord := FItems[ARecNum - 1];
FItems.Delete(ARecNum - 1);
ARecord.Free;
Dec(RecordCount);
end;
end;
procedure TNFIRecordList.Clear;
var i: Integer;
begin
If RecordCount > 0 Then
For i := RecordCount downto 1 Do
RemoveRecord(i);
end;
{=======================================================================}
{ ** TNFIVarRec CODE }
{=======================================================================}
constructor TNFIVarRec.Create;
begin
MemorySize := 8192;
try
Memory := TMemoryStream.Create;
except
Abort;
end;
end;
destructor TNFIVarRec.Destroy;
begin
If Assigned(Memory) Then Memory.Free;
end;
procedure TNFIVarRec.ResetPointer;
begin
Memory.Position := 0;
end;
procedure TNFIVarRec.Reset;
begin
ResetPointer;
Memory.Clear;
end;
procedure TNFIVarRec.SetMemorySize(ASize: LongInt);
begin
If Assigned(Memory) Then Memory.SetSize(ASize);
end;
procedure TNFIVarRec.Move(Source: Pointer; ASize: LongInt);
begin
Reset;
Memory.WriteBuffer(Source^, ASize);
end;
procedure TNFIVarRec.MoveItem(AnItem: TNFIRecordItem);
begin
If Assigned(AnItem) Then
Move(AnItem.Data, AnItem.Size);
end;
function TNFIVarRec.Append(Source: Pointer; ASize: LongInt): Boolean;
begin
try
Memory.WriteBuffer(Source^, ASize);
Append := True;
except
Append := False;
end;
end;
{ THESE BLOBS ARE NOT TRADITIONAL DELPHI DATABASE BLOB OBJECTS. BLOB REFERS TO ANY GENERIC }
{ BINARY OBJECT THAT CAN ONLY BE READ AND WRITTEN FROM MEMORY! IF YOU NEED TO STORE A }
{ BITMAP (FOR INSTANCE), YOU CAN READ AND WRITE IT USING APPENDBLOB AND READBLOB! NOTE }
{ THAT TNFIVARREC AUTOMATICALLY STORES THE BLOB SIZE SO WHEN READ THE EQUIVALENT AMOUNT }
{ OF MEMORY IS ALLOCATED. MAXIMUM BLOB SIZE IS 2 GB. }
function TNFIVarRec.AppendBlob(Source: Pointer; ASize: LongInt): Boolean;
begin
try
Memory.WriteBuffer(ASize, 4);
Memory.WriteBuffer(Source^, ASize);
AppendBlob := True;
except
AppendBlob := False;
end;
end;
{ Please read the associated notes located at the class definition }
function TNFIVarRec.ReadBlob(var Buffer: Pointer): LongInt;
var BlobSize: LongInt;
begin
try
Memory.ReadBuffer(BlobSize, 4);
Buffer := Pointer(LongInt(Memory.Memory) + Memory.Position);
Memory.Position := Memory.Position + BlobSize;
ReadBlob := BlobSize;
except
Buffer := nil;
ReadBlob := -1;
end;
end;
{ Please read the associated notes located at the class definition }
function TNFIVarRec.ReadBlobEx(var Buffer: Pointer): LongInt;
var BlobSize: LongInt;
P: Pointer;
begin
try
Memory.ReadBuffer(BlobSize, 4);
P := Pointer(LongInt(Memory.Memory) + Memory.Position);
Buffer := AllocMem(BlobSize);
System.Move(P^, Buffer^, BlobSize);
Memory.Position := Memory.Position + BlobSize;
ReadBlobEx := BlobSize;
except
Buffer := nil;
ReadBlobEx := -1;
end;
end;
function TNFIVarRec.LoadFromFile(AFileName: String): Boolean;
var FileStream: TFileStream;
begin
LoadFromFile := False;
try
FileStream := TFileStream.Create(AFilename, fmOpenRead);
Reset;
Memory.CopyFrom(FileStream, FileStream.Size);
Memory.Position := 0;
LoadFromFile := True;
finally
If Assigned(FileStream) Then FileStream.Free;
end;
end;
procedure TNFIVarRec.LoadFromStream(AStream: TStream);
begin
Reset;
Memory.CopyFrom(AStream, AStream.Size);
Memory.Position := 0;
end;
procedure TNFIVarRec.SaveToFile(AFileName: String);
var FileStream: TFileStream;
begin
try
FileStream := TFileStream.Create(AFilename, fmCreate);
ResetPointer; // NOT RESET! We want to keep all information!
FileStream.CopyFrom(Memory, Memory.Size);
finally
If Assigned(FileStream) Then FileStream.Free;
end;
end;
procedure TNFIVarRec.SaveToStream(var AStream: TStream);
begin
ResetPointer;
AStream.CopyFrom(Memory, Memory.Size);
end;
function TNFIVarRec.GetMemory: Pointer;
begin
GetMemory := Memory.Memory;
end;
function TNFIVarRec.GetSize: LongInt;
begin
GetSize := Memory.Size;
end;
procedure TNFIVarRec.SetByte(AByte: Byte);
begin
Memory.WriteBuffer(AByte, 1);
end;
function TNFIVarRec.GetByte: Byte;
var AResult: Byte;
begin
Memory.ReadBuffer(AResult, 1);
GetByte := AResult;
end;
procedure TNFIVarRec.SetShortInt(AShortInt: ShortInt);
begin
SetByte(AShortInt);
end;
function TNFIVarRec.GetShortInt: ShortInt;
begin
GetShortInt := GetByte;
end;
procedure TNFIVarRec.SetWord(AWord: Word);
begin
Memory.WriteBuffer(AWord, 2);
end;
procedure TNFIVarRec.SetInteger(AInteger: Integer);
begin
SetWord(AInteger);
end;
function TNFIVarRec.GetInteger: Integer;
var AResult: Integer;
begin
Memory.ReadBuffer(AResult, 2);
GetInteger := AResult;
end;
function TNFIVarRec.GetWord: Word;
begin
GetWord := GetInteger;
end;
procedure TNFIVarRec.SetLongInt(ALongInt: LongInt);
begin
Memory.WriteBuffer(ALongInt, 4);
end;
function TNFIVarRec.GetLongInt: LongInt;
var AResult: LongInt;
begin
Memory.ReadBuffer(AResult, 4);
GetLongInt := AResult;
end;
procedure TNFIVarRec.SetString(AString: String);
var P: Pointer;
begin
GetMem(P, Length(AString) + 1);
StrPCopy(P, AString);
Memory.WriteBuffer(P^, Length(AString) + 1);
FreeMem(P);
end;
function TNFIVarRec.GetString: String;
var S: String;
C: Char;
begin
S := '';
Repeat
Memory.ReadBuffer(C, 1);
If C <> #0 Then S := S + C;
Until C = #0;
GetString := S;
end;
procedure TNFIVarRec.SetTimeStamp(ATime: TDateTime);
begin
Memory.WriteBuffer(ATime, SizeOf(TDateTime));
end;
function TNFIVarRec.GetTimeStamp: TDateTime;
var AResult: TDateTime;
begin
Memory.ReadBuffer(AResult, SizeOf(TDateTime));
GetTimeStamp := AResult;
end;
function TNFIVarRec.AppendPChar(Source: PChar): Boolean;
begin
try
Memory.WriteBuffer(Source^, StrLen(Source) + 1); { Include the terminating #0 }
AppendPChar := True;
except
AppendPChar := False;
end;
end;
procedure TNFIVarRec.ReadPChar(Buffer: PChar);
begin
try
StrCopy(Buffer, Pointer(LongInt(Memory.Memory) + Memory.Position));
except
Buffer := nil;
end;
end;
{=======================================================================}
{ ** TLONGARRAY CODE }
{=======================================================================}
constructor TLongArray.Create;
begin
Reset;
end;
destructor TLongArray.Destroy;
begin
If Assigned(Buffer) Then FreeMem(Buffer);
end;
procedure TLongArray.Reset;
begin
If Assigned(Buffer) Then FreeMem(Buffer);
BufferSize := 8192;
Buffer := AllocMem(BufferSize);
DataSize := 0;
end;
procedure TLongArray.Grow; { Add 4 extra kb to the end of the buffer }
begin
System.Inc(BufferSize, 4096);
ReAllocMem(Buffer, BufferSize);
end;
procedure TLongArray.Truncate;
begin
ReAllocMem(Buffer, DataSize);
BufferSize := DataSize;
end;
procedure TLongArray.Add(ALongInt: LongInt);
var P: ^LongInt;
begin
If DataSize = BufferSize Then Grow;
P := Buffer;
System.Inc(LongInt(P), DataSize);
P^ := ALongInt;
System.Inc(DataSize, 4);
end;
procedure TLongArray.Remove(AtPos: LongInt);
var P, Q: Pointer;
CopyAmount: LongInt;
begin
If (DataSize > 0) and (AtPos <= (DataSize div 4)) Then
begin
P := Buffer;
System.Inc(LongInt(P), AtPos * 4); // Point it past the record we are deleting
Q := Buffer;
System.Inc(Longint(Q), (AtPos - 1) * 4); // Point it to the one we are deleting
CopyAmount := DataSize - (AtPos * 4);
If CopyAmount > 0 Then
System.Move(P^, Q^, CopyAmount);
System.Dec(DataSize, 4);
If DataSize > 8192 Then Truncate;
end;
end;
procedure TLongArray.Insert(AtPos: LongInt; ALongInt: LongInt);
var P, TempBuffer: Pointer;
Q: ^LongInt;
CopyAmount: LongInt;
begin
If (AtPos > 0) and ((AtPos - 1 ) * 4 <= DataSize) Then
begin
If BufferSize = DataSize Then Grow;
P := Buffer;
System.Inc(LongInt(P), (AtPos - 1) * 4);
Q := P;
CopyAmount := DataSize - ((AtPos - 1) * 4);
If CopyAmount > 0 Then
begin
GetMem(TempBuffer, CopyAmount);
System.Move(P^, TempBuffer^, CopyAmount);
System.Inc(LongInt(P), 4);
System.Move(TempBuffer^, P^, CopyAmount);
FreeMem(TempBuffer);
end;
Q^ := ALongInt;
System.Inc(DataSize, 4);
end;
end;
function TLongArray.GetAtPos(Index: Integer): LongInt;
var P: ^LongInt;
begin
GetAtPos := 0;
If (Index > 0) and ((Index - 1) * 4 <= DataSize) Then
begin
P := Buffer;
System.Inc(LongInt(P), (Index - 1) * 4);
GetAtPos := P^;
end;
end;
function TLongArray.GetCount: LongInt;
begin
If DataSize = 0 Then GetCount := 0
Else GetCount := DataSize div 4;
end;
procedure TLongArray.Replace(AtPos: LongInt; ALongInt: LongInt);
var P: ^LongInt;
begin
If (AtPos > 0) and ((AtPos - 1) * 4 <= DataSize) Then
begin
P := Buffer;
System.Inc(LongInt(P), (AtPos - 1) * 4);
P^ := ALongInt;
end;
end;
// Used for setting the "write" property of "At"
procedure TLongArray.ReplacePos(Index: Integer; AValue: LongInt);
begin
Replace(Index, AValue);
end;
procedure TLongArray.Inc(AtPos, ANum: LongInt);
var i: LongInt;
begin
i := At[AtPos] + ANum;
Replace(AtPos, i);
end;
procedure TLongArray.Dec(AtPos, ANum: LongInt);
var i: LongInt;
begin
i := At[AtPos] - ANum;
Replace(AtPos, i);
end;
end.