void CArchive::Abort() {

ASSERT(m_bDirectBuffer ||

m_lpBufStart == NULL || AfxIsValidAddress(m_lpBufStart,

m_lpBufMax – m_lpBufStart, IsStoring()));

ASSERT(m_bDirectBuffer ||

m_lpBufCur == NULL || AfxIsValidAddress(m_lpBufCur,

m_lpBufMax – m_lpBufCur, IsStoring()));

// disconnect from the file mjpFile = NULL;

if (!m_bUserBuf) {

ASSERT(!m_bDirectBuffer); delete[] m_lpBufStart; m_lpBufStart = NULL; m_lpBufCur = NULL;

}

delete m_pSchemaMap; m_pSchemaMap = NULL;

// m_pStoreMap and m_pLoadArray are unioned, // so we only need to delete one

ASSERT((CObject*)m_pStoreMap == (CObject*)m_pLoadArray); delete (CObject*)m_pLoadArray; m_pLoadArray = NULL;Посмотрим, что происходит с архивом в случае прекращения работы посредством вызова метода AbortQ. Первым делом метод «отсоединяет» архив от файла, присваивая полю m__pFile значе­ние NULL. Затем в том случае, если у архива есть ассоциированный с ним буфер, производится удаление буфера. Если в буфере остались данные, которые не были записаны в файл, то эти данные будут потеряны. Указатели на начало буфера и на текущую позицию буфера делаются равными NULL. Затем удаляется указатель на хэш-таблицу, содержащую номера схем классов, а за ней и хэш-таблица (или массив) сохраненных объектов.

Если метод CRuntimeClass::Load() вернул значение NULL, это означает, что произошла ошибка, которую метод ReadClass() са­мостоятельно устранить не в состоянии. Естественный выход для метода ReadClass() в этой ситуации – выработка исключения, что он и делает. Если же загрузка прошла нормально, то начинается проверка соответствия схем (версий) классов, ведь вполне веро­ятно, что в программе используется описание более новой версии класса, чем сохраненная в архиве, верно?

Если схемы класса в вызывающем модуле и в считанной из ар­хива информации не совпали и при этом не указано, что класс мо­жет загружать информацию разных версий, то вырабатывается ис­ключение. В том случае, если схемы не совпадают, но указано, что класс может загружать информацию разных версий, для хранения несовпадающих версий заводится новая хэш-таблица, указатель на нее записывается в поле mjDSchemaMap. Ключами в этой таб­лице служат указатели на информацию времени выполнения клас­са, считанного из архива, а значения, которые принимают элемен­ты, равны номерам схем считанных из архива классов. Здесь я не поленюсь лишний раз повторить, что хэш-таблица заводится для хранения ТОЛЬКО тех схем, номера которых НЕ СОВПАДАЮТ со схемой класса, информация о котором передана методу в качестве аргумента.

Раз заведена хэш-таблица, то как же обойтись без проверки числа элементов в ней при помощи метода CheckCount()? А после проверки указатель на информацию времени исполнения класса записывается в очередной свободный элемент массива указателей, который был заведен при вызове метода MapObject(). Естественно, число элемен­тов в этом массиве увеличивается на единицу. *

Тем самым мы завершили обработку описания впервые встре­тившегося класса. А что происходит в тех случаях, когда мы счи­тываем ссылки на ранее встречавшиеся описания классов? Если индекс ранее встречавшегося класса не равен нулю (если читатель помнит, то нулевой элемент массива инициализируется значением NULL) и не превышает верхнего индекса массива (индекс в таком случае просто лишен смысла), из элемента массива с указанным индексом выбирается информация времени исполнения класса…

Так… А почему мы постоянно говорим о массиве? Дело в том, что индекс, с которым элемент был добавлен в ХЭШ-ТАБЛИЦУ при записи в архив, может использоваться как индекс МАССИВА при считывании из архива. Ведь в данном случае нам не нужно осуществлять массу проверок, верно? И для хранения данных вполне достаточно массива, доступ к элементам которого можно осуществлять по индексам, верно?

Затем метод ReadClass() начинает работу в точном соответствии с тем списком правил, который мы сформировали в конце предыду­щего раздела. В том случае, если считан тэг объекта, то метод записывает тэг объекта по адресу, переданному ему в качестве третьего аргумента, и возвращает значение NULL. Отметим этот факт – метод ReadClassQ в том случае, если из архива считан тэг объекта, возвращает значение NULL. У объекта схемы (версии) быть не может, поэтому мы не заполняем указатель на схему. Однако если из архива считан тэг класса, нам придется немного повозиться с этим тэгом.

Давайте рассуждать. Если встречен тэг класса, то какие случаи должны быть рассмотрены при этом? Наверное, должны быть рас­смотрены два случая: 1) считан тэг ранее не встречавшегося клас­са и 2) считана ссылка на тэг ранее встречавшегося в процессе считывания класса. В том случае, если метод ReadClass() считал из архива тэг ранее не встречавшегося класса, то он должен загрузить информацию времени выполнения этого класса, после чего осуществить все необходимые проверки, верно? Информация вре­мени выполнения загружается при помощи метода CRuntimeClass::Load(), исходный текст которого можно найти в файле агссоге.срр:

