member.cpp

ncbi源码

}

TObjectPtr CMemberInfoFunctions::GetDelayedMember(const CMemberInfo* memberInfo,
                                                  TObjectPtr classPtr)
{
    _ASSERT(memberInfo->CanBeDelayed());
    memberInfo->GetDelayBuffer(classPtr).Update();
    memberInfo->UpdateSetFlagYes(classPtr);
    return memberInfo->GetItemPtr(classPtr);
}

void CMemberInfoFunctions::ReadSimpleMember(CObjectIStream& in,
                                            const CMemberInfo* memberInfo,
                                            TObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(!memberInfo->HaveSetFlag());
    in.ReadObject(memberInfo->GetItemPtr(classPtr),
                  memberInfo->GetTypeInfo());
}

void CMemberInfoFunctions::ReadWithSetFlagMember(CObjectIStream& in,
                                                 const CMemberInfo* memberInfo,
                                                 TObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(memberInfo->HaveSetFlag());
    memberInfo->UpdateSetFlagYes(classPtr);
    try {
        in.ReadObject(memberInfo->GetItemPtr(classPtr),
                      memberInfo->GetTypeInfo());
    }
    catch (CSerialException& e) {
        if (e.GetErrCode() == CSerialException::eMissingValue) {
            if ( memberInfo->Optional() && memberInfo->HaveSetFlag() ) {
                in.SetFailFlags(CObjectIStream::fNoError,0);
                if ( memberInfo->UpdateSetFlagNo(classPtr) ) {
                    memberInfo->GetTypeInfo()->SetDefault(
                        memberInfo->GetItemPtr(classPtr));
                }
            } else {
                NCBI_RETHROW(e, CSerialException, eFormatError,
                    "error while reading " + memberInfo->GetId().GetName());
            }
        } else {
            NCBI_RETHROW_SAME(e,
                "error while reading " + memberInfo->GetId().GetName());
        }
    }
}

void CMemberInfoFunctions::ReadLongMember(CObjectIStream& in,
                                          const CMemberInfo* memberInfo,
                                          TObjectPtr classPtr)
{
    if ( memberInfo->CanBeDelayed() ) {
        CDelayBuffer& buffer = memberInfo->GetDelayBuffer(classPtr);
        if ( !buffer ) {
            memberInfo->UpdateSetFlagYes(classPtr);
            in.StartDelayBuffer();
            memberInfo->GetTypeInfo()->SkipData(in);
            in.EndDelayBuffer(buffer, memberInfo, classPtr);
            return;
        }
        buffer.Update();
    }
    
    memberInfo->UpdateSetFlagYes(classPtr);
    in.ReadObject(memberInfo->GetItemPtr(classPtr),
                  memberInfo->GetTypeInfo());
}

void CMemberInfoFunctions::ReadMissingSimpleMember(CObjectIStream& in,
                                                   const CMemberInfo* memberInfo,
                                                   TObjectPtr classPtr)
{
    _ASSERT(!memberInfo->Optional());
    in.ExpectedMember(memberInfo);

    if (memberInfo->HaveSetFlag()) {
        memberInfo->UpdateSetFlagNo(classPtr);
    }
    memberInfo->GetTypeInfo()->SetDefault(memberInfo->GetItemPtr(classPtr));
#ifdef _DEBUG
    if (in.GetVerifyData() == eSerialVerifyData_No) {
        if (memberInfo->GetTypeInfo()->GetTypeFamily() == eTypeFamilyPrimitive) {
            CObjectInfo objinfo(memberInfo->GetItemPtr(classPtr),
                                memberInfo->GetTypeInfo());
            if (objinfo.GetPrimitiveValueType() == ePrimitiveValueString) {
                objinfo.SetPrimitiveValueString(CSerialObject::ms_UnassignedStr);
            } else {
                size_t size = memberInfo->GetTypeInfo()->GetSize();
                if (size <= sizeof(long)) {
                    char* tmp = static_cast<char*>(
                        memberInfo->GetItemPtr(classPtr));
                    for (; size != 0; --size, ++tmp) {
                        *tmp = CSerialObject::ms_UnassignedByte;
                    }
                }
            }
        }
    }
#endif
}

