member.cpp

ncbi源码

    m_Optional = true;
    m_Default = def;
    UpdateFunctions();
    return this;
}

CMemberInfo* CMemberInfo::SetSetFlag(const bool* setFlag)
{
    _ASSERT(Optional());
    m_SetFlagOffset = TPointerOffsetType(setFlag);
    m_BitSetFlag = false;
    UpdateFunctions();
    return this;
}

CMemberInfo* CMemberInfo::SetSetFlag(const Uint4* setFlag)
{
    m_SetFlagOffset = TPointerOffsetType(setFlag);
    m_BitSetFlag = true;
    UpdateFunctions();
    return this;
}

bool CMemberInfo::CompareSetFlags(TConstObjectPtr object1,
                                  TConstObjectPtr object2) const
{
    return GetSetFlagNo(object1) == GetSetFlagNo(object2);
}

CMemberInfo* CMemberInfo::SetOptional(const bool* setFlag)
{
    m_Optional = true;
    return SetSetFlag(setFlag);
}

void CMemberInfo::UpdateFunctions(void)
{
    // determine function pointers
    TMemberGetConst getConstFunc;
    TMemberGet getFunc;
    SMemberReadFunctions readFuncs;
    TMemberWriteFunction writeFunc;
    SMemberSkipFunctions skipFuncs;
    SMemberCopyFunctions copyFuncs;

    // get/readmain/write
    if ( CanBeDelayed() ) {
        getConstFunc = &TFunc::GetConstDelayedMember;
        getFunc = &TFunc::GetDelayedMember;
        readFuncs.m_Main = &TFunc::ReadLongMember;
        writeFunc = &TFunc::WriteLongMember;
    }
    else if ( !HaveSetFlag() ) {
        getConstFunc = &TFunc::GetConstSimpleMember;
        getFunc = &TFunc::GetSimpleMember;
        readFuncs.m_Main = &TFunc::ReadSimpleMember;

        if ( GetDefault() )
            writeFunc = &TFunc::WriteWithDefaultMember;
        else if ( Optional() )
            writeFunc = &TFunc::WriteOptionalMember;
        else
            writeFunc = &TFunc::WriteSimpleMember;
    }
    else {
        // have set flag
        getConstFunc = &TFunc::GetConstSimpleMember;
        getFunc = &TFunc::GetWithSetFlagMember;
        readFuncs.m_Main = &TFunc::ReadWithSetFlagMember;
        writeFunc = &TFunc::WriteWithSetFlagMember;
    }

    // copymain/skipmain
    copyFuncs.m_Main = &TFunc::CopySimpleMember;
    skipFuncs.m_Main = &TFunc::SkipSimpleMember;

    // readmissing/copymissing/skipmissing
    if ( Optional() ) {
        if ( HaveSetFlag() ) {
            readFuncs.m_Missing = &TFunc::ReadMissingWithSetFlagMember;
        }
        else {
            readFuncs.m_Missing = &TFunc::ReadMissingOptionalMember;
        }
        copyFuncs.m_Missing = &TFunc::CopyMissingOptionalMember;
        skipFuncs.m_Missing = &TFunc::SkipMissingOptionalMember;
    }
    else {
        readFuncs.m_Missing = &TFunc::ReadMissingSimpleMember;
        copyFuncs.m_Missing = &TFunc::CopyMissingSimpleMember;
        skipFuncs.m_Missing = &TFunc::SkipMissingSimpleMember;
    }

    // update function pointers
    m_GetConstFunction = getConstFunc;
    m_GetFunction = getFunc;
    m_ReadHookData.SetDefaultFunction(readFuncs);
    m_WriteHookData.SetDefaultFunction(writeFunc);
    m_SkipHookData.SetDefaultFunction(skipFuncs);
    m_CopyHookData.SetDefaultFunction(copyFuncs);
}

void CMemberInfo::UpdateDelayedBuffer(CObjectIStream& in,
                                      TObjectPtr classPtr) const
{
    _ASSERT(CanBeDelayed());
    _ASSERT(GetDelayBuffer(classPtr).GetIndex() == GetIndex());

    GetTypeInfo()->ReadData(in, GetItemPtr(classPtr));
}

void CMemberInfo::SetReadFunction(TMemberReadFunction func)
{
    SMemberReadFunctions funcs = m_ReadHookData.GetDefaultFunction();
    funcs.m_Main = func;
    m_ReadHookData.SetDefaultFunction(funcs);
}

void CMemberInfo::SetReadMissingFunction(TMemberReadFunction func)
{
    SMemberReadFunctions funcs = m_ReadHookData.GetDefaultFunction();
    funcs.m_Missing = func;
    m_ReadHookData.SetDefaultFunction(funcs);
}

void CMemberInfo::SetWriteFunction(TMemberWriteFunction func)
{
    m_WriteHookData.SetDefaultFunction(func);
}

void CMemberInfo::SetSkipFunction(TMemberSkipFunction func)
{
    SMemberSkipFunctions funcs = m_SkipHookData.GetDefaultFunction();
    funcs.m_Main = func;
    m_SkipHookData.SetDefaultFunction(funcs);
}

