Method WriteObject

src/core/serializerimpl.cpp:336–389

////////////////////////////////////////////////////////////////////////// WriteObect, ReadObject //////////////////////////////////////////////////////////////////////////

// WriteObect, ReadObject
///////////////////////////////////////////////////////////////////////////////
void cSerializerImpl::WriteObject(const iTypedSerializable* pObj)
{
    ASSERT(pObj != 0);
    //ASSERT(mbInit); // this isn't needed if we are not writing the type array
    ASSERT(IsWriting());
    cDebug d("cSerializerImpl::WriteObject");
    //d.TraceDetail("Entering...  Archive Offset = %d\n", mpArchive->CurrentPos());
    d.TraceDetail("             Object Type    = %s\n", pObj->GetType().AsString());
    // first, we write out the header, which consists of the following:
    // int32 refrence into mTypeArray, indicating the object's type
    // int32 version of stored data
    // int32 size of the chunk (counting from this point; not including the previous int32
    // data  the object data
    ASSERT(mpArchive != 0);


    // 5Nov 98 mdb -- I am removing the read and write of type info for this method; it is never used, since
    // the object is already created when ReadObject() happens. The only good it might serve is in asserting that
    // the input stream is valid, but I can do that with the 0xffffffff size below (asserting that it is the same
    // when it is read back in)
    /*  int i = 0;
    for(; i < mTypeArray.size(); i++)
    {
        if(pObj->GetType() == *mTypeArray[i])
        {
            // aha! this is it!
            break;
        }
    }
    if(i == mTypeArray.size())
    {
        // the type was not registered; 
        // a debate exists in my mind as to whether this should be an exception or an assertion -- mdb
        d.TraceError("Attempt to serialize unregistered type : %s\n", pObj->GetType().AsString());
        ThrowAndAssert(eSerializerUnknownType(pObj->GetType().AsString()));
    }
    mpArchive->WriteInt32(i);
*/

    mpArchive->WriteInt32(0); // place holder for type array index
    mpArchive->WriteInt32(pObj->Version());
    // write a placeholder for the size; we will come back and fill in the right value later...
    //int64 sizePos = mpArchive->CurrentPos();
    mpArchive->WriteInt32(0xffffffff);

    // write out the object!
    pObj->Write(this);

    // finally, we need to go back and patch up the size...
    //int64 returnPos = mpArchive->CurrentPos();
    //mpArchive->Seek(sizePos, cBidirArchive::BEGINNING);
    //mpArchive->WriteInt32((int32)(returnPos - sizePos - sizeof(int32)));
    //mpArchive->Seek(returnPos, cBidirArchive::BEGINNING);
}

void cSerializerImpl::ReadObject(iTypedSerializable* pObj)
{