void
CMemberInfoFunctions::ReadMissingOptionalMember(CObjectIStream& /*in*/,
                                                const CMemberInfo* memberInfo,
                                                TObjectPtr classPtr)
{
    _ASSERT(memberInfo->Optional());
    memberInfo->GetTypeInfo()->SetDefault(memberInfo->GetItemPtr(classPtr));
}

void
CMemberInfoFunctions::ReadMissingWithSetFlagMember(CObjectIStream& /*in*/,
                                                   const CMemberInfo* memberInfo,
                                                   TObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(memberInfo->HaveSetFlag());
    if ( memberInfo->UpdateSetFlagNo(classPtr) ) {
        memberInfo->GetTypeInfo()->SetDefault(memberInfo->GetItemPtr(classPtr));
    }
}

void CMemberInfoFunctions::WriteSimpleMember(CObjectOStream& out,
                                             const CMemberInfo* memberInfo,
                                             TConstObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(!memberInfo->Optional());
    out.WriteClassMember(memberInfo->GetId(),
                         memberInfo->GetTypeInfo(),
                         memberInfo->GetItemPtr(classPtr));
}

void CMemberInfoFunctions::WriteOptionalMember(CObjectOStream& out,
                                               const CMemberInfo* memberInfo,
                                               TConstObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(memberInfo->Optional());
    TTypeInfo memberType = memberInfo->GetTypeInfo();
    TConstObjectPtr memberPtr = memberInfo->GetItemPtr(classPtr);
    if ( memberType->IsDefault(memberPtr) )
        return;

    out.WriteClassMember(memberInfo->GetId(), memberType, memberPtr);
}

void CMemberInfoFunctions::WriteWithDefaultMember(CObjectOStream& out,
                                                  const CMemberInfo* memberInfo,
                                                  TConstObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(memberInfo->GetDefault());
    TTypeInfo memberType = memberInfo->GetTypeInfo();
    TConstObjectPtr memberPtr = memberInfo->GetItemPtr(classPtr);
    if ( memberType->Equals(memberPtr, memberInfo->GetDefault()) )
        return;

    out.WriteClassMember(memberInfo->GetId(), memberType, memberPtr);
}

void CMemberInfoFunctions::WriteWithSetFlagMember(CObjectOStream& out,
                                                  const CMemberInfo* memberInfo,
                                                  TConstObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(memberInfo->HaveSetFlag());
    if ( memberInfo->GetSetFlagNo(classPtr) ) {
        if (memberInfo->Optional()) {
            return;
        }
        ESerialVerifyData verify = out.GetVerifyData();
        if (verify == eSerialVerifyData_Yes) {
            out.ThrowError(CObjectOStream::fUnassigned,
                string("Unassigned member: ")+memberInfo->GetId().GetName());
        } else if (verify == eSerialVerifyData_No) {
            return;
        }
    }
#ifdef _DEBUG
    if (memberInfo->GetSetFlag(classPtr) == CMemberInfo::eSetMaybe &&
        memberInfo->GetTypeInfo()->GetTypeFamily() == eTypeFamilyPrimitive) {
        bool do_err_post = false;
        CConstObjectInfo objinfo(memberInfo->GetItemPtr(classPtr),
                                 memberInfo->GetTypeInfo());
        if (objinfo.GetPrimitiveValueType() == ePrimitiveValueString) {
            string tmp;
            objinfo.GetPrimitiveValueString(tmp);
            do_err_post = (tmp == CSerialObject::ms_UnassignedStr);
        } else {
            size_t size = memberInfo->GetTypeInfo()->GetSize();
            const char* tmp = static_cast<const char*>(
                memberInfo->GetItemPtr(classPtr));
            for (; size != 0 && *tmp == CSerialObject::ms_UnassignedByte; --size, ++tmp)
                ;
            do_err_post = (size == 0);
        }
        if (do_err_post) {
            ERR_POST(Error << "CObjectOStream: at "<< out.GetPosition()<<
                     ": Member \""<< memberInfo->GetId().GetName()<<
                     "\" seems to be unassigned");
        }
    }
#endif
    out.WriteClassMember(memberInfo->GetId(),
                         memberInfo->GetTypeInfo(),
                         memberInfo->GetItemPtr(classPtr));
}

