dnudprequestor.pas

一个国外比较早的IOCP控件

// The contents of this file are used with permission, 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/MPL-1.1.html
//
// 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.
{$I DnConfig.inc}
unit DnUdpRequestor;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Winsock2,
  DnConst, DnRtl, DnInterfaces, DnUdpReactor,  DnUdpRequests,
  DnAbstractLogger, DnAbstractExecutor;


type
  TDnUdpRead =          procedure (Context: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer;
                          FromAddr: String; Buf: PChar; BufSize: Cardinal) of object;
  TDnUdpWrite =         procedure (Context: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer;
                           Buf: PChar; BufSize: Cardinal) of object;
  TDnUdpError =         procedure (Context: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer;
                           ErrorCode: Cardinal) of object;

  TDnUdpRequestor = class({$IFDEF ROOTISCOMPONENT}TComponent{$ELSE}TDnObject{$ENDIF},
                          IDnUdpReadHandler, IDnUdpWriteHandler)
  protected
    FReactor:   TDnUdpReactor;
    FLogLevel:  TDnLogLevel;
    FLogger:    TDnAbstractLogger;
    FActive:    Boolean;
    FExecutor:  TDnAbstractExecutor;

    FUdpRead:         TDnUdpRead;
    FUdpWrite:        TDnUdpWrite;
    FUdpError:        TDnUdpError;
    

    //IDnUdpReadHandler
    procedure DoRead(ThreadContext: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer; FromAddr: String; Buffer: PChar; BufSize: Cardinal);
    procedure DoReadError(ThreadContext: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer; ErrorCode: Cardinal);

    //IDnUdpWriteHandler
    procedure DoWrite(ThreadContext: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer; Buffer: PChar; BufSize: Cardinal);
    procedure DoWriteError(ThreadContext: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer; ErrorCode: Cardinal);

    procedure DoError(Context: TDnThreadContext; Socket: IDnUdpSocket;  Key: Pointer;
                      ErrorCode: Cardinal);

    {$IFDEF ROOTISCOMPONENT}
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
    {$ENDIF}
    function TurnOn: Boolean; virtual;
    function TurnOff: Boolean; virtual;
    procedure SetActive(Value: Boolean);
    procedure CheckAvail;

  public
    constructor Create{$IFDEF ROOTISCOMPONENT}(AOwner: TComponent); override{$ENDIF};
    destructor Destroy; override;
    procedure   PostLogMessage(Msg: String);

    procedure Read(Socket: IDnUdpSocket; Key: Pointer; Buf: PChar; BufSize: Cardinal);
    procedure ReadString(Socket: IDnUdpSocket; Key: Pointer; Buf: String);

    procedure Write(Socket: IDnUdpSocket; Key: Pointer; Buf: PChar;
      BufSize: Cardinal; const ToAddr: String; Port: Word);
    procedure WriteString(Socket: IDnUdpSocket; Key: Pointer; const Buf: String;
      const ToAddr: String; Port: Word);
  published
    property Reactor:   TDnUdpReactor read FReactor write FReactor;
    property LogLevel:  TDnLogLevel read FLogLevel write FLogLevel;
    property Logger:    TDnAbstractLogger read FLogger write FLogger;
    property Executor:  TDnAbstractExecutor read FExecutor write FExecutor;
    property Active:    Boolean read FActive write SetActive;

    property OnRead:  TDnUdpRead read FUdpRead write FUdpRead;
    property OnWrite: TDnUdpWrite read FUdpWrite write FUdpWrite;
    property OnError: TDnUdpError read FUdpError write FUdpError;
  end;


procedure Register;

implementation

procedure Register;
begin
  {$IFDEF ROOTISCOMPONENT}
  RegisterComponents('DNet', [TDnUdpRequestor]);
  {$ENDIF}
end;

//----------------------------------------------------------------------------

constructor TDnUdpRequestor.Create{$IFDEF ROOTISCOMPONENT}(AOwner: TComponent){$ENDIF};
begin
  inherited Create{$IFDEF ROOTISCOMPONENT}(AOwner){$ENDIF};
  FUdpRead := Nil;
  FUdpWrite := Nil;
  FUdpError := Nil;
  FLogger := Nil;
  FExecutor := Nil;
  FLogLevel := llMandatory;
  FReactor := Nil;
end;

destructor TDnUdpRequestor.Destroy;
begin
  inherited Destroy;
