MFC浅析(8) CArchive 原理

CArchive 原理

FMD(http://www.fmdstudio.net)

MFC 提供CArchive类实现数据的缓冲区读写，同时定义了类对象的存储与读取方案。

以下对CArchvie 的内部实现作分析。

1.概述

CArchive使用了缓冲区，即一段内存空间作为临时数据存储地，对CArchive的读写都先依次排列到此缓冲区，当缓冲区满或用户要求时，将此段整理后的数据读写到指定的存储煤质。

当建立CArchive对象时，应指定其模式是用于缓冲区读，还是用于缓冲区写。

可以这样理解，CArchive对象相当于铁路的货运练调度站，零散的货物被收集，当总量到达火车运量的时候，由火车装运走。

当接到火车的货物时，则货物由被分散到各自的货主。与货运不同的是，交货、取货是按时间循序执行的，而不是凭票据。因此必须保证送货的和取货的货主按同样的循序去存或取。

对于大型的货物，则是拆散成火车单位，运走，取货时，依次取各部分，组装成原物。

2.内部数据

缓冲区指针 BYTE* m_lpBufStart,指向缓冲区，这个缓冲区有可能是底层CFile(如派生类CMemFile)对象提供的，但一般是CArchive自己建立的。

缓冲区尾部指针 BYTE* m_lpBufMax;

缓冲区当前位置指针 BYTE* m_lpBufCur;

初始化时，如果是读模式,当前位置在尾部，如果是写模式，当前位置在头部:

m_lpBufCur = (IsLoading()) ? m_lpBufMax : m_lpBufStart;

3.基本数据读写

对于基本的数据类型，例如字节、双字等，可以直接使用""、"

//操作符定义捕:

//插入操作

CArchive& operator<<(BYTE by);

CArchive& operator<<(WORD w);

CArchive& operator<<(LONG l);

CArchive& operator<<(DWORD dw);

CArchive& operator<<(float f);

CArchive& operator<<(double d);

CArchive& operator<<(int i);

CArchive& operator<<(short w);

CArchive& operator<<(char ch);

CArchive& operator<<(unsigned u);

//提取操作

CArchive& operator>>(BYTE& by);

CArchive& operator>>(WORD& w);

CArchive& operator>>(DWORD& dw);

CArchive& operator>>(LONG& l);

CArchive& operator>>(float& f);

CArchive& operator>>(double& d);

CArchive& operator>>(int& i);

CArchive& operator>>(short& w);

CArchive& operator>>(char& ch);

CArchive& operator>>(unsigned& u);

下面以双字为例，分析原码

双字的插入(写)

CArchive& CArchive::operator<<(DWORD dw)

{

if (m_lpBufCur + sizeof(DWORD) > m_lpBufMax) //缓冲区空间不够

Flush(); //缓冲区内容提交到实际存储煤质。

if (!(m_nMode & bNoByteSwap))

_AfxByteSwap(dw, m_lpBufCur); //处理字节顺序

else

*(DWORD*)m_lpBufCur = dw; //添入缓冲区

m_lpBufCur += sizeof(DWORD); //移动当前指针

return *this;

}

双字的提取(读)

CArchive& CArchive::operator>>(DWORD& dw)

{

if (m_lpBufCur + sizeof(DWORD) > m_lpBufMax) //缓冲区要读完了

FillBuffer(sizeof(DWORD) - (UINT)(m_lpBufMax - m_lpBufCur)); //重新读入内容到缓冲区

dw = *(DWORD*)m_lpBufCur; //读取双字

m_lpBufCur += sizeof(DWORD); //移动当前位置指针

if (!(m_nMode & bNoByteSwap))

_AfxByteSwap(dw, (BYTE*)&dw); //处理字节顺序

return *this;

}

4.缓冲区的更新

以上操作中，当缓冲区将插入满或缓冲区将提取空时，都将对缓冲区进行更新处理

缓冲区将插入致满时调用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 = m_lpBufMax; // 指向尾

}

else //写模式