CRuntimeClass* PASCAL CRuntimeClass::Load(CArchive& ar,

UINT*’pwSchemaNum)

// loads a runtime class description

{

WORD nLen;

char szClassName[64]; CRuntimeClass* pClass;

WORD wTemp;

ar >> wTemp; *pwSchemaNum = wTemp; ar >> nLen;

if (nLen >= _countof(szClassName) ||

ar.Read(szClassName, nLen*sizeof(char)) !=

nLen*sizeof(char))

{

return NULL;

}

szClassName[nLen] = ^Л\0′;

// search app specific classes

AFX_MODULE_STATE* pModuleState = AfxGetModuleState(); AfxLockGlobals(CRIT_RUNTIMECLASSLIST);

for (pClass = pModuleState->m_classList; pClass != NULL; pClass = pClass->m_pNextClass)

{

if (IstrcmpA(szClassName,

pClass->m_lpszClassName) == 0)

{

AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST); return pClass;

}

}

AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST);

#ifdef _AFXDLL

// search classes in shared DLLs AfxLockGlobals(CRITJDYNLINKLIST);

for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL; pDLL = pDLL->m_pNextDLL)

{

for (pClass = pDLL->m_classList; pClass != NULL; pClass = pClass->m_pNextClass)

{

if (IstrcmpA(szClassName,

pClass->m_lpszClassName) == 0)

{

AfxUnlockGlobals(CRIT_DYNLINKL1ST) ; return pClass;

}

}

}

AfxUnlockGlobals(CRIT_DYNLINKLIST); #endif

TRACE1 ("’Warning: Cannot load %hs from archive.

Class not defined.\n", szClassName);

return NULL; // not found

}

В тексте этого метода нужно обратить внимание на одну ме­лочь: для чтения названия класса выделяется буфер размером 64 байта. Следовательно, название класса не может быть длин­нее 64 символов.

CObject* CArchive::ReadObject(const CRuntimeClass*

pClassRefRequested)

{

ASSERT(pClassRefRequested == NULL || AfxIsValidAddress(pClassRefRequested,

sizeof(CRuntimeClass), FALSE));

ASSERT(IsLoading()); // proper direction ASSERT(wNullTag == 0);

ASSERT((wClassTag « 16) == dwBigClassTag); ASSERT((wNewClassTag & wClassTag) == wClassTag);

// attempt to load next stream as CRuntimeClass UINT nSchema; DWORD obTag;

CRuntimeClass* pClassRef = ReadClass(pClassRefRequested,

SnSchema, &obTag);

// check to see if tag to already loaded object CObject* pOb; if (pClassRef == NULL) {

if (obTag > (DWORD)m_pLoadArray->GetUpperBound()) {

// tag is too large for the number of objects read so far AfxThrowArchiveException(CArchiveException::badlndex,

m_strFileName);

}