void CMemberInfo::SetSkipMissingFunction(TMemberSkipFunction func)
{
    SMemberSkipFunctions funcs = m_SkipHookData.GetDefaultFunction();
    funcs.m_Missing = func;
    m_SkipHookData.SetDefaultFunction(funcs);
}

void CMemberInfo::SetCopyFunction(TMemberCopyFunction func)
{
    SMemberCopyFunctions funcs = m_CopyHookData.GetDefaultFunction();
    funcs.m_Main = func;
    m_CopyHookData.SetDefaultFunction(funcs);
}

void CMemberInfo::SetCopyMissingFunction(TMemberCopyFunction func)
{
    SMemberCopyFunctions funcs = m_CopyHookData.GetDefaultFunction();
    funcs.m_Missing = func;
    m_CopyHookData.SetDefaultFunction(funcs);
}

void CMemberInfo::SetGlobalReadHook(CReadClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_ReadHookData.SetGlobalHook(hook);
}

void CMemberInfo::SetLocalReadHook(CObjectIStream& stream,
                                   CReadClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_ReadHookData.SetLocalHook(stream.m_ClassMemberHookKey, hook);
}

void CMemberInfo::ResetGlobalReadHook(void)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_ReadHookData.ResetGlobalHook();
}

void CMemberInfo::ResetLocalReadHook(CObjectIStream& stream)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_ReadHookData.ResetLocalHook(stream.m_ClassMemberHookKey);
}

void CMemberInfo::SetPathReadHook(CObjectIStream* in, const string& path,
                                  CReadClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_ReadHookData.SetPathHook(in,path,hook);
}

void CMemberInfo::SetGlobalWriteHook(CWriteClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_WriteHookData.SetGlobalHook(hook);
}

void CMemberInfo::SetLocalWriteHook(CObjectOStream& stream,
                                    CWriteClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_WriteHookData.SetLocalHook(stream.m_ClassMemberHookKey, hook);
}

void CMemberInfo::ResetGlobalWriteHook(void)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_WriteHookData.ResetGlobalHook();
}

void CMemberInfo::ResetLocalWriteHook(CObjectOStream& stream)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_WriteHookData.ResetLocalHook(stream.m_ClassMemberHookKey);
}

void CMemberInfo::SetPathWriteHook(CObjectOStream* out, const string& path,
                                   CWriteClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_WriteHookData.SetPathHook(out,path,hook);
}

void CMemberInfo::SetGlobalSkipHook(CSkipClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_SkipHookData.SetGlobalHook(hook);
}

void CMemberInfo::SetLocalSkipHook(CObjectIStream& stream,
                                   CSkipClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_SkipHookData.SetLocalHook(stream.m_ClassMemberSkipHookKey, hook);
}

void CMemberInfo::ResetGlobalSkipHook(void)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_SkipHookData.ResetGlobalHook();
}

void CMemberInfo::ResetLocalSkipHook(CObjectIStream& stream)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_SkipHookData.ResetLocalHook(stream.m_ClassMemberSkipHookKey);
}

void CMemberInfo::SetPathSkipHook(CObjectIStream* in, const string& path,
                                  CSkipClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_SkipHookData.SetPathHook(in,path,hook);
}

void CMemberInfo::SetGlobalCopyHook(CCopyClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_CopyHookData.SetGlobalHook(hook);
}

void CMemberInfo::SetLocalCopyHook(CObjectStreamCopier& stream,
                                   CCopyClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_CopyHookData.SetLocalHook(stream.m_ClassMemberHookKey, hook);
}

void CMemberInfo::ResetGlobalCopyHook(void)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_CopyHookData.ResetGlobalHook();
}

void CMemberInfo::ResetLocalCopyHook(CObjectStreamCopier& stream)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_CopyHookData.ResetLocalHook(stream.m_ClassMemberHookKey);
}

void CMemberInfo::SetPathCopyHook(CObjectStreamCopier* stream, const string& path,
                                  CCopyClassMemberHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_CopyHookData.SetPathHook(stream ? &(stream->In()) : 0,path,hook);
}

TObjectPtr CMemberInfo::CreateClass(void) const
{
    return GetClassType()->Create();
}

TConstObjectPtr
CMemberInfoFunctions::GetConstSimpleMember(const CMemberInfo* memberInfo,
                                           TConstObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    return memberInfo->GetItemPtr(classPtr);
}

TConstObjectPtr
CMemberInfoFunctions::GetConstDelayedMember(const CMemberInfo* memberInfo,
                                            TConstObjectPtr classPtr)
{
    _ASSERT(memberInfo->CanBeDelayed());
    const_cast<CDelayBuffer&>(memberInfo->GetDelayBuffer(classPtr)).Update();
    return memberInfo->GetItemPtr(classPtr);
}

TObjectPtr CMemberInfoFunctions::GetSimpleMember(const CMemberInfo* memberInfo,
                                                 TObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(!memberInfo->HaveSetFlag());
    return memberInfo->GetItemPtr(classPtr);
}

TObjectPtr CMemberInfoFunctions::GetWithSetFlagMember(const CMemberInfo* memberInfo,
                                                      TObjectPtr classPtr)
{
    _ASSERT(!memberInfo->CanBeDelayed());
    _ASSERT(memberInfo->HaveSetFlag());
    return memberInfo->GetItemPtr(classPtr);