disklist.pas

《delphi深度编程及其项目开发》

      exit;
    end;
  end;
  move(buffer[0], buffsize, 4);
end;

//写入对应的一条队列的大小;
function TcommQueue.writebuffersize(const position: longint; const buffersize: longint): integer;
var
  buffer: array[0..3] of char;
  I: integer;
  writeaccount: longint;
begin
  result := -1;
  seek(Q, position);
  move(buffersize, buffer[0], 4);
  //判断剩余大小是否大于4，如果小于4，则得分开写
  if FFileSize - Frearpointer < 4 then
  begin
    for i := 0 to (FFileSize - Frearpointer - 1) do
    begin
      blockwrite(Q, buffer[i], 1, writeaccount);
      if writeaccount <> 1 then
      begin
        result := -1;
        exit;
      end;
    end;
    seek(Q, 512);
    for i := (FFileSize - Frearpointer) to 3 do
    begin
      blockwrite(Q, buffer[i], 1, writeaccount);
      if writeaccount <> 1 then
      begin
        result := -1;
        exit;
      end;
    end;
  end
  else
  begin
    blockwrite(Q, buffer, 4, writeaccount);
    if writeaccount <> 4 then
    begin
      result := -1;
      exit;
    end;
  end;
end;

//读取是否回绕字符值
function TcommQueue.readscroll: integer; //读取是否回绕字符值
var
  readaccount: integer;
begin
  result := 1;
  seek(Q, 14);
  blockread(Q, Fscroll, 1, readaccount);
  if readaccount <> 1 then
    result := -1;
end;

//写入是否回绕字符值
function TcommQueue.writescroll(const Myscroll: char): integer;
var
  writeaccount: integer;
begin
  result := 1;
  seek(Q, 14);
  blockwrite(Q, myscroll, 1, writeaccount);
  if writeaccount <> 1 then
  begin
    result := -1;
    exit;
  end;
  Fscroll := Myscroll;
end;

//从磁盘文件读出队列，保存为流
function TCommQueue.readStream(var aStream: TMemoryStream): integer;
var
  buffer: array[1..divAccount] of char;
  i: integer;
  ActReadNum: Longint;
  aleft: Longint;
  bufferSize: longint;
begin
  result := 1;
  //进入互斥，阻止其他线程访问
  if waitForSingleObject(hMutex, INFINITE) = WAIT_OBJECT_0 then
  begin
    try
      //判断底部剩余空间是否大于4,以判断是否分开读
      if fFileSize - FfrontPointer - 4 > 0 then
        aLeft := fFileSize - FfrontPointer - 4
      else
        aLeft := fFileSize - (FFrontPointer + 4 - fFileSize);
      readbuffersize(Ffrontpointer, buffersize);
      for i := 0 to buffersize div divAccount - 1 do
      begin
        if aLeft >= divAccount then
        begin
          blockRead(Q, buffer[1], divAccount, ActReadNum);
          aStream.Write(buffer[1], divAccount);
          aLeft := aLeft - divAccount;
          if ActReadNum <> DivAccount then
          begin
            Result := -1;
            exit;
          end;
        end
        else
        begin
          blockRead(Q, buffer[1], aLeft, ActReadNum);
          astream.Write(buffer[1], aLeft);
          aLeft := fFileSize - ffrontPointer;
          if ActReadNum <> aLeft then
          begin
            Result := -1;
            exit;
          end;
          Seek(Q, 512);
          blockRead(Q, buffer[1], divAccount - aLeft, ActReadNum);
          astream.write(buffer[1], divAccount - aLeft);
          aLeft := aLeft - (divAccount - aLeft);
          if ActReadNum <> divAccount - aLeft then
          begin
            Result := -1;
            exit;
          end;

        end;
      end;
    //如果还有剩余
      if bufferSize mod divAccount <> 0 then
      begin
        if aleft >= bufferSize mod divAccount then
        begin
          blockRead(Q, buffer[1], bufferSize mod divAccount, actReadNum);
          aStream.Write(buffer, bufferSize mod divAccount);
          if ActReadNum <> DivAccount then
          begin
            Result := -1;
            exit;
          end;
        end
        else
        begin
          blockRead(Q, buffer[1], aLeft, actReadNum);
          aStream.Write(buffer[1], aLeft);
          if ActReadNum <> DivAccount then
          begin
            Result := -1;
            exit;
          end;
          Seek(Q, 512);
          blockRead(Q, buffer[1], bufferSize mod divAccount - aleft, actReadNum);
          aStream.Write(buffer[1], bufferSize mod divAccount - aleft);
          if ActReadNum <> DivAccount then
          begin
            Result := -1;
            exit;
          end;
        end;
      end;
    finally
      //离开互斥状态
      releaseMutex(hMutex);
    end;
  end;
end;

//读取磁盘队列一条内容
function TcommQueue.readqueue(var buffer; var size: longint): integer;
var
  recvstream: TmemoryStream;