{

if (!m_bDirectBuffer)

{

// 内容写入到文件

if (m_lpBufCur != m_lpBufStart)

m_pFile-> Write(m_lpBufStart, m_lpBufCur - m_lpBufStart);

}

else

{

//如果是直接针对内存区域的的(例如CMemFile中) (只需移动相关指针，指向新的一块内存)

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; //指向缓冲区首

}

缓冲区将提取空将调用GFileeBuffer,nBytesNeeded为当前剩余部分上尚有用的字节

void CArchive::FillBuffer(UINT nBytesNeeded)

{

ASSERT_VALID(m_pFile);

ASSERT(IsLoading());

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;

// 从文件中读取

if (!m_bDirectBuffer)

{

ASSERT(m_lpBufCur != NULL);

ASSERT(m_lpBufStart != NULL);

ASSERT(m_lpBufMax != NULL);

if (m_lpBufCur > m_lpBufStart)

{

//保留剩余的尚未处理的部分，将它们移动到头

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;

{

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

{

// 如果是针对内存区域(CMemFile),移动相关指针，指向新的一块内存

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);

}

5.指定长度数据段落的读写

以下分析

UINT Read(void* lpBuf, UINT nMax); 读取长度为nMax的数据

void Write(const void* lpBuf, UINT nMax); 写入指定长度nMax的数据

对于大段数据的读写，先使用当前缓冲区中的内容或空间读取或写入，若这些空间够用了，则结束。

否则，从剩余的数据中找出最大的缓冲区整数倍大小的一块数据，直接读写到存储煤质(不反复使用缓冲区)。

剩余的余数部分，再使用缓冲区读写。

(说明:缓冲区读写的主要目的是将零散的数据以缓冲区大小为尺度来处理。对于大型数据，其中间的部分，不是零散的数据，使用缓冲区已经没有意思，故直接读写)

①读取

UINT CArchive::Read(void* lpBuf, UINT nMax)

{

ASSERT_VALID(m_pFile);

if (nMax == 0)

return 0;

UINT nMaxTemp = nMax; //还需要读入的长度，读入一部分，就减相应数值，直到此数值变为零

//处理当前缓冲区中剩余部分。

//如果要求读入字节小于缓冲区中剩余部分,则第一部分为要求读入的字节数，

//否则读入全部剩余部分

UINT nTemp = min(nMaxTemp, (UINT)(m_lpBufMax - m_lpBufCur));

memcpy(lpBuf, m_lpBufCur, nTemp);

m_lpBufCur += nTemp;

lpBuf = (BYTE*)lpBuf + nTemp; //移动读出内容所在区域的指针

nMaxTemp -= nTemp;

//当前缓冲区中剩余部分不够要求读入的长度。

//还有字节需要读，则需要根据需要执行若干次填充缓冲区，读出，直到读出指定字节。

if (nMaxTemp != 0)

{

//计算出去除尾数部分的字节大小(整数个缓冲区大小)

//对于这些部分，字节从文件对象中读出，放到输出缓冲区

nTemp = nMaxTemp - (nMaxTemp % m_nBufSize);

UINT nRead = 0;

UINT nLeft = nTemp;

UINT nBytes;

{

nBytes = m_pFile-> Read(lpBuf, nLeft); //要求读入此整数缓冲区部分大小

lpBuf = (BYTE*)lpBuf + nBytes;

nRead += nBytes;

nLeft -= nBytes;

}

while ((nBytes > 0) && (nLeft > 0)); 知道读入了预定大小，或到达文件尾

nMaxTemp -= nRead;

if (nRead == nTemp) //读入的字节等于读入的整数倍部分该读最后的余数部分了

{

// 建立装有此最后余数部分的内容的CArchive的工作缓冲区。

if (!m_bDirectBuffer)

{

UINT nLeft = max(nMaxTemp, (UINT)m_nBufSize);

UINT nBytes;

BYTE* lpTemp = m_lpBufStart;

nRead = 0;

{

nBytes = m_pFile-> Read(lpTemp, nLeft); //从文件中读入到CArchive缓冲区

lpTemp = lpTemp + nBytes;

nRead += nBytes;

nLeft -= nBytes;

}

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

m_lpBufCur = m_lpBufStart;

m_lpBufMax = m_lpBufStart + nRead;

}

else

{

nRead = m_pFile-> GetBufferPtr(CFile::bufferRead, m_nBufSize,

(void**)&m_lpBufStart, (void**)&m_lpBufMax);

ASSERT(nRead == (UINT)(m_lpBufMax - m_lpBufStart));

m_lpBufCur = m_lpBufStart;

}

//读出此剩余部分到输出

nTemp = min(nMaxTemp, (UINT)(m_lpBufMax - m_lpBufCur));

memcpy(lpBuf, m_lpBufCur, nTemp);

m_lpBufCur += nTemp;

nMaxTemp -= nTemp;

}

return nMax - nMaxTemp;

}

②保存,写入

void CArchive::Write(const void* lpBuf, UINT nMax)

{

if (nMax == 0)

return;

//读入可能的部分到缓冲区当前的剩余部分

UINT nTemp = min(nMax, (UINT)(m_lpBufMax - m_lpBufCur));

memcpy(m_lpBufCur, lpBuf, nTemp);

m_lpBufCur += nTemp;

lpBuf = (BYTE*)lpBuf + nTemp;

nMax -= nTemp;

if (nMax > 0) //还有未写入的部分

{

Flush(); //将当前缓冲区写入到存储煤质

//计算出整数倍缓冲区大小的字节数

nTemp = nMax - (nMax % m_nBufSize);

m_pFile-> Write(lpBuf, nTemp); //直接写到文件

lpBuf = (BYTE*)lpBuf + nTemp;

nMax -= nTemp;

//剩余部分添加到缓冲区

if (m_bDirectBuffer)

{

// sync up direct mode buffer to new file position

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;

}

// copy remaining to active buffer

ASSERT(nMax < (UINT)m_nBufSize);

ASSERT(m_lpBufCur == m_lpBufStart);

memcpy(m_lpBufCur, lpBuf, nMax);

m_lpBufCur += nMax;

}

6.字符串的读写

①CArchive提供的WriteString和ReadString

字符串写

void CArchive::WriteString(LPCTSTR lpsz)

{

ASSERT(AfxIsValidString(lpsz));

Write(lpsz, lstrlen(lpsz) * sizeof(TCHAR)); //调用Write，将字符串对应的一段数据写入

}

字符串读(读取一行字符串)

LPTSTR CArchive::ReadString(LPTSTR lpsz, UINT nMax)

{

// if nMax is negative (such a large number doesn't make sense given today's

// 2gb address space), then assume it to mean "keep the newline".

int nStop = (int)nMax < 0 ? -(int)nMax : (int)nMax;

ASSERT(AfxIsValidAddress(lpsz, (nStop+1) * sizeof(TCHAR)));

_TUCHAR ch;

int nRead = 0;

TRY

{

while (nRead < nStop)

{

*this >> ch; //读出一个字节

// stop and end-of-line (trailing '\n' is ignored) 遇换行—回车

if (ch == '\n' || ch == '\r')

{

if (ch == '\r')

*this >> ch;

// store the newline when called with negative nMax

if ((int)nMax != nStop)

lpsz[nRead++] = ch;

break;

}

lpsz[nRead++] = ch;

}

CATCH(CArchiveException, e)

{

if (e-> m_cause == CArchiveException::endOfFile)

{

DELETE_EXCEPTION(e);

if (nRead == 0)

return NULL;

}

else

{

THROW_LAST();

}

END_CATCH

lpsz[nRead] = '\0';

return lpsz;

}

ReadString到CString对象,可以多行字符

BOOL CArchive::ReadString(CString& rString)

{

rString = &afxChNil; // empty string without deallocating

const int nMaxSize = 128;

LPTSTR lpsz = rString.GetBuffer(nMaxSize);

LPTSTR lpszResult;

int nLen;

for (;;)

{

lpszResult = ReadString(lpsz, (UINT)-nMaxSize); // store the newline

rString.ReleaseBuffer();

// if string is read completely or EOF

if (lpszResult == NULL ||

(nLen = lstrlen(lpsz)) < nMaxSize ||

lpsz[nLen-1] == '\n')

{

break;

}

nLen = rString.GetLength();

lpsz = rString.GetBuffer(nMaxSize + nLen) + nLen;

}

// remove '\n' from end of string if present

lpsz = rString.GetBuffer(0);

nLen = rString.GetLength();

if (nLen != 0 && lpsz[nLen-1] == '\n')

rString.GetBufferSetLength(nLen-1);

return lpszResult != NULL;

}

②使用CString对象的""符读写字符串

CString定义了输入输出符,可以象基本类型的数据一样使用CArchive

的操作符定义

friend CArchive& AFXAPI operator<<(CArchive& ar, const CString& string);

friend CArchive& AFXAPI operator>>(CArchive& ar, CString& string);

// CString serialization code

// String format:

// UNICODE strings are always prefixed by 0xff, 0xfffe

// if < 0xff chars: len:BYTE, TCHAR chars

// if >= 0xff characters: 0xff, len:WORD, TCHAR chars

// if >= 0xfffe characters: 0xff, 0xffff, len:DWORD, TCHARs

CArchive& AFXAPI operator<<(CArchive& ar, const CString& string)

{

// special signature to recognize unicode strings

#ifdef _UNICODE

ar << (BYTE)0xff;

ar << (WORD)0xfffe;

#endif

if (string.GetData()-> nDataLength < 255)

{

ar << (BYTE)string.GetData()-> nDataLength;

}

else if (string.GetData()-> nDataLength < 0xfffe)

{

ar << (BYTE)0xff;

ar << (WORD)string.GetData()-> nDataLength;

}

else

{

ar << (BYTE)0xff;

ar << (WORD)0xffff;

ar << (DWORD)string.GetData()-> nDataLength;

}

ar.Write(string.m_pchData, string.GetData()-> nDataLength*sizeof(TCHAR));

return ar;

}

// return string length or -1 if UNICODE string is found in the archive

AFX_STATIC UINT AFXAPI _AfxReadStringLength(CArchive& ar)

{

DWORD nNewLen;

// attempt BYTE length first

BYTE bLen;

ar >> bLen;

if (bLen < 0xff)

return bLen;

// attempt WORD length

WORD wLen;

ar >> wLen;

if (wLen == 0xfffe)

{

// UNICODE string prefix (length will follow)

return (UINT)-1;

}

else if (wLen == 0xffff)

{

// read DWORD of length

ar >> nNewLen;

return (UINT)nNewLen;

}

else

return wLen;

}

CArchive& AFXAPI operator>>(CArchive& ar, CString& string)

{

#ifdef _UNICODE

int nConvert = 1; // if we get ANSI, convert

#else

int nConvert = 0; // if we get UNICODE, convert

#endif

UINT nNewLen = _AfxReadStringLength(ar);

if (nNewLen == (UINT)-1)

{

nConvert = 1 - nConvert;

nNewLen = _AfxReadStringLength(ar);

ASSERT(nNewLen != -1);

}

// set length of string to new length

UINT nByteLen = nNewLen;

#ifdef _UNICODE

string.GetBufferSetLength((int)nNewLen);

nByteLen += nByteLen * (1 - nConvert); // bytes to read

#else

nByteLen += nByteLen * nConvert; // bytes to read

if (nNewLen == 0)

string.GetBufferSetLength(0);

else

string.GetBufferSetLength((int)nByteLen+nConvert);

#endif

// read in the characters

if (nNewLen != 0)

{

ASSERT(nByteLen != 0);

// read new data

if (ar.Read(string.m_pchData, nByteLen) != nByteLen)

AfxThrowArchiveException(CArchiveException::endOfFile);

// convert the data if as necessary

if (nConvert != 0)

{

#ifdef _UNICODE

CStringData* pOldData = string.GetData();

LPSTR lpsz = (LPSTR)string.m_pchData;

#else

CStringData* pOldData = string.GetData();

LPWSTR lpsz = (LPWSTR)string.m_pchData;

#endif

lpsz[nNewLen] = '\0'; // must be NUL terminated

string.Init(); // don't delete the old data

string = lpsz; // convert with operator=(LPWCSTR)

CString::FreeData(pOldData);

}

return ar;

}

7.CObject派生对象的读写

MFC中多数类都从CObject类派生，CObject类与CArchive类有着良好的合作关系，能实现将对象序列化储存到文件或其他媒介中去，或者读取预先储存的对象，动态建立对象等功能。

①CObject定义了针对CArvhive的输入输出操作符,可以向其他基本数据类型一样使用"<<"、"<<"符号

CArchive& AFXAPI operator<<(CArchive& ar, const CObject* pOb)

{ ar.WriteObject(pOb); return ar; }

CArchive& AFXAPI operator>>(CArchive& ar, CObject*& pOb)

{ pOb = ar.ReadObject(NULL); return ar; }

当使用这些符号时，实际上执行的是CArchive的WriteObject和ReadObject成员

②WriteObject与ReadObject

在WriteObject与ReadObject中先写入或读取运行时类信息(CRuntimeClas)，再调用Serialze(..),按其中的代码读写具体的对象数据。

因此，只要在CObject派生类中重载Serilize()函数，写入具体的读写过程，就可以使对象具有存储与创建能力。

//将对象写入到缓冲区

void CArchive::WriteObject(const CObject* pOb)

{

DWORD nObIndex;

// make sure m_pStoreMap is initialized

MapObject(NULL);

if (pOb == NULL)

{

// save out null tag to represent NULL pointer

*this << wNullTag;

}

else if ((nObIndex = (DWORD)(*m_pStoreMap)[(void*)pOb]) != 0)

// assumes initialized to 0 map

{

// save out index of already stored object

if (nObIndex < wBigObjectTag)

*this << (WORD)nObIndex;

else

{

*this << wBigObjectTag;

*this << nObIndex;

}

else

{

// write class of object first

CRuntimeClass* pClassRef = pOb-> GetRuntimeClass();

WriteClass(pClassRef); //写入运行类信息

// enter in stored object table, checking for overflow

CheckCount();

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

// 调用CObject的Serialize成员，按其中的代码写入类中数据。

((CObject*)pOb)-> Serialize(*this);

}

CObject* CArchive::ReadObject(const CRuntimeClass* pClassRefRequested)

{

// attempt to load next stream as CRuntimeClass

UINT nSchema;

DWORD obTag;

//先读入运行时类信息

CRuntimeClass* pClassRef = ReadClass(pClassRefRequested, &nSchema, &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::badIndex,

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::badClass,

m_strFileName);

}

else

{

// 建立对象

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); //调用CObject的Serialize,按其中代码读入对象数据。

m_nObjectSchema = nSchemaSave;

ASSERT_VALID(pOb);

}

return pOb;

}

③运行时类信息的读写

为了避免众多重复的同类对象写入重复的类信息，CArchive中使用CMap对象储存和检索类信息。

void CArchive::WriteClass(const CRuntimeClass* pClassRef)

{

ASSERT(pClassRef != NULL);

ASSERT(IsStoring()); // proper direction

if (pClassRef-> m_wSchema == 0xFFFF)

{

TRACE1("Warning: Cannot call WriteClass/WriteObject for %hs.\n",

pClassRef-> m_lpszClassName);

AfxThrowNotSupportedException();

}

// make sure m_pStoreMap is initialized

MapObject(NULL);

// write out class id of pOb, with high bit set to indicate

// new object follows

// ASSUME: initialized to 0 map

DWORD nClassIndex;

if ((nClassIndex = (DWORD)(*m_pStoreMap)[(void*)pClassRef]) != 0)

{

// previously seen class, write out the index tagged by high bit

if (nClassIndex < wBigObjectTag)

*this << (WORD)(wClassTag | nClassIndex);

else

{

*this << wBigObjectTag;

*this << (dwBigClassTag | nClassIndex);

}

else

{

// store new class

*this << wNewClassTag;

pClassRef-> Store(*this);

// store new class reference in map, checking for overflow

CheckCount();

(*m_pStoreMap)[(void*)pClassRef] = (void*)m_nMapCount++;

}

CRuntimeClass* CArchive::ReadClass(const CRuntimeClass* pClassRefRequested,

UINT* pSchema, DWORD* pObTag)

{

ASSERT(pClassRefRequested == NULL ||

AfxIsValidAddress(pClassRefRequested, sizeof(CRuntimeClass), FALSE));

ASSERT(IsLoading()); // proper direction

if (pClassRefRequested != NULL && pClassRefRequested-> m_wSchema == 0xFFFF)

{

TRACE1("Warning: Cannot call ReadClass/ReadObject for %hs.\n",

pClassRefRequested-> m_lpszClassName);

AfxThrowNotSupportedException();

}

// make sure m_pLoadArray is initialized

MapObject(NULL);

// read object tag - if prefixed by wBigObjectTag then DWORD tag follows

DWORD obTag;

WORD wTag;

*this >> wTag;

if (wTag == wBigObjectTag)

*this >> obTag;

else

obTag = ((wTag & wClassTag) << 16) | (wTag & ~wClassTag);

// check for object tag (throw exception if expecting class tag)

if (!(obTag & dwBigClassTag))

{

if (pObTag == NULL)

AfxThrowArchiveException(CArchiveException::badIndex, m_strFileName);

*pObTag = obTag;

return NULL;

}

CRuntimeClass* pClassRef;

UINT nSchema;

if (wTag == wNewClassTag)

{

// new object follows a new class id

if ((pClassRef = CRuntimeClass::Load(*this, &nSchema)) == NULL)

AfxThrowArchiveException(CArchiveException::badClass, m_strFileName);

// check nSchema against the expected schema

if ((pClassRef-> m_wSchema & ~VERSIONABLE_SCHEMA) != nSchema)

{

if (!(pClassRef-> m_wSchema & VERSIONABLE_SCHEMA))

{

// schema doesn't match and not marked as VERSIONABLE_SCHEMA

AfxThrowArchiveException(CArchiveException::badSchema,

m_strFileName);

}

else

{

// they differ -- store the schema for later retrieval

if (m_pSchemaMap == NULL)

m_pSchemaMap = new CMapPtrToPtr;

ASSERT_VALID(m_pSchemaMap);

m_pSchemaMap-> SetAt(pClassRef, (void*)nSchema);

}

CheckCount();

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

}

else

{

// existing class index in obTag followed by new object

DWORD nClassIndex = (obTag & ~dwBigClassTag);

if (nClassIndex == 0 || nClassIndex > (DWORD)m_pLoadArray-> GetUpperBound())

AfxThrowArchiveException(CArchiveException::badIndex,

m_strFileName);

pClassRef = (CRuntimeClass*)m_pLoadArray-> GetAt(nClassIndex);

ASSERT(pClassRef != NULL);

// determine schema stored against objects of this type

void* pTemp;

BOOL bFound = FALSE;

nSchema = 0;

if (m_pSchemaMap != NULL)

{

bFound = m_pSchemaMap-> Lookup( pClassRef, pTemp );

if (bFound)

nSchema = (UINT)pTemp;

}

if (!bFound)

nSchema = pClassRef-> m_wSchema & ~VERSIONABLE_SCHEMA;

}

// check for correct derivation

if (pClassRefRequested != NULL &&

!pClassRef-> IsDerivedFrom(pClassRefRequested))

{

AfxThrowArchiveException(CArchiveException::badClass, m_strFileName);

}

// store nSchema for later examination

if (pSchema != NULL)

*pSchema = nSchema;

else

m_nObjectSchema = nSchema;

// store obTag for later examination

if (pObTag != NULL)

*pObTag = obTag;

// return the resulting CRuntimeClass*

return pClassRef;

}