void CMemberInfoFunctions::WriteLongMember(CObjectOStream& out,
                                           const CMemberInfo* memberInfo,
                                           TConstObjectPtr classPtr)
{
    bool haveSetFlag = memberInfo->HaveSetFlag();
    if ( haveSetFlag && memberInfo->GetSetFlagNo(classPtr) ) {
        // not set -> skip this member
        return;
    }
    
    if ( memberInfo->CanBeDelayed() ) {
        const CDelayBuffer& buffer = memberInfo->GetDelayBuffer(classPtr);
        if ( buffer ) {
            if ( out.WriteClassMember(memberInfo->GetId(), buffer) )
                return;

            // cannot write delayed buffer -> proceed after update
            const_cast<CDelayBuffer&>(buffer).Update();
        }
    }
    
    TTypeInfo memberType = memberInfo->GetTypeInfo();
    TConstObjectPtr memberPtr = memberInfo->GetItemPtr(classPtr);
    if ( !haveSetFlag && memberInfo->Optional() ) {
        TConstObjectPtr defaultPtr = memberInfo->GetDefault();
        if ( !defaultPtr ) {
            if ( memberType->IsDefault(memberPtr) )
                return; // DEFAULT
        }
        else {
            if ( memberType->Equals(memberPtr, defaultPtr) )
                return; // OPTIONAL
        }
    }
    
    out.WriteClassMember(memberInfo->GetId(), memberType, memberPtr);
}

void CMemberInfoFunctions::CopySimpleMember(CObjectStreamCopier& copier,
                                            const CMemberInfo* memberInfo)
{
    copier.CopyObject(memberInfo->GetTypeInfo());
}

void CMemberInfoFunctions::CopyMissingSimpleMember(CObjectStreamCopier& copier,
                                                   const CMemberInfo* memberInfo)
{
    _ASSERT(!memberInfo->Optional());
    copier.ExpectedMember(memberInfo);
}

void CMemberInfoFunctions::CopyMissingOptionalMember(CObjectStreamCopier& /*copier*/,
                                                     const CMemberInfo* _DEBUG_ARG(memberInfo))
{
    _ASSERT(memberInfo->Optional());
}

void CMemberInfoFunctions::SkipSimpleMember(CObjectIStream& in,
                                            const CMemberInfo* memberInfo)
{
    in.SkipObject(memberInfo->GetTypeInfo());
}

void CMemberInfoFunctions::SkipMissingSimpleMember(CObjectIStream& in,
                                                   const CMemberInfo* memberInfo)
{
    _ASSERT(!memberInfo->Optional());
    in.ExpectedMember(memberInfo);
}

void CMemberInfoFunctions::SkipMissingOptionalMember(CObjectIStream& /*in*/,
                                                     const CMemberInfo* _DEBUG_ARG(memberInfo))
{
    _ASSERT(memberInfo->Optional());
}

void CMemberInfoFunctions::ReadHookedMember(CObjectIStream& stream,
                                            const CMemberInfo* memberInfo,
                                            TObjectPtr classPtr)
{
    CReadClassMemberHook* hook =
        memberInfo->m_ReadHookData.GetHook(stream.m_ClassMemberHookKey);
    if ( !hook ) {
        hook = memberInfo->m_ReadHookData.GetPathHook(stream);
    }
    if ( hook ) {
        CObjectInfo object(classPtr, memberInfo->GetClassType());
        TMemberIndex index = memberInfo->GetIndex();
        CObjectInfo::CMemberIterator member(object, index);
        _ASSERT(member.Valid());
        if (memberInfo->HaveSetFlag()) {
            memberInfo->UpdateSetFlagYes(classPtr);
        }
        hook->ReadClassMember(stream, member);
    }
    else
        memberInfo->DefaultReadMember(stream, classPtr);
}

void CMemberInfoFunctions::ReadMissingHookedMember(CObjectIStream& stream,
                                                   const CMemberInfo* memberInfo,
                                                   TObjectPtr classPtr)
{
    CReadClassMemberHook* hook =
        memberInfo->m_ReadHookData.GetHook(stream.m_ClassMemberHookKey);
    if ( !hook ) {
        hook = memberInfo->m_ReadHookData.GetPathHook(stream);
    }
    if ( hook ) {