begin
  result := 1;
  if empty = 1 then
  begin
    result := -1; //队列已空
    exit;
  end;
  //创建接收的内存流
  recvStream := TMemoryStream.Create;
  //调用ReadStream，从磁盘队列读出一条内容
  readStream(recvStream);
  recvStream.Seek(0, 0);
  //将流写入Buffer
  recvStream.Read(Buffer, recvStream.Size);
  size := recvStream.Size;
  //指针向后移动一位
  Ffrontpointer := addone(Ffrontpointer);
  writeheadfront(Ffrontpointer);
end;

//将流写入磁盘队列
function TCommQueue.writeStream(aStream: TMemoryStream): integer;
var
  buffer: array[1..divAccount] of char;
  i: integer;
  ActWriteNum: Longint;
  aleft: Longint;
begin
  Result := 1;
  //进入互斥，阻止其他线程访问
  if waitForSingleObject(hMutex, INFINITE) = WAIT_OBJECT_0 then
  begin
    try
      //判断底部剩余空间是否大于4，以判断是否分开写
      if fFileSize - Frearpointer - 4 > 0 then
        aLeft := fFileSize - Frearpointer - 4
      else
        aLeft := fFileSize - (FrearPointer + 4 - fFileSize);
      aStream.Seek(0, 0);
      for i := 0 to aStream.Size div divAccount - 1 do
      begin
        if aLeft >= divAccount then
        begin
          aStream.Read(buffer[1], divAccount);
          blockWrite(Q, buffer[1], divAccount, ActWriteNum);
          aLeft := aLeft - divAccount;
          if ActWriteNum <> DivAccount then
          begin
            Result := -1;
            exit;
          end;
        end
        else
        begin
          astream.Read(buffer[1], aLeft);
          blockWrite(Q, buffer[1], aLeft, ActWriteNum);
          aLeft := fFileSize - ffrontPointer;
          if ActWriteNum <> aLeft then
          begin
            Result := -1;
            exit;
          end;
          Seek(Q, 512);
          astream.Read(buffer[1], divAccount - aLeft);
          blockWrite(Q, buffer[1], divAccount - aLeft, ActWriteNum);
          aLeft := aLeft - (divAccount - aLeft);
          if ActWriteNum <> divAccount - aLeft then
          begin
            Result := -1;
            exit;
          end;

        end;
      end;
    //如果还有剩余
      if aStream.Size mod divAccount <> 0 then
      begin
        if aleft >= aStream.Size mod divAccount then
        begin
          aStream.read(buffer[1], aStream.Size mod divAccount);
          blockWrite(Q, buffer[1], aStream.Size mod divAccount, actWriteNum);
          if ActWriteNum <> DivAccount then
          begin
            Result := -1;
            exit;
          end;
        end
        else
        begin
          aStream.Read(buffer[1], aLeft);
          blockWrite(Q, buffer[1], aLeft, actWriteNum);
          if ActWriteNum <> DivAccount then
          begin
            Result := -1;
            exit;
          end;
          Seek(Q, 512);
          aStream.Read(buffer[1], aStream.Size mod divAccount - aleft);
          blockWrite(Q, buffer[1], aStream.Size mod divAccount - aleft, actWriteNum);
          if ActWriteNum <> DivAccount then
          begin
            Result := -1;
            exit;
          end;
        end;
      end;
    finally
      //离开互斥
      releaseMutex(hMutex);
    end;
  end;
end;

//向磁盘队列插入一条内容
function TcommQueue.writequeue(const Buffer; const size: integer): integer;
var
  SendStream: Tmemorystream;
  leftsize: longint;
begin
  result := 1; //代表写成功
  getleftsize(leftsize);
  if leftsize < size + 4 then //判断剩余空间是否够
  begin
    result := -1; //剩余空间；
    exit;
  end;
  try
    //创建内存流
    sendStream := Tmemorystream.Create;
    //将buffer写入到流中
    sendStream.WriteBuffer(buffer, size);
    sendStream.Seek(0, sofrombeginning);
    //写入数据区大小
    WriteBufferSize(Frearpointer, size);
    //将流写入磁盘队列
    writeStream(sendStream);
    //将尾指针相后移
    Frearpointer := addone(Frearpointer);
    writeheadrear(Frearpointer);
  finally
    sendStream.Free;
  end;
end;

//将指针向下移
function TcommQueue.addone(var position: longint): longint;
var
  buffersize: longint;
  nextposition: longint;
begin
  readFileSize;
  readbuffersize(position, buffersize);
  nextposition := position + 4 + buffersize;
  if nextposition > FFileSize then
  begin
    if Fscroll = 'Y' then
      Fscroll := 'N'
    else
      Fscroll := 'Y';
    writescroll(Fscroll);
    result := (position + 4 + buffersize) mod FFileSize + 512;
  end
  else
    result := position + 4 + buffersize;
end;

end.