pOb = (CObject*)m_pLoadArray->GetAt(obTag); if (pOb != NULL &&

pClassRefRequested != NULL && !pOb->IsKindOf(pClassRefRequested))

{

// loaded an object but of the wrong class

AfxThrowArchiveException(CArchiveException:rbadClass,

m_strFileName);

}

}

else {

// allocate a new object based on the class just acquired pOb = pClassRef->CreateObject(); if (pOb == NULL)

AfxThrowMemoryException();

// Add to mapping array BEFORE de-serializing CheckCount();

m_pLoadArray->InsertAt(m_nMapCount + + , pOb) ;

// Serialize the object with the schema number set // in the archive

UINT nSchemaSave = m_nObjectSchema;

m_nObjectSchema = nSchema;

pOb->Serialize(*this);

m_nObjectSchema = nSchemaSave;

ASSERT_VALID(pOb) ;

}

return pOb;

}

void CArchive::MapObject(const CObject* pOb) {

if (IsStoring()) {

if (m_pStoreMap == NULL) {

// initialize the storage map

// (use CMapPtrToPtr because it is used for

// HANDLE maps too)

m_pStoreMap = new CMapPtrToPtr(m_nGrowSize) ; m_pStoreMap->InitHashTable(m_nHashSize); m_pStoreMap->SetAt(NULL, (void*) (DWORD)wNullTag) ; m_nMapCount = 1;

}

if (pOb != NULL) {

CheckCount(); (*m_pStoreMap)[(void*)pOb] = (void*)m_nMapCount++;

}

}

else {

if (m_pLoadArray == NULL) {

// initialize the loaded object pointer array // and set special values m_pLoadArray = new CPtrArray; m_pLoadArray->SetSize(1, m_nGrowSize); ASSERT(wNullTag == 0); m_pLoadArray->SetAt(wNullTag, NULL); m_nMapCount = 1;

}

if (pOb != NULL) {

CheckCount() ;

m_pLoadArray->InsertAt(m_nMapCount++, (void*)pOb);

}

}

}

Схема взаимоотношения буфера и его полей

_AFX_INLINE CArchive& CArchive::operator«(WORD w) {

if (m_lpBufCur + sizeof(WORD) > m_lpBufMax) Flush();

*(UNALIGNED WORD*)m_lpBufCur = w; m_lpBufCur += sizeof(WORD); return *this;

}

Так… В том случае, если для записи в буфер не хватает места, то вызывается метод Flush(), исходный код которого находится в файле агссоге.срр и тоже достаточно велик:

void CArchive::Flush() {

ASSERT_VALID(m_pFile);

ASSERT(m_bDirectBuffer || m_lpBufStart !=NULL); ASSERT(m_bDirectBuffer || m_lpBufCur !=NULL); ASSERT(m_lpBufStart == NULL ||

AfxIsValidAddress(m_lpBufStart,

m_lpBufMax – m_lpBufStart,

IsStoring ())); ASSERT(m_lpBufCur == NULL ||

AfxIsValidAddress(m_lpBufCur,

m_lpBufMax – m_lpBufCur,

IsStoring ()));

if (IsLoading()) {

// unget the characters in the buffer, // seek back unused amount

if (m_lpBufMax != m_lpBufCur)

m_pFile->Seek(-(m_lpBufMax – m_lpBufCur), CFile::current); m_lpBufCur = mjlpBufMax; // empty

}

else {

if (!m_bDirectBuffer) {

// write out the current buffer to file if (m_lpBufCur != m_lpBufStart) m_pFile->Write(m_lpBufStart, m_lpBufCur – m_lpBufStart);

}

else {

// commit current buffer

if (m_lpBufCur != m_lpBufStart)

m_pFile->GetBufferPtr(CFile::bufferCommit,

m_lpBufCur – m_lpBufStart) ;

// get next buffer «.

VERIFY(m_pFile->GetBufferPtr(CFile::bufferWrite,

m_nBufSize, (void**)&m_lpBufStart, (void**)&m_lpBufMax) == (UINT)m_nBufSize) ; ASSERT((UINT)m_nBufSize == (UINT)(m_lpBufMax -

m_lpBufStart)) ;

}

m_lpBufCur = m_lpBufStart;

}

}

