member.cpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: member.cpp,v $
 * PRODUCTION Revision 1000.3  2004/06/01 19:40:26  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.38
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: member.cpp,v 1000.3 2004/06/01 19:40:26 gouriano Exp $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*               National Center for Biotechnology Information
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government have not placed any restriction on its use or reproduction.
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data, the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties, express or implied, including
*  warranties of performance, merchantability or fitness for any particular
*  purpose.
*
*  Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Eugene Vasilchenko
*
* File Description:
*   !!! PUT YOUR DESCRIPTION HERE !!!
*
* ===========================================================================
*/

#include <ncbi_pch.hpp>
#include <corelib/ncbistd.hpp>
#include <corelib/ncbimtx.hpp>

#include <serial/member.hpp>
#include <serial/objectinfo.hpp>
#include <serial/objectiter.hpp>
#include <serial/objistr.hpp>
#include <serial/objostr.hpp>
#include <serial/objcopy.hpp>
#include <serial/delaybuf.hpp>
#include <serial/serialimpl.hpp>
#ifdef _DEBUG
#include <serial/serialbase.hpp>
#endif
#include <memory>

BEGIN_NCBI_SCOPE

class CMemberInfoFunctions
{
public:
    static TConstObjectPtr GetConstSimpleMember(const CMemberInfo* memberInfo,
                                                TConstObjectPtr classPtr);
    static TConstObjectPtr GetConstDelayedMember(const CMemberInfo* memberInfo,
                                                 TConstObjectPtr classPtr);
    static TObjectPtr GetSimpleMember(const CMemberInfo* memberInfo,
                                      TObjectPtr classPtr);
    static TObjectPtr GetWithSetFlagMember(const CMemberInfo* memberInfo,
                                           TObjectPtr classPtr);
    static TObjectPtr GetDelayedMember(const CMemberInfo* memberInfo,
                                       TObjectPtr classPtr);
    

    static void ReadSimpleMember(CObjectIStream& in,
                                 const CMemberInfo* memberInfo,
                                 TObjectPtr classPtr);
    static void ReadWithSetFlagMember(CObjectIStream& in,
                                        const CMemberInfo* memberInfo,
                                        TObjectPtr classPtr);
    static void ReadLongMember(CObjectIStream& in,
                                 const CMemberInfo* memberInfo,
                                 TObjectPtr classPtr);
    static void ReadHookedMember(CObjectIStream& in,
                                 const CMemberInfo* memberInfo,
                                 TObjectPtr classPtr);
    static void ReadMissingSimpleMember(CObjectIStream& in,
                                        const CMemberInfo* memberInfo,
                                        TObjectPtr classPtr);
    static void ReadMissingWithSetFlagMember(CObjectIStream& in,
                                             const CMemberInfo* memberInfo,
                                             TObjectPtr classPtr);
    static void ReadMissingOptionalMember(CObjectIStream& in,
                                            const CMemberInfo* memberInfo,
                                            TObjectPtr classPtr);
    static void ReadMissingHookedMember(CObjectIStream& in,
                                        const CMemberInfo* memberInfo,
                                        TObjectPtr classPtr);
    static void WriteSimpleMember(CObjectOStream& out,
                                  const CMemberInfo* memberInfo,
                                  TConstObjectPtr classPtr);
    static void WriteOptionalMember(CObjectOStream& out,
                                      const CMemberInfo* memberInfo,
                                      TConstObjectPtr classPtr);
    static void WriteWithDefaultMember(CObjectOStream& out,
                                         const CMemberInfo* memberInfo,
                                         TConstObjectPtr classPtr);
    static void WriteWithSetFlagMember(CObjectOStream& out,
                                         const CMemberInfo* memberInfo,
                                         TConstObjectPtr classPtr);
    static void WriteLongMember(CObjectOStream& out,
                                  const CMemberInfo* memberInfo,
                                  TConstObjectPtr classPtr);
    static void WriteHookedMember(CObjectOStream& out,
                                  const CMemberInfo* memberInfo,
                                  TConstObjectPtr classPtr);
    static void SkipSimpleMember(CObjectIStream& in,
                                 const CMemberInfo* memberInfo);
    static void SkipMissingSimpleMember(CObjectIStream& in,
                                        const CMemberInfo* memberInfo);
    static void SkipMissingOptionalMember(CObjectIStream& in,
                                          const CMemberInfo* memberInfo);
    static void SkipHookedMember(CObjectIStream& in,
                                 const CMemberInfo* memberInfo);
    static void SkipMissingHookedMember(CObjectIStream& in,
                                        const CMemberInfo* memberInfo);
    static void CopySimpleMember(CObjectStreamCopier& copier,
                                 const CMemberInfo* memberInfo);
    static void CopyHookedMember(CObjectStreamCopier& copier,
                                 const CMemberInfo* memberInfo);
    static void CopyMissingSimpleMember(CObjectStreamCopier& copier,
                                        const CMemberInfo* memberInfo);
    static void CopyMissingOptionalMember(CObjectStreamCopier& copier,
                                            const CMemberInfo* memberInfo);
    static void CopyMissingHookedMember(CObjectStreamCopier& copier,
                                        const CMemberInfo* memberInfo);


