source: branches/ByteArray/Devices/DeviceMapper.pas

unit DeviceMapper;

interface

uses
  Classes, SysUtils, Device, Channel, Generics.Collections, Int, Math;

type

  { TMappedDevice }

  TMappedDevice = class
    Device: TDevice;
    ReadCount: Integer;
    WriteCount: Integer;
    ReadBase: Integer;
    WriteBase: Integer;
    constructor Create;
    destructor Destroy; override;
  end;

  { TDeviceMapper }

  TDeviceMapper = class(TChannelDevice)
  private
    function ChannelRead(Address: TInt; Size: TIntSize): TInt;
    procedure ChannelWrite(Address: TInt; Size: TIntSize; Value: TInt);
    function ChannelGetSize: TInt;
  public
    ReadHandlers: TList<TReadEvent>;
    WriteHandlers: TList<TWriteEvent>;
    MappedDevices: TObjectList<TMappedDevice>;
    procedure RegisterDevice(Device: TDevice);
    procedure UnregisterDevice(Device: TDevice);
    procedure SetChannel(Channel: TChannel); override;
    constructor Create;
    destructor Destroy; override;
  end;


implementation

{ TMappedDevice }

constructor TMappedDevice.Create;
begin
end;

destructor TMappedDevice.Destroy;
begin
  inherited;
end;

{ TDeviceMapper }

procedure TDeviceMapper.RegisterDevice(Device: TDevice);
var
  NewMappedDevice: TMappedDevice;
  Handlers: THandlers;
begin
  Handlers := Device.GetHandlers;

  NewMappedDevice := TMappedDevice.Create;
  NewMappedDevice.Device := Device;
  NewMappedDevice.ReadBase := ReadHandlers.Count;
  NewMappedDevice.WriteBase := WriteHandlers.Count;
  NewMappedDevice.ReadCount := Handlers.ReadHandlers.Count;
  NewMappedDevice.WriteCount := Handlers.WriteHandlers.Count;
  MappedDevices.Add(NewMappedDevice);

  ReadHandlers.AddRange(Handlers.ReadHandlers);
  WriteHandlers.AddRange(Handlers.WriteHandlers);
  Handlers.Free;
end;

procedure TDeviceMapper.UnregisterDevice(Device: TDevice);
var
  I: Integer;
begin
  for I := 0 to MappedDevices.Count - 1 do
    if MappedDevices[I].Device = Device then begin
      MappedDevices.Delete(I);
      Break;
    end;
end;

function TDeviceMapper.ChannelRead(Address: TInt; Size: TIntSize): TInt;
begin
  if Address < ReadHandlers.Count then
    Result := ReadHandlers[Address](Size)
    else Result := 0;
end;

procedure TDeviceMapper.ChannelWrite(Address: TInt; Size: TIntSize; Value: TInt);
var
  I: Integer;
begin
  if Address < WriteHandlers.Count then
    WriteHandlers[Address](Size, Value);
end;

function TDeviceMapper.ChannelGetSize: TInt;
begin
  Result := Max(ReadHandlers.Count, WriteHandlers.Count);
end;

procedure TDeviceMapper.SetChannel(Channel: TChannel);
begin
  Channel.Read := ChannelRead;
  Channel.Write := ChannelWrite;
  Channel.GetSize := ChannelGetSize;
end;

constructor TDeviceMapper.Create;
begin
  MappedDevices := TObjectList<TMappedDevice>.Create;
  ReadHandlers := TList<TReadEvent>.Create;
  WriteHandlers := TList<TWriteEvent>.Create;
end;

destructor TDeviceMapper.Destroy;
begin
  FreeAndNil(ReadHandlers);
  FreeAndNil(WriteHandlers);
  FreeAndNil(MappedDevices);
  inherited;
end;

end.