void CArchive::FillBuffer(UINT nBytesNeeded) {

ASSERT_VALID(m_pFile); ASSERT (IsLoadingO ) ;

ASSERT(m_bDirectBuffer || m_lpBufStart !=NULL); ASSERT(m_bDirectBuffer || m_lpBufCur !=NULL); ASSERT(nBytesNeeded > 0);

ASSERT(nBytesNeeded <= (UINT)m_nBufSize); ASSERT(m_lpBufStart == NULL ||

AfxIsValidAddress(m_lpBufStart,

m_lpBufMax – m_lpBufStart, FALSE)); ASSERT(m_lpBufCur == NULL ||

AfxIsValidAddress(m_lpBufCur,

m_lpBufMax – m_lpBufCur, FALSE));

UINT nUnused = m_lpBufMax – m_lpBufCur;

ULONG nTotalNeeded = ( (ULONG)nBytesNeeded) + nUnused;

// fill up the current buffer from file if (!m_bDirectBuffer) {

ASSERT(m_lpBufCur != NULL); ASSERT(m_lpBufStart != NULL); ASSERT(m_lpBufMax !=NULL);

if (m_lpBufCur > m_lpBufStart) {

// copy unused

if ( (int)nUnused > 0) {

memmove(m_lpBufStart, m_lpBufCur, nUnused); m_lpBufCur = m_lpBufStart; m_lpBufMax = m_lpBufStart + nUnused;

}

// read to satisfy nBytesNeeded or nLeft if possible UINT nRead = nUnused; UINT nLeft = m_nBufSize-nUnused; UINT nBytes;

BYTE* lpTemp = m_lpBufStart + nUnused;

do

{

nBytes = m_pFile->Read(lpTemp, nLeft); lpTemp = lpTemp + nBytes; nRead += nBytes; nLeft -= nBytes;

}

while (nBytes > 0 && nLeft > 0 && nRead < nBytesNeeded);

m_lpBufCur = m_lpBufStart; m_lpBufMax = m_lpBufStart + nRead;

}

}

else {

// seek to unused portion and get the buffer

I/ starting there if (nUnused != 0)

m_pFile->Seek(-(LONG)nUnused, CFile::current); UINT nActual = m_pFile->GetBufferPtr(CFile::bufferRead,

m_nBufSize, (void**)&m_lpBufStart, (void**)&m_lpBufMax) ; ASSERT(nActual == (UINT)(m_lpBufMax – m_lpBufStart)); m_lpBufCur = m_lpBufStart;

}

// not enough data to fill request?

if ( (ULONG) (m_lpBufMax – m_lpBufCur) < nTotalNeeded) AfxThrowArchiveException(CArchiveException::endOfFile);

}

После проверки и, при необходимости, выдачи всех предупреж­дений метод определяет прежде всего число неиспользуемых бай­тов в буфере. Обратите внимание на то, что это значение вычис­ляется как разность между значениями полей mJpBufMax и mJpBufCur, а не (mJpBufStart + m_nBufSize – mJpBufCur). Почему? Пока непонятно… Затем определяется, сколько всего бай­тов необходимо для того, чтобы операция чтения могла завер­шиться нормально. Естественно, число необходимых байтов равно сумме числа неиспользуемых байтов в буфере и числа недоста­ющих байтов, переданных методу в качестве аргумента. Далее про­исходит следующее. Если у нас буфер занят частично, т. е. число неиспользуемых байтов не равно нулю, то мы копируем свободный участок памяти в начало буфера. При этом указатель на текущую позицию в буфере устанавливается на начало буфера. Это понятно. Но непонятно следующее – почему указатель m JpBufMax устанав­ливается на конец переписанного участка? Подождите, пожалуйста, осталось совсем недолго…