end;


{$IFDEF ROOTISCOMPONENT}
procedure TDnUdpRequestor.Notification(AComponent: TComponent; Operation: TOperation);
begin
  if (AComponent = FReactor) and (Operation = opRemove) then
    FReactor := Nil;
  if (AComponent = FLogger) and (Operation = opRemove) then
    FLogger := Nil;
end;
{$ENDIF}

procedure TDnUdpRequestor.PostLogMessage(Msg: String);
begin
  try
    if FLogger <> Nil then
      FLogger.LogMsg(FLogLevel, Msg);
  except
    ;
  end;
end;

function TDnUdpRequestor.TurnOn: Boolean;
begin
  Result := True;
end;

function TDnUdpRequestor.TurnOff: Boolean;
begin
  Result := False;
end;

procedure TDnUdpRequestor.SetActive(Value: Boolean);
begin
  if FActive and not Value then
    FActive := TurnOff
  else
  if not FActive and Value then
    FActive := TurnOn;
end;

procedure TDnUdpRequestor.CheckAvail;
begin
  if not FActive then
    raise EDnException.Create(ErrObjectNotActive, 0);
end;

procedure TDnUdpRequestor.Read(Socket: IDnUdpSocket; Key: Pointer; Buf: PChar; BufSize: Cardinal);
var Request: TDnUdpRequest;
begin
  CheckAvail;
  Request := TDnUdpReadRequest.Create(Socket, Key, Self, Buf, BufSize);
  IDnIORequest(Request).Execute;
end;

procedure TDnUdpRequestor.ReadString(Socket: IDnUdpSocket; Key: Pointer; Buf: String);
var Request: TDnUdpRequest;
begin
  CheckAvail;
  Request := TDnUdpReadRequest.CreateString(Socket, Key, Self, Buf);
  IDnIORequest(Request).Execute;
end;

procedure TDnUdpRequestor.Write(Socket: IDnUdpSocket; Key: Pointer; Buf: PChar; BufSize: Cardinal;
  const ToAddr: String; Port: Word);
var Request: TDnUdpRequest;
begin
  CheckAvail;
  Request := TDnUdpWriteRequest.Create(Socket, Key, Self, Buf, BufSize, ToAddr, Port);
  IDnIORequest(Request).Execute;
end;

procedure TDnUdpRequestor.WriteString(Socket: IDnUdpSocket; Key: Pointer; const Buf: String;
  const ToAddr: String; Port: Word);
var Request: TDnUdpRequest;
begin
  CheckAvail;
  Request := TDnUdpWriteRequest.CreateString(Socket, Key, Self, Buf, ToAddr, Port);
  IDnIORequest(Request).Execute;
end;

procedure TDnUdpRequestor.DoRead(ThreadContext: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer;
  FromAddr: String; Buffer: PChar; BufSize: Cardinal);
begin
  try
    if Assigned(FUdpRead) then
      FUdpRead(ThreadContext, Socket, Key, FromAddr, Buffer, BufSize);
  except
    on E: Exception do
      Self.PostLogMessage(E.Message);
  end;
end;

procedure TDnUdpRequestor.DoReadError(ThreadContext: TDnThreadContext; Socket: IDnUdpSocket;
  Key: Pointer; ErrorCode: Cardinal);
begin
  Self.DoError(ThreadContext, Socket, Key, ErrorCode);
end;

procedure TDnUdpRequestor.DoWrite(ThreadContext: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer; Buffer: PChar; BufSize: Cardinal);
begin
  try
    if Assigned(FUdpWrite) then
      FUdpWrite(ThreadContext, Socket, Key, Buffer, BufSize);
  except
    on E: Exception do
      Self.PostLogMessage(E.Message);
  end;
end;

procedure TDnUdpRequestor.DoWriteError(ThreadContext: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer; ErrorCode: Cardinal);
begin
  Self.DoError(ThreadContext, Socket, Key, ErrorCode);
end;

procedure TDnUdpRequestor.DoError(Context: TDnThreadContext; Socket: IDnUdpSocket; Key: Pointer;
                                  ErrorCode: Cardinal);
begin
  try
    if Assigned(FUdpError) then
      FUdpError(Context, Socket, Key, ErrorCode);
  except
    on E: Exception do
      Self.PostLogMessage(E.Message);
  end;
end;


end.