Одним из приложений массивов, которое описывается во многих книгах, - это массивы на диске (или, если хотите, дисковые массивы, но не путайте их с RAID!), т.е. файлы записей фиксированной длины. Этот тип массивов обладает своими собственными особенностями, заслуживающими отдельного рассмотрения, после которого мы напишем класс, заключающий в себе файл записей (или данных). Постоянные массивы известны как файлы данных или файлы записей, а элементы таких массивов представляют собой записи. Индекс элементов в постоянных массивах называется порядковым номером записи.

Язык Pascal всегда поддерживал файлы записей и Delphi продолжает эту традицию. Стандартный метод работы с файлами записей выгладит следующим образом:

var
MyRecord : TMyRecord;
MyFile : file of TMyRecord;
begin
{открыть файл данных)
System. Assign (MyFile, 'MyData. DAT') ;
System. Rewrite (MyFile);
try
{сохранить запись в позицию 0} . .установить поля MyRecord.. System.Write(MyFile, MyRecord);
{считать запись с позиции 0} System.Seek(MyFile, Ob-System .Read(MyFile, MyRecord);
finally
System.Close(MyFile);
ends-end;

В приведенном блоке кода открывается файл данных (процедуры Assign и Rewrite), затем в файл записывается новая запись (процедура Write) и, наконец, запись считывается (процедуры Seek и Read). Обратите внимание, что перед считыванием необходимо с помощью процедуры Seek установить указатель позиции в файле на начало записи. Если этого не сделать, будет считана вторая запись файла. Код примера включает блок try. .finally, который гарантирует, что файл будет закрыт независимо от того, что происходит при выполнении процедуры Rewrite.

Однако в приведенном примере способа получения доступа к записям файла присутствуют две ошибки. Первая из них, хотя и небольшая, тем не менее, очень важная. Единственным методом определения размера каждой записи является считывание ее из исходного кода программы, которая осуществляет доступ к файлу. Если есть файл записей, то для определения длины записи необходимо поработать с окном шестнадцатеричного представления. Если длина записи и объем файла известны, можно легко определить количество записей в файле.

И вторая проблема - файлы данных не содержат информации о структуре записей, количестве полей и их типах. Если бы в файле хранился больший объем информации, работать с записями и самими файлами было бы намного проще.

Какую информацию, помимо записей, потребовалось бы хранить в файле? Как уже говорилось, одним из дополнительных полей могла бы быть длина записи, а вторым - количество находящихся в файле записей. При помощи этих двух полей можно определить допустимость файла (т.е. равен ли объем файла количеству записей, умноженному на длину записи, плюс размер служебной информации).

Предположим, что в файле находится специальный служебный блок данных. Пусть этот блок содержит некоторые важные данные о файле, за которыми следует определенное количество записей одинакового размера. Другими словами, служебный блок данных содержит постоянную информацию о массиве (размер элемента, количество элементов и, может быть, ряд других данных).

В таком случае мы можем написать свой класс, который будет открывать файл и вносить в него записи (и, конечно, соответствующим образом изменять содержимое служебного блока), считывать записи по заданному порядковому номеру, записывать и обновлять записи по порядковому номеру и закрывать файл. А как же удаление записей? Не хотелось бы перемещать записи в файле на одну позицию с целью закрытия "дыры", образованной после удаления одной записи, как мы это делали в массивах в памяти. Подобная процедура заняла бы слишком много времени.

Существует два возможных решения для организации удаления записей. Первое - самое простое, которое используется в файлах данных ёВАЗЕ. Для каждой записи в файле устанавливается префикс, состоящий из одного байта и содержащий флаг удаления. Флаг может быть булевым значением (Ьтв/£а1вв) или символом (например, 'У/'г^Г или '*7пусто). При удалении записи устанавливается флаг удаления, который и будет говорить о том, что данная запись удалена. Все кажется достаточно простым, но что делать с удаленными записями? Вариант А - просто игнорировать. К сожалению, в этом случае в файле будет накапливаться все большее и большее число удаленных записей и в некоторый момент времени файл придется уплотнять, дабы избавиться от ненужных записей и уменьшить размер файла данных. Вариант В - повторно использовать место, занимаемое удаленными записями. При добавлении в файл новой записи по файлу выполняется поиск удаленной записи, на место которой и будет добавлена новая запись. Очевидно, что вариант В неэффективен. Представьте себе, что в файле, содержащем 10000 записей, удалена только одна запись. Для того чтобы найти всего одну удаленную запись, нам придется выполнить цикл, по крайней мере, по 5000 записям. Эта операция принадлежит к классу О(и), поэтому вариант В лучше не реализовывать.

Тем не менее, вариант В имеет и свои положительные стороны, в частности, повторное использование места, занимаемого удаленными записями. Если бы только нам удалось привести его к классу 0(1)! Такие рассуждения привели к разработке еще одного метода удаления записей - цепочке уделенных записей (для этого метода наличие служебного блока данных обязательно, поэтому будем считать, что служебные данные присутствуют).

Перед каждой записью находится 4-байтный префикс - значение типа 1опд1пс.. Он предназначен для хранения флага удаления. Его нормальное значение -1 - значение, которое указывает, что запись не удалена. Любое другое значение будет означать, что запись удалена. Но это еще не все. Обратите внимание, что размер каждой записи увеличивается на 4 байта. В свою очередь, пользователь считает, что размер записи не изменился. В служебном заголовке хранится еще одно значение типа 1опд1пг>, которое представляет собой порядковый номер первой удаленной записи. Нормальное значение для этого поля -2, которое означает, что в файле нет удаленных записей.

При удалении первой записи мы поступаем следующим образом. Сначала устанавливаем значение флага удаления записи равным значению поля порядкового номера первой удаленной записи служебного заголовка, т.е. значению -2. Затем значение флага удаления записывается на диск. После этого в поле порядкового

Удаление записи номера первой удаленной записи служебного заголовка записываем порядковый номер только что удаленной записи

Рисунок 2.3. Удаление записи номера первой удаленной записи служебного заголовка записываем порядковый номер только что удаленной записи. В результате получаем следующее: во-первых, значение флага удаления записи не равно -1 (т.е. теперь запись отмечена как удаленная) и, во-вторых, поле порядкового номера первой удаленной записи служебного заголовка теперь указывает на удаленную запись (т.е. запись, место, занимаемое которой, можно использовать повторно).

При удалении второй записи выполняются все те же операции. После них флаг второй уделенной записи будет содержать порядковый номер первой удаленной записи (не равный -1, что говорит о том, что запись удалена), а поле первой удаленной записи служебного заголовка будет указывать на вторую удаленную запись.

А что происходит при добавлении в файл новой записи? Вместо простого добавления записи в конец файла, как мы делали раньше, проверяем значение поля порядкового номера удаленной записи в служебном заголовке. Если значение не равно -1, значит, существует запись, занимаемое которой место можно использовать повторно. При вставке новой записи потребуется изменить содержащееся в служебном заголовке значение. Если этого не сделать, при последующем добавлений записи она снова будет записана на то же место, а предыдущая запись будет потеряна. В этом случае мы считываем флаг удаления записи, занимаемое которой место будет использоваться повторно, и переносим его в поле первой удаленной записи служебного заголовка данных. Обратите внимание, что при повторном использовании последней удаленной записи в поле первой удаленной записи служебного заголовка будет установлено значение -2, поскольку флаг удаления записи содержал это значение.

Есть еще один вопрос, который проще рассмотреть на примере кода. Было бы довольно глупо ограничить концепцию постоянных (устойчивых) массивов только до файлов на диске. Несмотря на то что в подавляющем большинстве случаев будут использоваться файлы, ничто не мешает нам организовать постоянный массив в памяти или на любом другом устройстве хранения данных. Было бы удобно иметь класс постоянного массива, который пользуется потоками. В Delphi предусмотрен богатый набор классов потоков, включая файловый поток. Таким образом, если мы напишем код, использующий класс TStream, его можно будет применять со всеми другими классами, порожденными от TStream.

Ниже приведен код класса TtdRecordStream - класса, предназначенного для постоянного хранения в потоке массива записей.

Листинг 2.18. Класс TtdRecordStream для хранения постоянных массивов.

type TtdRecordStream = class private FStream : TStream;
FCount : longint;
FCapacity : longint;
FHeaderRec : PtdRSHeaderRec;
FName : TtdNameString;
FRecord : PByteArray;
FRecordLen : integer;
FRecordLen4 : integer;
FZeroPosition : longint;
protected
procedure rsSetCapacity(aCapacity : longint);
procedure rsError(aErrorCode : integer;
const aMethodName : TtdNameString;
aNumValue : longint);
function rsCalcRecordOffset(alndex : longint) : longint;
procedure rsCreateHeaderRec(aRecordLen : integer);
procedure rsReadHeaderRec;
procedure rsReadStream(var aBuffer;
aBufLen : integer);
procedure rsWriteStream(var aBuffer;
aBufLen : integer);
procedure rsSeekStream(aOffset : longint);
public
constructor Create (aStream : TStream;
aRecordLength : integer);
destructor Destroy;
override;
procedure Flush;
virtual;
function Add(var aRecord) : longint;
procedure Clear;
procedure Delete (alndex : longint);
procedure Read (alndex : longint;
var aRecord;
var alsDeleted : boolean) ; procedure Write (alndex : longint;
var aRecord) ;
property Capacity : longint read FCapacity write rsSetCapacity;
property Count : longint read FCount ;
property RecordLength : integer read FRecordLen;
property Name : TtdNameString read FName write FName ;
end;

К сожалению, для такого типа постоянных массивов очень сложно перегрузить операцию [], поэтому в классе TtdRecordStream свойство Items не используется. Вместо него введены простые методы Read и Write.

Конструктор Create может вызываться в двух режимах: для постоянного массива в потоке или не в потоке. Режим определяется самим конструктором и в случае, если используется новый поток, создается служебный блок.

Листинг 2.19. Конструктор класса TtdRecordStream

constructor TtdRecordStream.Create(aStream : TStream;
aRecordLength : integer);
begin inherited Create;
{сохранить поток и его текущую позицию)
FStream : = aStream;
FZeroPosition := aStream.Position;
{если размер потока равен нулю, нужно создать служебный заголовок) if (aStream.Size - FZeroPosition = 0) then
rsCreateHeaderRec(aRecordLength) {в противном случае проверить, содержится ли в потоке действительный служебный заголовок, считать его и установить значения его полей) else
rsReadHeaderRec; {выделить память под запись) FRecordLen4 := FRecordLen + sizeof (longint) ; GetMem(FRecord, FRecordLen4);
end;

Обратите внимание, что конструктор считывает текущее положение потока и записывает его в FZeroPosition. Текущее положение, которое, как правило, равно нулю, будет использовать для указания положения служебного заголовка для постоянного массива. Это означает, что перед вызовом конструктора Create программист может записать в поток свой служебный заголовок, и методы класса не будут его изменять. Тем не менее, класс предполагает, что оставшаяся часть потока, начиная с положения FZeroPosition, принадлежит классу и в нее допускается вносить изменения.

Конструктор вызывает либо метод rsCreateHeaderRec, который создает новый служебный заголовок для пустого потока (т.е. при необходимости создания нового массива), либо метод rsReadHeaderRec, который считывает текущий служебный заголовок (и, кроме того, проверяет его корректность).

И, наконец, конструктор Create выделяет из кучи память для записи (память выделяется с учетом размера флага удаления). Деструктор Destroy освобождает память, выделенную под запись.

Листинг 2.20. Деструктор класса TtdRecordStream

destructor TtdRecordStream. Destroy;
begin
if (FHeaderReconil) then FreeMem(FHeaderRec, FheaderRecA.hrHeaderLen);
if (FRecordonil) then
FreeMem(FRecord, FRecordLen4);
inherited Destroy;
end;

А теперь давайте рассмотрим два вспомогательных метода, которые соответственно создают новый или считывают существующий служебный заголовок.

Листинг 2.21. Создание и считывание служебного заголовка

procedure TtdRecordStream.гsCreateHeaderRec(aRecordLen : integer);
begin
{выделить память под служебный заеоловок) if ((aRecordLen + sizeof (longint)) <
sizeof (TtdRSHeaderRec)) then begin
FHeaderRec : = AllocMem(sizeof(TtdRSHeaderRec));
FHeaderRecA.hrHeaderLen : = sizeof(TtdRSHeaderRec);
end
else begin
FHeaderRec :== AllocMem( aRecordLen + sizeof (longint)) ; FHeaderRecA.hrHeaderLen := aRecordLen + sizeof(longint);
end;
{задать значения остальных стандартных полей) with FHeaderRecA do begin
hrSignature := cRSSignature;
hrVersion := $00010000; {Major=l;
Minor=0}
hrRecordLen := aRecordLen;
hrCapacity := 0;
hrCount := 0;
hrlstDelRec := cEndOfDeletedChain;
end;
{обновить служебный заголовок) rsSeekStream(FZeroPosition);
rsWriteStream(FHeaderRecA, FHeaderRecA.hrHeaderLen); {задать значение поля длины записи) FRecordLen := aRecordLen;
end;
procedure TtdRecordStream.rsReadHeaderRec;
var
StreamSize : longint;
TempHeaderRec : TtdRSHeaderRec;
begin
{если размер потока меньше размера служебного заголовка, это неверный поток) StreamSize := FStream.Size - FZeroPosition;
if (StreamSize <
sizeof(TtdRSHeaderRec)) then
rsError(tdeRSNoHeaderRec, 'rsReadHeaderRec', 0) ; {считать служебный заголовок) rsSeekStream(FZeroPosition);
rsReadStream(TempHeaderRec, sizeof(TtdRSHeaderRec));
{первая санитарная проверка: сигнатура и счетчик/емкость) with TempHeaderRec do begin if (hrSignatureocRSSignature) or (hrCount >
hrCapacity) then rsError(tdeRSBadHeaderRec, 1rsReadHeaderRec', 0) ;
end;
{выделить память под реальный служебный заголовок, скопировать уже считанные данные) FHeaderRec : = AllocMem(TempHeaderRec.hrHeaderLen);
Move(TempHeaderRec, FHeaderRecA, TempHeaderRec.hrHeaderLen); {вторая санитарная проверка: проверка данных записи) with FHeaderRec* do begin
FRecordLen4 : = hrRecordLen + 4; {for rsCalcRecordOffset}
if (StreamSizeOrsCalcRecordOff set (hrCapacity)) then rsError(tdeRSBadHeaderRec, ' rsReadHeaderRec1, 0) ;
{установить значения полей класса)
FCount :=hrCount;
FCapacity := hrCapacity;
FRecordLen := hrRecordLen;
end;
end;
function TtdRecordSt ream. rsCalcRecordOff set (alndex : longint) : longint;
begin
Result := FZeroPosition + FHeaderRecA .hrHeaderLen + (alndex * FRecordLen4) ;
end;

Приведенный метод создания служебного заголовка вызывается только в случае, когда поток пуст. Принцип его работы очень прост. Сначала служебный заголовок создается в памяти, а затем записывается в поток. Если длина записи больше, чем нормальный размер служебного заголовка, его размер увеличивает до размера записи. В служебном заголовке содержится семь полей: поле сигнатуры, которое может использоваться для контроля при считывании записи; номер версии служебного заголовка (это позволит в будущем добавлять в заголовок новые поля и сохранять совместимость версий); длина служебного заголовка; длина записи; емкость потока (т.е. количество записей как активных, так и удаленных, которые в данный момент находятся в потоке); количество активных записей; и, наконец, порядковый номер первой удаленной записи (здесь значение этого поля устанавливается равным cEndOfDetectedChain или -2).

Метод считывания служебного заголовка должен содержать определенную проверку, которая будет гарантировать, что данный заголовок является действительным. Для этого сначала выполняется проверка сигнатуры, затем проверка того, что количество активных записей меньше или равно емкости потока и имеет ли поток достаточный объем для объявленной емкости. Если все проверки проходят успешно, считается, что служебный блок содержит корректные данные, и поля класса обновляются значениями, считанными из потока.

Метод rsCalcRecordOffset просто вычисляет смещение записи, порядковый номер которой передан ему во входном параметре. При этом учитывается начальное положение потока и размер служебного заголовка.

Листинг 2.22. Добавление новой записи в постоянный массив

function TtdRecordStream. Add(var aRecord) : longint;
begin
{если цепочка удаленных записей пуста, в поток добавляется новая запись} if (FHeaderRecA .hrlstDelRec = cEndOfDeletedChain) then begin
Result :=FCapacity;
inc(FCapacity);
inc(FHeaderRecA.hrCapacity);
end
{в противном случае используется первая удаленная запись, обновляется значение поля удаленной записи в служебном заголовке для указания на следующую удаленную запись}
else begin Result := FHeaderRecA.hrlstDelRec;
rsSeekStream(rsCalcRecordOffset(FHeaderRecA.hrlstDelRec))/ rsReadStream(FHeaderRecA.hrlstDelRec, sizeof(longint));
end;
{определить смещение записи и сохранить новую запись} rsSeekStream(rsCalcRecordOffset(Result));
PLongint(FRecord)A : = cActiveRecord;
Move(aRecord, FRecordA[sizeof(longint)], FRecordLen);
rsWritestream(FRecordA, FRecordLen4);
{количество записей увеличилось на единицу}
inc(FCount);
inc(FHeaderRecA.hrCount); {обновить служебный заголовок} rsSeekStream(FZeroPosition);
rsWriteStream(FHeaderRecA, sizeof(TtdRSHeaderRec));
end;

Если цепочка удаленных записей не пуста, определить первую удаленную запись (именно поверх нее будет сохраняться новая запись). Мы считываем флаг удаления для этой записи и обновляем поле первой удаленной записи служебного заголовка. Затем мы определяем положение начала удаленной записи, устанавливаем значение флага удаления равным cActiveRecord (-1) и сохраняем запись, переданную методу во входном параметре.

При считывании и сохранении записей необходимо учитывать, удалена ли требуемая запись. Записи идентифицируются по их порядковым номерам.

Листинг 2.23. Чтение и обновление записи в постоянном массиве

procedure TtdRecordStream.Read(alndex : longint ;*
var aRecord;
var alsDeleted : boolean) ;
begin
{проверить, действителен ли порядковый номер записи)
if (alndex < 0) or (alndex >= Capacity) then rsError(tdeRSOutOfBounds, 1Read', alndex);
{определить смещение записи и считать ее)
rsSeekStream(rsCalcRecordOffset(alndex));
rsReadStream(FRecordA, FRecordLen4);
if (PLongint(FRecord)A = cActiveRecord) then begin alsDeleted := falser-Move (FRecordA[sizeof(longint)], aRecord, FRecordLen);
end
else begin
alsDeleted := true;
FillChar(aRecord, FRecordLen, Ob-end;
end;
procedure TtdRecordStream.Write (alndex : longint;
var aRecord) ;
var
DeletedFlag : longint;
begin
{проверить, действителен ли порядковый номер записи) if (alndex < 0) or (alndex >= Capacity) then
rsError(tdelndexOutOfBounds, 'Write1, alndex); {проверить, что запись не была удалена) rsSeekStream(rsCalcRecordOffset(alndex));
rsReadStream(DeletedFlag, sizeof(longint));
if (DeletedFlagOcActiveRecord) then
rsError(tdeRSRecIsDeleted, 1Write1, alndex); {сохранить запись) rsWriteStream(aRecord, FRecordLen);
end;

Метод Read возвращает флаг, который показывает, была ли удалена запись. Если запись не удалена, буфер записи, переданный во входном параметре, заполняется записью, считанной из потока. Код просто в один прием считывает всю запись и ее флаг удаления и действует в соответствии со значением флага.

Метод Write, прежде всего, проверяет, была ли удалена требуемая запись. Если запись удалена, она недоступна для изменения, вследствие чего возникает исключение. В противном случае в поток помещается новое значение записи.

И последний метод, связанный с обработкой записей, - это метод Delete.

Листинг 2.24. Чтение и обновление записи в постоянном массиве

procedure TtdRecordStream. Delete (aIndex : longint); var DeletedFlag : longint; begin {проверить, действителен ли порядковый номер записи} if (aIndex < 0) or (aIndex >= Capacity) then rsError(tdeRSOutOfBounds, 1 Delete', aIndex); {проверить, что запись не была удалена} гsSeekStream(гsCalcRecordOffset(aIndex)); rsReadStream(DeletedFlag, sizeof(longint)); if (DeletedFlagOcActiveRecord) then rsError(tdeRSAlreadyDeleted, 1 Delete', aIndex); {записать порядковый номер первой удаленной записи в первые

4 байта удаляемой записи) rsSeekStream(rsCalcRecordOffset(aIndex));
rsWriteStream(FHeaderRecA.hrlstDelRec, sizeof(longint)); {обновить значение поля первой удаленной записи служебного заголовка, чтобы оно указывало на удаляемую запись) FHeaderRecA.hrlstDelRec := aIndex; {количество записей уменьшилось на единицу) dec(FCount);
dec(FHeaderRecA.hrCount); {обновить служебный заголовок) rsSeekStream(FZeroPosition);
rsWriteStream(FHeaderRecA, sizeof(TtdRSHeaderRec));
end;

Метод Delete, прежде всего, проверяет, была ли удалена требуемая запись. Если запись была удалена, метод вызывает ошибку. Если все в порядке, текущее значение поля первой удаленной записи служебного заголовка копируется во флаг удаления записи. Затем значение поля первой удаленной записи устанавливается равным порядковому номеру удаляемой записи, количество активных записей в массиве уменьшается на единицу и обновляется служебный заголовок в потоке.

Метод Clear аналогичен Delete, но он предназначен для удаления всех активных записей постоянного массива.

Листинг 2.25. Очистка содержимого постоянного массива

procedure TtdRecordStream.Clear;
var
Inx : longint;
DeletedFlag : longint;
begin
{выполнить цикл no всем записям и объединить их в одну цепочку удаленных записей)
for Inx := 0 to pred(FCapacity) do begin rsSeekStream(rsCalcRecordOffset(Inx));
гsReadStream(DeletedFlag, sizeof(longint));
if (DeletedFlag = cActiveRecord) then begin
{записать порядковый номер первой удаленной записи в первые 4 байта удаляемой записи)
rsSeekStream(rsCalcRecordOffset(Inx));
rsWriteStream(FHeaderRecA.hrlstDelRec, sizeof(longint)); {обновить значение поля первой удаленной записи служебного заголовка, чтобы оно указывало на удаляемую запись) FHeaderRecA.hrlstDelRec := Inx;
end;
end;
{записей нет) FCount := 0;
FHeaderRecA.hrCount := 0;
{обновить служебный заголовок)
rsSeekStream(FZeroPosition);
rsWriteStream(FHeaderRecA, sizeof(TtdRSHeaderRec));
end;

Этот метод выполняет цикл по всем записям массива и, если запись активна, удаляет ее в соответствии с алгоритмом, используемым в методе Delete.

Класс TtdRecordStream позволяет также в один прием увеличивать емкость потока на несколько записей, а не добавлять записи по одной с помощью метода Add. Такая возможность позволяет зарезервировать место под постоянный массив, если заранее известно количество записей, которое будет в нем храниться. Запись свойства Capacity осуществляется через метод rsSetCapacity.

Листинг 2.26. Задание емкости постоянного массива

procedure TtdRecordStream.rsSetCapacity(aCapacity : longint); var
Inx : longint;
begin
{допускается только увеличение емкости) if (aCapacity >
FCapacity) then begin
{заполнить текущую запись нулями)
FillChar(FRecordA, FRecordLen4, 0);
{найти конец файла)
гsSeekStream(гsCalcRecordOffset(FCapacity));
{создать дополнительные записи и внести их в цепочку удаленных записей) for Inx := FCapacity to pred(aCapacity) do begin
PLongint(FRecord)A : = FHeaderRecA.hrlstDelRec;
rsWriteStream(FRecordA, FRecordLen4);
FHeaderRecA.hrlstDelRec := Inx;
end;
{сохранить новую емкость)
FCapacity := aCapacity;
FHeaderRecA.hrCapacity := aCapacity;
{обновить служебный заголовок) rsSeekStream(FZeroPosition);
rsWriteStream(FHeaderRecA, sizeof(TtdRSHeaderRec));
end;
end;

Как видно из приведенного кода, метод rsSetCapacity добавляет в конец потока пустые записи и вносит их в цепочку удаленных записей. После этого обновляются поля служебного заголовка, и в массиве появляется несколько удаленных записей, которые можно заполнить с помощью метода Add

Последние методы, которые мы рассмотрим, будут очень простыми. Это низкоуровневые методы, предназначенные для считывания из потока, записи в поток и поиска в потоке. Кроме того, в каждом из них имеется блок проверки результата.

Листинг 2.27. Низкоуровневые методы доступа к потоку

procedure TtdRecordStream. rsReadStream(var aBuffer;
a,BufLen : integer);
var
BytesRead : longint;
begin
BytesRead := FStream.Read(aBuffer, aBufLen);
if (BytesReadoaBufLen) then rsError(tdeRSReadError, 1rsReadStream1, aBufLen);
end;
procedure TtdRecordStream. r s SeekSt ream (aOff set : longint); var
NewOffset : longint;
begin
NewOffset := FStream.Seek(aOffset, soFromBeginning);
if (NewOffsetoaOffset) then rsError(tdeRSSeekError, 1rsSeekStream1, aOffset);
end;
procedure TtdRecordStream.rsWriteStream(var aBuffer;
aBufLen : integer);
var
BytesWritten : longint;
begin
BytesWritten := FStream.Write(aBuffer, aBufLen);
if (BytesWrittenoaBufLen) then
rsError(tdeRSWriteError, 1rsWriteStream', aBufLen);
Flush;
end;

Как видите, если результат выполнения одного из методов не соответствует ожидаемому, методы вызывают исключения.

Существует еще один метод, о котором мы не говорили, - rsWriteStream. Фактически это метод Flush - виртуальный метод, предназначенный для сброса содержащихся в потоке данных на связанное с потоком устройство (например, диск). Его реализация для нашего класса представляет собой пустую подпрограмму, поскольку мы не знаем, как сбросить данные из стандартного потока TStream. Он существует только для того, чтобы быть перекрытым в дочерних классах, которые имеют дело с потоком, связанным с диском, например, файловым потоком.

Листинг 2.28. Реализация постоянных массивов с помощью файлового потока

constructor TtdRecordFile. Create (const aFileName : string;
aMode : word;
aRecordLength : integer);
begin
FStream : = TFileStream. Create (aFileName, aMode);
inherited Create(FStream, aRecordLength) ; FFileName := aFileName;
Mode :* aMode;
end;
destructor TtdRecordFile.Destroy;
begin
inherited Destroy;
FStream.Free;
end;
procedure TtdRecordFile.Flush;
{$IFDEF Delphil)
var
DosError : word;
Handle : THandle;
begin
Handle := FStream.Handle;
asm
mov ah, $68
mov bx, Handle
call D0S3Call
jc @@Error
xor ax, ax @6Error:
mov DosError, ax end;

if (DosErroroO) then rsError(tdeRSFlushError, 1 Flush1, DosError) end; {$ENDIF) {$IFDEF Delphi2Plus) begin if not FlushFileBuf fers (FStream.Handle) then rsError(tdeRSFlushError, 1 Flush', GetLastError) end; {$ENDIF) В приведенном коде присутствует перекрытый метод Flush, который сбрасывает данные в дескриптор, связанный с файловым потоком, содержащим постоянный массив. Реализации для Delphi 1 и для 32-битных версий будут отличаться, поскольку процесс сброса данных в дескриптор в этих версиях различен.

Полный код класса TtdRecordStream можно найти на Web-сайте издательства, в разделе материалов. После выгрузки материалов отыщите среди них файл TDRecFil.pas.

Класс TtdObjectList || Оглавление || Резюме2


Фундаментальные алгоритмы и структуры данных в Delphi



Новости за месяц

  • Апрель
    2019
  • Пн
  • Вт
  • Ср
  • Чт
  • Пт
  • Сб
  • Вс