    static void ReadParentClass(CObjectIStream& in,
                                const CMemberInfo* memberInfo,
                                TObjectPtr objectPtr);
    static void ReadMissingParentClass(CObjectIStream& in,
                                       const CMemberInfo* memberInfo,
                                       TObjectPtr objectPtr);
    static void WriteParentClass(CObjectOStream& out,
                                 const CMemberInfo* memberInfo,
                                 TConstObjectPtr objectPtr);
    static void CopyParentClass(CObjectStreamCopier& copier,
                                const CMemberInfo* memberInfo);
    static void CopyMissingParentClass(CObjectStreamCopier& copier,
                                       const CMemberInfo* memberInfo);
    static void SkipParentClass(CObjectIStream& in,
                                const CMemberInfo* memberInfo);
    static void SkipMissingParentClass(CObjectIStream& in,
                                       const CMemberInfo* memberInfo);
};

typedef CMemberInfoFunctions TFunc;

CMemberInfo::CMemberInfo(const CClassTypeInfoBase* classType,
                         const CMemberId& id, TPointerOffsetType offset,
                         const CTypeRef& type)
    : CParent(id, offset, type),
      m_ClassType(classType), m_Optional(false), m_NonEmpty(false), m_Default(0),
      m_SetFlagOffset(eNoOffset), m_BitSetFlag(false),
      m_DelayOffset(eNoOffset),
      m_GetConstFunction(&TFunc::GetConstSimpleMember),
      m_GetFunction(&TFunc::GetSimpleMember),
      m_ReadHookData(SMemberReadFunctions(&TFunc::ReadSimpleMember,
                                          &TFunc::ReadMissingSimpleMember),
                     SMemberReadFunctions(&TFunc::ReadHookedMember,
                                          &TFunc::ReadMissingHookedMember)),
      m_WriteHookData(&TFunc::WriteSimpleMember, &TFunc::WriteHookedMember),
      m_SkipHookData(SMemberSkipFunctions(&TFunc::SkipSimpleMember,
                                          &TFunc::SkipMissingSimpleMember),
                     SMemberSkipFunctions(&TFunc::SkipHookedMember,
                                          &TFunc::SkipMissingHookedMember)),
      m_CopyHookData(SMemberCopyFunctions(&TFunc::CopySimpleMember,
                                          &TFunc::CopyMissingSimpleMember),
                     SMemberCopyFunctions(&TFunc::CopyHookedMember,
                                          &TFunc::CopyMissingHookedMember))
{
}

CMemberInfo::CMemberInfo(const CClassTypeInfoBase* classType,
                         const CMemberId& id, TPointerOffsetType offset,
                         TTypeInfo type)
    : CParent(id, offset, type),
      m_ClassType(classType), m_Optional(false), m_NonEmpty(false), m_Default(0),
      m_SetFlagOffset(eNoOffset), m_BitSetFlag(false),
      m_DelayOffset(eNoOffset),
      m_GetConstFunction(&TFunc::GetConstSimpleMember),
      m_GetFunction(&TFunc::GetSimpleMember),
      m_ReadHookData(SMemberReadFunctions(&TFunc::ReadSimpleMember,
                                          &TFunc::ReadMissingSimpleMember),
                     SMemberReadFunctions(&TFunc::ReadHookedMember,
                                          &TFunc::ReadMissingHookedMember)),
      m_WriteHookData(&TFunc::WriteSimpleMember, &TFunc::WriteHookedMember),
      m_SkipHookData(SMemberSkipFunctions(&TFunc::SkipSimpleMember,
                                          &TFunc::SkipMissingSimpleMember),
                     SMemberSkipFunctions(&TFunc::SkipHookedMember,
                                          &TFunc::SkipMissingHookedMember)),
      m_CopyHookData(SMemberCopyFunctions(&TFunc::CopySimpleMember,
                                          &TFunc::CopyMissingSimpleMember),
                     SMemberCopyFunctions(&TFunc::CopyHookedMember,
                                          &TFunc::CopyMissingHookedMember))
{
}

