 |
File: HNQueue.pas {****************************************************************************
** **
** PSSDK HNQueue module **
** Copyright (c) 1997 - 2007 microOLAP Technologies LTD, **
** Khalturin A.P., Naumov D.A. **
** **
****************************************************************************}
unit HNQueue;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
HNPSManager, HNPsSdkDef;
type
TOnPacketsReceive = procedure (Sender : TObject; ThParam: Pointer; hPackets: Pointer; Count: DWORD) of object;
TOnPacketReceive = procedure (Sender : TObject; ThParam: Pointer; hPacket: Pointer; pPacketData: Pointer; IncPacketSize: DWORD) of object;
TOnThreadBegin = procedure (Sender : TObject; Var ThParam: Pointer) of object;
TOnThreadEnd = procedure (Sender : TObject; ThParam: Pointer) of object;
TOnDelete = procedure (Sender : TObject) of object;
//---------------------------------------------------------------------------
// Class THNQueue
//---------------------------------------------------------------------------
THNQueue = class
private
hQue : Pointer;
FOnPacketsReceive: TOnPacketsReceive;
FOnPacketReceive: TOnPacketReceive;
FOnThreadBegin: TOnThreadBegin;
FOnThreadEnd: TOnThreadEnd;
FOnDelete: TOnDelete;
private
function GetItemsCount: DWORD;
procedure SetItemsCount(ItemsCount: DWORD);
function GetMaxPacketSize: DWORD;
procedure SetMaxPacketSize(MaxPacketSize: DWORD);
function GetAllocatedSize: DWORD;
function GetFreeCount: DWORD;
function GetFullCount: DWORD;
procedure DoOnPacketReceive(ThParam: Pointer; hPacket: Pointer; pPacketData: Pointer; IncPacketSize: Cardinal);
procedure DoOnThreadBegin(Var ThParam: Pointer);
procedure DoOnThreadEnd(ThParam: Pointer);
procedure DoOnDelete();
// Add in v3.1
function GetOrderingById : BOOL;
procedure SetOrderingById(bOrderingById : BOOL);
function GetReceiveManyAtOnce : BOOL;
procedure SetReceiveManyAtOnce(bReceiveManyAtOnce : BOOL);
procedure DoOnPacketsReceive(ThParam: Pointer; hPackets: Pointer; Count: DWORD);
public
constructor Create();
destructor Destroy(); override;
function IsValid: BOOL;
property Handle: Pointer read hQue;
property AllocatedSize: DWORD read GetAllocatedSize;
property FreeCount: DWORD read GetFreeCount;
property FullCount: DWORD read GetFullCount;
function AllocItems(): DWORD;
function FreeItems(): DWORD;
function Start(): DWORD;
function Stop(): DWORD;
function IsStarted(): BOOL;
function Get_FreeItem(dwMilliseconds : DWORD): Pointer;
procedure Return_FreeItem(hPacket : Pointer);
function Get_FullItem(dwMilliseconds : DWORD): Pointer;
procedure Return_FullItem(hPacket : Pointer);
function UnblockWaitFree() : BOOL;
function UnblockWaitFull() : BOOL;
// Add in v3.1
function Get_FreeItems(dwMilliseconds : DWORD; hPackets: Pointer; Count: DWORD): DWORD;
function Get_FullItems(dwMilliseconds : DWORD; hPackets: Pointer; Count: DWORD): DWORD;
procedure Return_FreeItems(hPackets: Pointer; Count: DWORD);
procedure Return_FullItems(hPackets: Pointer; Count: DWORD);
published
property MaxPacketSize: DWORD read GetMaxPacketSize write SetMaxPacketSize;
property ItemsCount: DWORD read GetItemsCount write SetItemsCount;
property OnPacketReceive: TOnPacketReceive read FOnPacketReceive write FOnPacketReceive;
property OnThreadBegin: TOnThreadBegin read FOnThreadBegin write FOnThreadBegin;
property OnThreadEnd: TOnThreadEnd read FOnThreadEnd write FOnThreadEnd;
property OnDelete: TOnDelete read FOnDelete write FOnDelete;
// Add in v3.1
property OrderingById : BOOL read GetOrderingById write SetOrderingById;
property ReceiveManyAtOnce : BOOL read GetReceiveManyAtOnce write SetReceiveManyAtOnce;
property OnPacketsReceive: TOnPacketsReceive read FOnPacketsReceive write FOnPacketsReceive;
end;
implementation
{$INCLUDE 'HNPsSdkFun.pas'}
//---------------------------------------------------------------------------
// IntOnPacketsReceive - OnPacketReceive event handler.
//---------------------------------------------------------------------------
procedure IntOnPacketsReceive(Param: Pointer; ThParam: Pointer; hPackets: Pointer; Count: DWORD); stdcall;
var
pQue : THNQueue;
begin
pQue := THNQueue(Param);
pQue.DoOnPacketsReceive(ThParam,hPackets,Count);
end;
//---------------------------------------------------------------------------
// IntOnPacketReceive - OnPacketReceive event handler.
//---------------------------------------------------------------------------
procedure IntOnPacketReceive(Param: Pointer; ThParam: Pointer; hPacket: Pointer; pPacketData: Pointer; IncPacketSize: Cardinal); stdcall;
var
pQue : THNQueue;
begin
pQue := THNQueue(Param);
pQue.DoOnPacketReceive(ThParam,hPacket,pPacketData,IncPacketSize);
end;
//---------------------------------------------------------------------------
// IntOnThreadBegin - OnThreadBegin event handler.
//---------------------------------------------------------------------------
procedure IntOnThreadBegin(Param: Pointer; Var ThParam: Pointer); stdcall;
var
pQue : THNQueue;
begin
pQue := THNQueue(Param);
pQue.DoOnThreadBegin(ThParam);
end;
//---------------------------------------------------------------------------
// IntOnThreadEnd - OnThreadEnd event handler.
//---------------------------------------------------------------------------
procedure IntOnThreadEnd(Param: Pointer; ThParam: Pointer); stdcall;
var
pQue : THNQueue;
begin
pQue := THNQueue(Param);
pQue.DoOnThreadEnd(ThParam);
end;
//---------------------------------------------------------------------------
// IntOnDelete - OnDelete event handler.
//---------------------------------------------------------------------------
procedure IntOnDelete(Param: Pointer); stdcall;
var
pQue : THNQueue;
begin
pQue := THNQueue(Param);
pQue.DoOnDelete();
end;
//---------------------------------------------------------------------------
// Create - Creates the HNQueue object.
//---------------------------------------------------------------------------
constructor THNQueue.Create();
begin
hQue := QueCreate();
QueSetOnPacketRecv (hQue,@IntOnPacketReceive, Self);
QueSetOnPacketsRecv(hQue,@IntOnPacketsReceive, Self);
QueSetOnThreadBegin(hQue,@IntOnThreadBegin, Self);
QueSetOnThreadEnd (hQue,@IntOnThreadEnd,Self);
QueSetOnDeleteItems(hQue,@IntOnDelete, Self);
end;
//---------------------------------------------------------------------------
// Destroy - Destroys the HNQueue object.
//---------------------------------------------------------------------------
destructor THNQueue.Destroy();
begin
QueSetOnPacketRecv (hQue,nil,nil);
QueSetOnPacketsRecv(hQue,nil,nil);
QueSetOnThreadBegin(hQue,nil,nil);
QueSetOnThreadEnd (hQue,nil,nil);
QueSetOnDeleteItems(hQue,nil,nil);
QueDestroy(hQue);
end;
//---------------------------------------------------------------------------
// Method - IsValid - Checks if the HNQueue object is created correctly.
//---------------------------------------------------------------------------
function THNQueue.IsValid: BOOL;
begin
Result := (hQue <> nil);
end;
//---------------------------------------------------------------------------
// Property - ItemsCount - Returns an overall quantity of queue elements.
//---------------------------------------------------------------------------
function THNQueue.GetItemsCount(): DWORD;
begin
Result := QueGetItemsCount(hQue);
end;
//---------------------------------------------------------------------------
// Property - ItemsCount - Sets an overall quantity of queue elements.
//---------------------------------------------------------------------------
procedure THNQueue.SetItemsCount(ItemsCount: DWORD);
begin
QueSetItemsCount(hQue,ItemsCount);
end;
//---------------------------------------------------------------------------
// Property - MaxPacketSize - Returns the queue packet maximum size.
//---------------------------------------------------------------------------
function THNQueue.GetMaxPacketSize(): DWORD;
begin
Result := QueGetMaxPacketSize(hQue);
end;
//---------------------------------------------------------------------------
// Property - MaxPacketSize - Sets the queue packet maximum size.
//---------------------------------------------------------------------------
procedure THNQueue.SetMaxPacketSize(MaxPacketSize: DWORD);
begin
QueSetMaxPacketSize(hQue,MaxPacketSize);
end;
//---------------------------------------------------------------------------
// Property - AllocatedSize - Returns total size of the memory pool used by queue.
//---------------------------------------------------------------------------
function THNQueue.GetAllocatedSize(): DWORD;
begin
Result := QueGetAllocatedSize(hQue);
end;
//---------------------------------------------------------------------------
// Property - FreeCount - Returns total amount of the queue items with Free status.
//---------------------------------------------------------------------------
function THNQueue.GetFreeCount(): DWORD;
begin
Result := QueGetFreeCount(hQue);;
end;
//---------------------------------------------------------------------------
// Property - FullCount - Returns total amount of the queue items with Full status.
//---------------------------------------------------------------------------
function THNQueue.GetFullCount(): DWORD;
begin
Result := QueGetFullCount(hQue);
end;
//---------------------------------------------------------------------------
// Method - AllocItems - Allocates memory for queue items and creates queue synchronization objects.
//---------------------------------------------------------------------------
function THNQueue.AllocItems(): DWORD;
begin
Result := QueAllocItems(hQue);;
end;
//---------------------------------------------------------------------------
// Method - FreeItems - Releases queue resources.
//---------------------------------------------------------------------------
function THNQueue.FreeItems(): DWORD;
begin
Result := QueFreeItems(hQue);
end;
//---------------------------------------------------------------------------
// Method - Start - Creates and starts internal queue thread.
//---------------------------------------------------------------------------
function THNQueue.Start(): DWORD;
begin
Result := QueStart(hQue);
end;
//---------------------------------------------------------------------------
// Method - Stop - Stops internal queue thread.
//---------------------------------------------------------------------------
function THNQueue.Stop(): DWORD;
begin
Result := QueStop(hQue);
end;
//---------------------------------------------------------------------------
// Method - IsStarted - Shows the status of the internal thread.
//---------------------------------------------------------------------------
function THNQueue.IsStarted(): BOOL;
begin
Result := QueIsStarted(hQue);
end;
//---------------------------------------------------------------------------
// Method - Get_FreeItem - Returns an element with Free status from the queue.
//---------------------------------------------------------------------------
function THNQueue.Get_FreeItem(dwMilliseconds : DWORD): Pointer;
begin
Result := QueGetFreeItem(hQue,dwMilliseconds);
end;
//---------------------------------------------------------------------------
// Method - Get_FreeItems - Returns an elements with Free status from the queue.
//---------------------------------------------------------------------------
function THNQueue.Get_FreeItems(dwMilliseconds : DWORD; hPackets: Pointer; Count: DWORD): DWORD;
begin
Result := QueGetFreeItems(hQue,dwMilliseconds,hPackets,Count);
end;
//---------------------------------------------------------------------------
// Method - Return_FreeItem - Returns an element with Free status back to the queue.
//---------------------------------------------------------------------------
procedure THNQueue.Return_FreeItem(hPacket : Pointer);
begin
QueReturnFreeItem(hQue,hPacket);
end;
//---------------------------------------------------------------------------
// Method - Return_FreeItems - Returns an elements with Free status back to the queue.
//---------------------------------------------------------------------------
procedure THNQueue.Return_FreeItems(hPackets: Pointer; Count: DWORD);
begin
QueReturnFreeItems(hQue,hPackets,Count);
end;
//---------------------------------------------------------------------------
// Method - Get_FullItem - Returns an element with Full status from the queue.
//---------------------------------------------------------------------------
function THNQueue.Get_FullItem(dwMilliseconds : DWORD): Pointer;
begin
Result := QueGetFullItem(hQue,dwMilliseconds);
end;
//---------------------------------------------------------------------------
// Method - Get_FullItems - Returns an elements with Full status from the queue.
//---------------------------------------------------------------------------
function THNQueue.Get_FullItems(dwMilliseconds : DWORD; hPackets: Pointer; Count: DWORD): DWORD;
begin
Result := QueGetFullItems(hQue,dwMilliseconds,hPackets,Count);
end;
//---------------------------------------------------------------------------
// Method - Return_FullItem - Returns an element with Full status back to the queue.
//---------------------------------------------------------------------------
procedure THNQueue.Return_FullItem(hPacket : Pointer);
begin
QueReturnFullItem(hQue,hPacket);
end;
//---------------------------------------------------------------------------
// Method - Return_FullItems - Returns an elements with Full status back to the queue.
//---------------------------------------------------------------------------
procedure THNQueue.Return_FullItems(hPackets: Pointer; Count: DWORD);
begin
QueReturnFullItems(hQue,hPackets,Count);
end;
//---------------------------------------------------------------------------
// Method - UnblockWaitFree - Turns out all application threads awaiting for Free elements from awaiting status
//---------------------------------------------------------------------------
function THNQueue.UnblockWaitFree() : BOOL;
begin
Result := QueUnblockWaitFree(hQue);
end;
//---------------------------------------------------------------------------
// Method - UnblockWaitFull - Turns out all application threads awaiting for Full elements from awaiting status.
//---------------------------------------------------------------------------
function THNQueue.UnblockWaitFull() : BOOL;
begin
Result := QueUnblockWaitFull(hQue);
end;
//---------------------------------------------------------------------------
// DoOnPacketsReceive - Fire event handler OnPacketsReceive
//---------------------------------------------------------------------------
procedure THNQueue.DoOnPacketsReceive(ThParam: Pointer; hPackets: Pointer; Count: DWORD);
begin
if Assigned(FOnPacketsReceive) then FOnPacketsReceive(Self,ThParam,hPackets,Count);
end;
//---------------------------------------------------------------------------
// DoOnPacketReceive - Occurs in the queue thread context immediately after a packet has been received by the network adapter and was enqueued for further processing.
//---------------------------------------------------------------------------
procedure THNQueue.DoOnPacketReceive(ThParam: Pointer; hPacket: Pointer; pPacketData: Pointer; IncPacketSize: Cardinal);
begin
if Assigned(FOnPacketReceive) then FOnPacketReceive(Self,ThParam,hPacket,pPacketData,IncPacketSize);
end;
//---------------------------------------------------------------------------
// DoOnThreadBegin - Tracks the creating of the internal queue thread.
//---------------------------------------------------------------------------
procedure THNQueue.DoOnThreadBegin(Var ThParam: Pointer);
begin
if Assigned(FOnThreadBegin) then FOnThreadBegin(Self,ThParam);
end;
//---------------------------------------------------------------------------
// DoOnThreadEnd - Tracks the closing of the internal component thread.
//---------------------------------------------------------------------------
procedure THNQueue.DoOnThreadEnd(ThParam: Pointer);
begin
if Assigned(FOnThreadEnd) then FOnThreadEnd(Self,ThParam);
end;
//---------------------------------------------------------------------------
// DoOnDelete - Tracks the releasing of the queue resources
//---------------------------------------------------------------------------
procedure THNQueue.DoOnDelete();
begin
if Assigned(FOnDelete) then FOnDelete(Self);
end;
//---------------------------------------------------------------------------
// v3.1 - QueGetOrderingById - Return sort packets by ID flag
//---------------------------------------------------------------------------
function THNQueue.GetOrderingById : BOOL;
begin
Result := QueGetOrderingById(hQue);
end;
//---------------------------------------------------------------------------
// v3.1 - QueSetOrderingById - Set sort packets by ID flag
//---------------------------------------------------------------------------
procedure THNQueue.SetOrderingById(bOrderingById : BOOL);
begin
QueSetOrderingById(hQue,bOrderingById);
end;
//---------------------------------------------------------------------------
// v3.1 - QueGetReceiveManyAtOnce - Return ReceiveManyAtOnce flag (see OnPacket(s)Receive event).
//---------------------------------------------------------------------------
function THNQueue.GetReceiveManyAtOnce : BOOL;
begin
Result := QueGetReceiveManyAtOnce(hQue);
end;
//---------------------------------------------------------------------------
// v3.1 - QueSetReceiveManyAtOnce - Set ReceiveManyAtOnce flag (see OnPacket(s)Receive event).
//---------------------------------------------------------------------------
procedure THNQueue.SetReceiveManyAtOnce(bReceiveManyAtOnce : BOOL);
begin
QueSetReceiveManyAtOnce(hQue,bReceiveManyAtOnce);
end;
end.
|
