Closing Channels in Pascal

program ClosingChannels;

uses
  SysUtils, Classes;

type
  TJobChannel = class(TThread)
  private
    FJobs: TThreadedQueue<Integer>;
    FDone: TEvent;
  protected
    procedure Execute; override;
  public
    constructor Create(AJobs: TThreadedQueue<Integer>; ADone: TEvent);
  end;

constructor TJobChannel.Create(AJobs: TThreadedQueue<Integer>; ADone: TEvent);
begin
  inherited Create(False);
  FJobs := AJobs;
  FDone := ADone;
end;

procedure TJobChannel.Execute;
var
  Job: Integer;
begin
  while True do
  begin
    if FJobs.PopItem(Job) then
      WriteLn('received job ', Job)
    else
    begin
      WriteLn('received all jobs');
      FDone.SetEvent;
      Break;
    end;
  end;
end;

var
  Jobs: TThreadedQueue<Integer>;
  Done: TEvent;
  Worker: TJobChannel;
  J: Integer;
  HasMoreJobs: Boolean;

begin
  Jobs := TThreadedQueue<Integer>.Create(5, INFINITE, 5);
  Done := TEvent.Create;

  Worker := TJobChannel.Create(Jobs, Done);

  for J := 1 to 3 do
  begin
    Jobs.PushItem(J);
    WriteLn('sent job ', J);
  end;

  Jobs.DoShutDown;
  WriteLn('sent all jobs');

  Done.WaitFor(INFINITE);

  HasMoreJobs := not Jobs.ShutDown;
  WriteLn('received more jobs: ', HasMoreJobs);

  Worker.Free;
  Done.Free;
  Jobs.Free;
end.

In this Pascal example, we’ve implemented a similar concept of closing channels using TThreadedQueue and TEvent from the SysUtils and Classes units. Here’s a breakdown of the translation:

1. We create a TJobChannel class that extends TThread to simulate the worker goroutine.

2. The Execute method of TJobChannel continuously tries to pop items from the queue until it’s empty and shut down.

3. In the main program, we create a TThreadedQueue<Integer> to represent the jobs channel and a TEvent for synchronization.

4. We create and start the worker thread.

5. We send three jobs to the queue and then shut it down, which is equivalent to closing the channel in Go.

6. We wait for the worker to finish using the Done event.

7. Finally, we check if there are more jobs by checking the shutdown state of the queue.

This Pascal implementation mimics the behavior of the original Go program, using threads and a thread-safe queue instead of goroutines and channels. The concept of closing a channel is simulated by shutting down the queue.

To run this program, you would typically compile it with a Pascal compiler like Free Pascal:

$ fpc closing_channels.pas
$ ./closing_channels

The output would be similar to the Go version, showing the jobs being sent and received, and finally indicating that all jobs have been processed.