RealICQClient/Client/Protocols/BasePacket.pas

unit BasePacket;

interface

uses
  SysUtils, Classes;

type
  TByte = array of Byte;
  TBasePacket = class
  private
    FBuffer: array of byte;
  public
    class function MajorProto: Byte; virtual;
    class function MinorProto: Byte; virtual;
    class function UnPack(const Data: Array of Byte): TBasePacket; virtual;
    function Pack(var buffer: TByte): Boolean; virtual;
    function Dispose: Boolean; virtual;
    function GetLength: Cardinal;
  end;

  TBasePacketClass = TBasePacket;

  TPacketManager = class(TInterfacedObject)
  private
    FClasses: TList;

    function IndexOf(const AMajor, AMinor: Byte): Integer;

  public
    constructor Create;
    destructor Destroy; override;
    class function Current: TPacketManager;

    function GetPacket(const AMajor, AMinor: Byte): TBasePacket;

    procedure RegisterClass(AClass: TBasePacketClass);
  end;

implementation

uses
  LoggerImport, InterfaceLogger;

var
  APacketManager: TPacketManager;

{ TBasePacket }

function TBasePacket.Dispose: Boolean;
begin

end;

function TBasePacket.GetLength: Cardinal;
begin
  Result := Length(FBuffer);
end;

class function TBasePacket.MajorProto: Byte;
begin
  Result := $00;
end;

class function TBasePacket.MinorProto: Byte;
begin
  Result := $00;
end;

function TBasePacket.Pack(var buffer: TByte): Boolean;
begin
  Buffer := TByte(FBuffer);
end;

class function TBasePacket.UnPack(const Data: array of Byte): TBasePacket;
begin

end;

{ TPacketManager }

constructor TPacketManager.Create;
begin
  FClasses := TList.Create;
end;

class function TPacketManager.Current: TPacketManager;
begin
  if APacketManager = nil then
    APacketManager := TPacketManager.Create;
  Result := APacketManager;
end;

destructor TPacketManager.Destroy;
begin
  FreeAndNil(FClasses);
  inherited;
end;

function TPacketManager.GetPacket(const AMajor, AMinor: Byte): TBasePacket;
var
  i: Integer;
begin
  i := IndexOf(AMajor, AMinor);
  if i < 0 then
    LoggerImport.Error(Format('接收到不能正常解析的数据包！Major:%d Minor: %d',[AMajor, AMinor]), 'TPacketManager.GetPacket');
  Result :=  TBasePacket(FClasses[i]);
end;

function TPacketManager.IndexOf(const AMajor, AMinor: Byte): Integer;
var
  i: Integer;
begin
  Result := -1;
  for I := 0 to FClasses.Count - 1 do
    if (TBasePacketClass(FClasses[i]).MajorProto = AMajor) and (TBasePacketClass(FClasses[i]).MajorProto = AMajor) then
    begin
      Result := i;
      Break;
    end;
end;

procedure TPacketManager.RegisterClass(AClass: TBasePacketClass);
var
  i: Integer;
begin
  i := IndexOf(AClass.MajorProto, AClass.MinorProto);
  if i >= 0 then
    raise Exception.CreateFmt('Major:%d Minor:%d已经被%s注册！', [AClass.MajorProto, AClass.MinorProto, TClass(FClasses[i]).ClassName]);

  i := FClasses.IndexOf(AClass);
  if i < 0 then
    FClasses.Add(AClass);
end;

end.