variant.cpp

ncbi源码

        variantPtr = CTypeConverter<TConstObjectPtr>::Get(variantPtr);
        _ASSERT(variantPtr != 0 );
        if ( variantInfo->IsObjectPointer() ) {
            out.WriteExternalObject(variantPtr, variantInfo->GetTypeInfo());
            return;
        }
    }
    out.WriteObject(variantPtr, variantInfo->GetTypeInfo());
}

void CVariantInfoFunctions::CopyNonObjectVariant(CObjectStreamCopier& copier,
                                                 const CVariantInfo* variantInfo)
{
    _ASSERT(variantInfo->IsNotObject());
    copier.CopyObject(variantInfo->GetTypeInfo());
}

void CVariantInfoFunctions::CopyObjectPointerVariant(CObjectStreamCopier& copier,
                                                     const CVariantInfo* variantInfo)
{
    _ASSERT(variantInfo->IsObjectPointer());
    copier.CopyExternalObject(variantInfo->GetTypeInfo());
}

void CVariantInfoFunctions::SkipNonObjectVariant(CObjectIStream& in,
                                                 const CVariantInfo* variantInfo)
{
    _ASSERT(variantInfo->IsNotObject());
    in.SkipObject(variantInfo->GetTypeInfo());
}

void CVariantInfoFunctions::SkipObjectPointerVariant(CObjectIStream& in,
                                                     const CVariantInfo* variantInfo)
{
    _ASSERT(variantInfo->IsObjectPointer());
    in.SkipExternalObject(variantInfo->GetTypeInfo());
}

void CVariantInfoFunctions::ReadHookedVariant(CObjectIStream& stream,
                                              const CVariantInfo* variantInfo,
                                              TObjectPtr choicePtr)
{
    CReadChoiceVariantHook* hook =
        variantInfo->m_ReadHookData.GetHook(stream.m_ChoiceVariantHookKey);
    if (!hook) {
        hook = variantInfo->m_ReadHookData.GetPathHook(stream);
    }
    if ( hook ) {
        CObjectInfo choice(choicePtr, variantInfo->GetChoiceType());
        TMemberIndex index = variantInfo->GetIndex();
        CObjectInfo::CChoiceVariant variant(choice, index);
        _ASSERT(variant.Valid());
        hook->ReadChoiceVariant(stream, variant);
    }
    else
        variantInfo->DefaultReadVariant(stream, choicePtr);
}

void CVariantInfoFunctions::WriteHookedVariant(CObjectOStream& stream,
                                               const CVariantInfo* variantInfo,
                                               TConstObjectPtr choicePtr)
{
    CWriteChoiceVariantHook* hook =
        variantInfo->m_WriteHookData.GetHook(stream.m_ChoiceVariantHookKey);
    if (!hook) {
        hook = variantInfo->m_WriteHookData.GetPathHook(stream);
    }
    if ( hook ) {
        CConstObjectInfo choice(choicePtr, variantInfo->GetChoiceType());
        TMemberIndex index = variantInfo->GetIndex();
        CConstObjectInfo::CChoiceVariant variant(choice, index);
        _ASSERT(variant.Valid());
        hook->WriteChoiceVariant(stream, variant);
    }
    else
        variantInfo->DefaultWriteVariant(stream, choicePtr);
}

void CVariantInfoFunctions::SkipHookedVariant(CObjectIStream& stream,
                                              const CVariantInfo* variantInfo)
{
    CSkipChoiceVariantHook* hook =
        variantInfo->m_SkipHookData.GetHook(stream.m_ChoiceVariantSkipHookKey);
    if (!hook) {
        hook = variantInfo->m_SkipHookData.GetPathHook(stream);
    }
    if ( hook ) {
        CObjectTypeInfo type(variantInfo->GetChoiceType());
        TMemberIndex index = variantInfo->GetIndex();
        CObjectTypeInfo::CChoiceVariant variant(type, index);
        _ASSERT(variant.Valid());
        hook->SkipChoiceVariant(stream, variant);
    }
    else
        variantInfo->DefaultSkipVariant(stream);
}