Идем дальше. И вот здесь… Посмотрите: значение переменной nRead делается равным числу неиспользованных байтов! Опять за­гадка. .. Определяем, сколько байтов еще необходимо считать для того, чтобы заполнить буфер до конца, читаем из файла в буфер… Полю mJpBufCur присваиваивается значение указателя на начало буфера… Вот оно! В поле mJpBufMax мы записываем число считан­ных байтов! Т. е. поле mJpBufMax указывает на конец тех данных, которые мы считали! Обычно поле mJpBufMax будет указывать на считывании достигли конца файла! В этом случае поле mJpBufMax будет указывать куда-то на середину буфера, на последний байт считанных данных! Т. е. поле mJpBufMax указывает на конец считанных данных!

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

Схематично взаимоотношения буфера и его полей показаны на 9.

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

Обратите внимание, что указатель m JpBufCur после осуществ­ления считывания данных указывает на начало буфера. А теперь, если мы вернемся в код перегруженного оператора «»», мы уви­дим, что сразу после вызова FillBuffer() оператор записывает по указанной ему ссылке считанное слово и увеличивает указатель mJpBufCur на величину, равную размеру считанного данного. Ука­затель mJpBufCur занимает то положение, которое и должен за­нимать!

pszWndClassName = AfxRegisterWndClass ( CS_HREDRAW |

CS_VREDRAW, LoadStandardCursor( IDC_ARROW ), ( HBRUSH ) ::GetStockObject( WHITE_BRUSH ), LoadStandardlcon( IDI_APPLICATION ) );

У каждого объекта, унаследованного от объекта класса СОЬ-ject, есть поле, содержащее в себе информацию времени выпол­нения. Эта информация представляет собой структуру типа CRunt-imeClass, которая описана в файле следующим образом:

struct CRuntimeClass {

// Attributes

LPCSTR m_lpszClassName; int m_nObjectSize;

UINT m_wSchema; // schema number of the loaded class CObject* (PASCAL* m_pfnCreateObject) () ;

// NULL => abstract class

#ifdef _AFXDLL

CRuntimeClass* (PASCAL* m_pfnGetBaseClass) (); #else

CRuntimeClass* m_pBaseClass; #endif

// Operations

CObject* CreateObject();

BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;

// Implementation

void Store(CArchive& ar) const;

static CRuntimeClass* PASCAL Load(CArchive& ar,

UINT* pwSchemaNum) ; // CRuntimeClass objects linked together in simple list CRuntimeClass* m_pNextClass;

// linked list of registered classes

};

Для того чтобы в ходе выполнения программы мог быть создан объект класса, который описывает CRuntimeClass, она хранит в себе указатель на конструктор по умолчанию этого класса – поле m_pfnCreateObject (CObject* (PASCAL* m_pfnCreateObject)()). Не­посредственно для создания объекта можно воспользоваться ме­тодом CreateObjectQ, который, выполняя функцию, указатель на которую находится в поле m_pfnCreateObject, возвращает указатель на созданный объект.

Если в программе возникла необходимость получить информацию о том классе, от которого был унаследован описыва­емый в структуре файл, то для этого можно воспользоваться полем mjDfnGetBaseClass (CRuntimeClass* (PASCAL* m_pfnGetBase-Class)()), в котором находится указатель на метод, позволяющий получить такую информацию.

Для сохранения объекта описываемого класса в архиве служит метод Store(). Восстановить объект из архива можно при помощи метода Load(). О том, как работают эти методы, мы поговорим при рассмотрении процесса сериализации.

Но, наверное, самым интересным полем является поле mjDNextClass. Судя по тому, что оно фактически является указате­лем на информацию времени исполнения, а также взглянув на на­звание этого поля, можно догадаться, что все структуры типа CRuntimeClass объединены в однонаправленный список. Зная ука­затель на начало этого списка, мы можем получить информацию о том, какие классы зарегистрированы в системе.