CMemberInfo::CMemberInfo(const CClassTypeInfoBase* classType,
                         const char* id, TPointerOffsetType offset,
                         const CTypeRef& type)
    : CParent(id, offset, type),
      m_ClassType(classType), m_Optional(false), m_NonEmpty(false), m_Default(0),
      m_SetFlagOffset(eNoOffset), m_BitSetFlag(false),
      m_DelayOffset(eNoOffset),
      m_GetConstFunction(&TFunc::GetConstSimpleMember),
      m_GetFunction(&TFunc::GetSimpleMember),
      m_ReadHookData(SMemberReadFunctions(&TFunc::ReadSimpleMember,
                                          &TFunc::ReadMissingSimpleMember),
                     SMemberReadFunctions(&TFunc::ReadHookedMember,
                                          &TFunc::ReadMissingHookedMember)),
      m_WriteHookData(&TFunc::WriteSimpleMember, &TFunc::WriteHookedMember),
      m_SkipHookData(SMemberSkipFunctions(&TFunc::SkipSimpleMember,
                                          &TFunc::SkipMissingSimpleMember),
                     SMemberSkipFunctions(&TFunc::SkipHookedMember,
                                          &TFunc::SkipMissingHookedMember)),
      m_CopyHookData(SMemberCopyFunctions(&TFunc::CopySimpleMember,
                                          &TFunc::CopyMissingSimpleMember),
                     SMemberCopyFunctions(&TFunc::CopyHookedMember,
                                          &TFunc::CopyMissingHookedMember))
{
}

CMemberInfo::CMemberInfo(const CClassTypeInfoBase* classType,
                         const char* id, TPointerOffsetType offset,
                         TTypeInfo type)
    : CParent(id, offset, type),
      m_ClassType(classType), m_Optional(false), m_NonEmpty(false), m_Default(0),
      m_SetFlagOffset(eNoOffset), m_BitSetFlag(false),
      m_DelayOffset(eNoOffset),
      m_GetConstFunction(&TFunc::GetConstSimpleMember),
      m_GetFunction(&TFunc::GetSimpleMember),
      m_ReadHookData(SMemberReadFunctions(&TFunc::ReadSimpleMember,
                                          &TFunc::ReadMissingSimpleMember),
                     SMemberReadFunctions(&TFunc::ReadHookedMember,
                                          &TFunc::ReadMissingHookedMember)),
      m_WriteHookData(&TFunc::WriteSimpleMember, &TFunc::WriteHookedMember),
      m_SkipHookData(SMemberSkipFunctions(&TFunc::SkipSimpleMember,
                                          &TFunc::SkipMissingSimpleMember),
                     SMemberSkipFunctions(&TFunc::SkipHookedMember,
                                          &TFunc::SkipMissingHookedMember)),
      m_CopyHookData(SMemberCopyFunctions(&TFunc::CopySimpleMember,
                                          &TFunc::CopyMissingSimpleMember),
                     SMemberCopyFunctions(&TFunc::CopyHookedMember,
                                          &TFunc::CopyMissingHookedMember))
{
}

void CMemberInfo::SetParentClass(void)
{
    GetId().SetParentTag();
    m_ReadHookData.SetDefaultFunction(
        SMemberReadFunctions(&TFunc::ReadParentClass,
                             &TFunc::ReadMissingParentClass));
    m_WriteHookData.SetDefaultFunction(&TFunc::WriteParentClass);
    m_SkipHookData.SetDefaultFunction(
        SMemberSkipFunctions(&TFunc::SkipParentClass,
                             &TFunc::SkipMissingParentClass));
    m_CopyHookData.SetDefaultFunction(
        SMemberCopyFunctions(&TFunc::CopyParentClass,
                             &TFunc::CopyMissingParentClass));
}

CMemberInfo* CMemberInfo::SetDelayBuffer(CDelayBuffer* buffer)
{
    m_DelayOffset = TPointerOffsetType(buffer);
    UpdateFunctions();
    return this;
}

CMemberInfo* CMemberInfo::SetOptional(void)
{
    m_Optional = true;
    UpdateFunctions();
    return this;
}

CMemberInfo* CMemberInfo::SetNonEmpty(void)
{
    m_NonEmpty = true;
    return this;
}

CMemberInfo* CMemberInfo::SetNoPrefix(void)
{
    GetId().SetNoPrefix();
    return this;
}

CMemberInfo* CMemberInfo::SetAttlist(void)
{
    GetId().SetAttlist();
    return this;
}

CMemberInfo* CMemberInfo::SetNotag(void)
{
    GetId().SetNotag();
    return this;
}

CMemberInfo* CMemberInfo::SetAnyContent(void)
{
    GetId().SetAnyContent();
    return this;
}

CMemberInfo* CMemberInfo::SetDefault(TConstObjectPtr def)
{