void CVariantInfoFunctions::CopyHookedVariant(CObjectStreamCopier& stream,
                                              const CVariantInfo* variantInfo)
{
    CCopyChoiceVariantHook* hook =
        variantInfo->m_CopyHookData.GetHook(stream.m_ChoiceVariantHookKey);
    if (!hook) {
        hook = variantInfo->m_CopyHookData.GetPathHook(stream.In());
    }
    if ( hook ) {
        CObjectTypeInfo type(variantInfo->GetChoiceType());
        TMemberIndex index = variantInfo->GetIndex();
        CObjectTypeInfo::CChoiceVariant variant(type, index);
        _ASSERT(variant.Valid());
        hook->CopyChoiceVariant(stream, variant);
    }
    else
        variantInfo->DefaultCopyVariant(stream);
}

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

void CVariantInfo::SetLocalReadHook(CObjectIStream& stream,
                                    CReadChoiceVariantHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_ReadHookData.SetLocalHook(stream.m_ChoiceVariantHookKey, hook);
}

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

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

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

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

void CVariantInfo::SetLocalWriteHook(CObjectOStream& stream,
                                     CWriteChoiceVariantHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_WriteHookData.SetLocalHook(stream.m_ChoiceVariantHookKey, hook);
}

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

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

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

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

void CVariantInfo::SetLocalSkipHook(CObjectIStream& stream,
                                    CSkipChoiceVariantHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_SkipHookData.SetLocalHook(stream.m_ChoiceVariantSkipHookKey, hook);
}

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

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

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

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

void CVariantInfo::SetLocalCopyHook(CObjectStreamCopier& stream,
                                    CCopyChoiceVariantHook* hook)
{
    CMutexGuard guard(GetTypeInfoMutex());
    m_CopyHookData.SetLocalHook(stream.m_ChoiceVariantHookKey, hook);
}

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

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

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

END_NCBI_SCOPE

/*
* ===========================================================================
* $Log: variant.cpp,v $
* Revision 1000.2  2004/06/01 19:42:08  gouriano
* PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.14
*
* Revision 1.14  2004/05/17 21:03:04  gorelenk
* Added include of PCH ncbi_pch.hpp
*
* Revision 1.13  2004/01/05 14:25:23  gouriano
* Added possibility to set serialization hooks by stack path
*
* Revision 1.12  2003/07/29 18:47:48  vasilche
* Fixed thread safeness of object stream hooks.
*
* Revision 1.11  2003/03/10 18:54:26  gouriano
* use new structured exceptions (based on CException)
*
* Revision 1.10  2002/09/09 18:14:02  grichenk
* Added CObjectHookGuard class.
* Added methods to be used by hooks for data
* reading and skipping.
*
* Revision 1.9  2001/05/17 15:07:09  lavr
* Typos corrected
*
* Revision 1.8  2000/10/20 15:51:44  vasilche
* Fixed data error processing.
* Added interface for constructing container objects directly into output stream.
* object.hpp, object.inl and object.cpp were split to
* objectinfo.*, objecttype.*, objectiter.* and objectio.*.
*
* Revision 1.7  2000/10/17 18:45:36  vasilche
* Added possibility to turn off object cross reference detection in
* CObjectIStream and CObjectOStream.
*
* Revision 1.6  2000/10/13 20:22:57  vasilche
* Fixed warnings on 64 bit compilers.
* Fixed missing typename in templates.
*
* Revision 1.5  2000/10/03 17:22:45  vasilche
* Reduced header dependency.
* Reduced size of debug libraries on WorkShop by 3 times.
* Fixed tag allocation for parent classes.
* Fixed CObject allocation/deallocation in streams.
* Moved instantiation of several templates in separate source file.
*
* Revision 1.4  2000/09/29 16:18:25  vasilche
* Fixed binary format encoding/decoding on 64 bit compulers.
* Implemented CWeakMap<> for automatic cleaning map entries.
* Added cleaning local hooks via CWeakMap<>.
* Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
* Added some user interface methods to CObjectIStream, CObjectOStream and
* CObjectStreamCopier.
*
* Revision 1.3  2000/09/26 19:24:58  vasilche
* Added user interface for setting read/write/copy hooks.
*
* Revision 1.2  2000/09/26 17:38:23  vasilche
* Fixed incomplete choiceptr implementation.
* Removed temporary comments.
*
* Revision 1.1  2000/09/18 20:00:26  vasilche
* Separated CVariantInfo and CMemberInfo.
* Implemented copy hooks.
* All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
* Most type specific functions now are implemented via function pointers instead of virtual functions.
*
* ===========================================================================
*/