source: branches/simple/DeviceManager.pas

unit DeviceManager;

interface

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

type
  TReadEvent8 = function: Byte of object;
  TReadEvent16 = function: Word of object;
  TWriteEvent8 = procedure (Data: Byte) of object;
  TWriteEvent16 = procedure (Data: Word) of object;

  { TDeviceManager8 }

  TDeviceManager8 = class(TDevice8)
  private
    FreeBaseAddress: Byte;
    Handlers: TObjectList<TChannel8>;
    Devices: TObjectList<TDevice8>;
    procedure RebuildHandlers;
  public
    procedure Write8(Address: Byte; Data: Byte);
    function Read8(Address: Byte): Byte;
    procedure SetDataBus(Channel: TAddressableChannel8); override;
    procedure RegisterDevice(Device: TDevice8);
    procedure UnregisterDevice(Device: TDevice8);
    constructor Create;
    destructor Destroy; override;
  end;

  { TDeviceManager16 }

  TDeviceManager16 = class(TDevice16)
  private
    FreeBaseAddress: Byte;
    Handlers: TObjectList<TChannel16>;
    Devices: TObjectList<TDevice16>;
    procedure RebuildHandlers;
  public
    function GetFreeHandler: TChannel16;
    function Read8(Address: Word): Byte;
    function Read16(Address: Word): Word;
    procedure Write8(Address: Word; Data: Byte);
    procedure Write16(Address: Word; Data: Word);
    procedure SetDataBus(Channel: TAddressableChannel16); override;
    procedure RegisterDevice(Device: TDevice16);
    procedure UnregisterDevice(Device: TDevice16);
    constructor Create;
    destructor Destroy; override;
  end;

  TDeviceManager = class(TDevice)
    BitWidth: TBitWidth;
    DeviceManager8: TDeviceManager8;
    DeviceManager16: TDeviceManager16;
  end;


implementation

{ TDeviceManager16 }

procedure TDeviceManager16.RebuildHandlers;
var
  I, J: Integer;
begin
  for I := 0 to Devices.Count - 1 do begin
    if Handlers.Count < Devices[I].BaseAddress + Devices[I].GetHandlerCount then
      Handlers.Count := Devices[I].BaseAddress + Devices[I].GetHandlerCount;
    for J := 0 to Devices[I].GetHandlerCount - 1 do
      Handlers[Devices[I].BaseAddress + J] := Devices[I].GetHandler(J);
  end;
end;

function TDeviceManager16.GetFreeHandler: TChannel16;
begin
  Result := TChannel16.Create;
  Handlers.Add(Result);
end;

function TDeviceManager16.Read8(Address: Word): Byte;
begin
  Result := Handlers[Address].Read8;
end;

function TDeviceManager16.Read16(Address: Word): Word;
begin
  Result := Handlers[Address].Read16;
end;

procedure TDeviceManager16.Write8(Address: Word; Data: Byte);
begin
  Handlers[Address].Write8(Data);
end;

procedure TDeviceManager16.Write16(Address: Word; Data: Word);
begin
  Handlers[Address].Write16(Data);
end;

procedure TDeviceManager16.SetDataBus(Channel: TAddressableChannel16);
begin
  Channel.Read8 := Read8;
  Channel.Read16 := Read16;
  Channel.Write8 := Write8;
  Channel.Write16 := Write16;
end;

procedure TDeviceManager16.RegisterDevice(Device: TDevice16);
begin
  Devices.Add(Device);
  Device.BaseAddress := FreeBaseAddress;
  Inc(FreeBaseAddress, Device.GetHandlerCount);
  RebuildHandlers;
end;

procedure TDeviceManager16.UnregisterDevice(Device: TDevice16);
begin
  Devices.Remove(Device);
  RebuildHandlers;
end;

constructor TDeviceManager16.Create;
begin
  Handlers := TObjectList<TChannel16>.Create;
  Devices := TObjectList<TDevice16>.Create;
end;

destructor TDeviceManager16.Destroy;
begin
  FreeAndNil(Devices);
  FreeAndNil(Handlers);
  inherited;
end;

{ TDeviceManager8 }

procedure TDeviceManager8.RebuildHandlers;
var
  I, J: Integer;
begin
  for I := 0 to Devices.Count - 1 do begin
    if Handlers.Count < Devices[I].BaseAddress + Devices[I].GetHandlerCount then
      Handlers.Count := Devices[I].BaseAddress + Devices[I].GetHandlerCount;
    for J := 0 to Devices[I].GetHandlerCount - 1 do
      Handlers[Devices[I].BaseAddress + J] := Devices[I].GetHandler(J);
  end;
end;

procedure TDeviceManager8.Write8(Address: Byte; Data: Byte);
begin
  Handlers[Address].Write8(Data);
end;

function TDeviceManager8.Read8(Address: Byte): Byte;
begin
  Result := Handlers[Address].Read8;
end;

procedure TDeviceManager8.SetDataBus(Channel: TAddressableChannel8);
begin
  Channel.Read8 := Read8;
  Channel.Write8 := Write8;
end;

procedure TDeviceManager8.RegisterDevice(Device: TDevice8);
begin
  Devices.Add(Device);
  Device.BaseAddress := FreeBaseAddress;
  Inc(FreeBaseAddress, Device.GetHandlerCount);
  RebuildHandlers;
end;

procedure TDeviceManager8.UnregisterDevice(Device: TDevice8);
begin
  Devices.Remove(Device);
  RebuildHandlers;
end;

constructor TDeviceManager8.Create;
begin
  Handlers := TObjectList<TChannel8>.Create;
  Devices := TObjectList<TDevice8>.Create;
end;

destructor TDeviceManager8.Destroy;
begin
  FreeAndNil(Devices);
  FreeAndNil(Handlers);
  inherited;
end;

end.