asntypes.cpp

ncbi源码

    typedef CContainerTypeInfo::CConstIterator TIterator; 

    static const CSequenceOfTypeInfo* GetType(const TIterator& iter)
        {
            return CTypeConverter<CSequenceOfTypeInfo>::SafeCast(iter.GetContainerType());
        }
    static bool InitIterator(TIterator& iter)
        {
            TObjectPtr nodePtr =
                GetType(iter)->FirstNode(iter.GetContainerPtr());
            iter.m_IteratorData = nodePtr;
            return nodePtr != 0;
        }
    static void ReleaseIterator(TIterator& )
        {
        }
    static void CopyIterator(TIterator& dst,
                             const TIterator& src)
        {
            dst.m_IteratorData = src.m_IteratorData;
        }
    static bool NextElement(TIterator& iter)
        {
            TObjectPtr nodePtr = GetType(iter)->NextNode(iter.m_IteratorData);
            iter.m_IteratorData = nodePtr;
            return nodePtr != 0;
        }
    static TConstObjectPtr GetElementPtr(const TIterator& iter)
        {
            return GetType(iter)->Data(iter.m_IteratorData);
        }
};

class CSequenceOfTypeInfoFunctionsI
{
public:
    typedef CContainerTypeInfo::CIterator TIterator; 

    static const CSequenceOfTypeInfo* GetType(const TIterator& iter)
        {
            return CTypeConverter<CSequenceOfTypeInfo>::SafeCast(iter.GetContainerType());
        }
    static bool InitIterator(TIterator& iter)
        {
            TObjectPtr* nodePtrPtr =
                &GetType(iter)->FirstNode(iter.GetContainerPtr());
            iter.m_IteratorData = nodePtrPtr;
            return *nodePtrPtr != 0;
        }
    static void ReleaseIterator(TIterator& )
        {
        }
    static void CopyIterator(TIterator& dst, const TIterator& src)
        {
            dst.m_IteratorData = src.m_IteratorData;
        }
    static bool NextElement(TIterator& iter)
        {
            TObjectPtr* nodePtrPtr =
                &GetType(iter)->NextNode(*(TObjectPtr*)iter.m_IteratorData);
            iter.m_IteratorData = nodePtrPtr;
            return *nodePtrPtr != 0;
        }
    static TObjectPtr GetElementPtr(const TIterator& iter)
        {
            return GetType(iter)->Data(*(TObjectPtr*)iter.m_IteratorData);
        }
    static bool EraseElement(TIterator& iter)
        {
            const CSequenceOfTypeInfo* type = GetType(iter);

            TObjectPtr* nodePtrPtr = (TObjectPtr*)iter.m_IteratorData;
            TObjectPtr nodePtr = *nodePtrPtr;
            TObjectPtr nextNodePtr = type->NextNode(nodePtr);
            *nodePtrPtr = nextNodePtr;
            type->DeleteNode(nodePtr);
            return nextNodePtr != 0;
        }
    static void EraseAllElements(TIterator& iter)
        {
            const CSequenceOfTypeInfo* type = GetType(iter);

            TObjectPtr* nodePtrPtr = (TObjectPtr*)iter.m_IteratorData;
            TObjectPtr nodePtr = *nodePtrPtr;
            *nodePtrPtr = 0;
            while ( nodePtr ) {
                TObjectPtr nextNodePtr = type->NextNode(nodePtr);
                type->DeleteNode(nodePtr);
                nodePtr = nextNodePtr;
            }
        }
};

class CSequenceOfTypeInfoFunctions
{
public:
    static void ReadSequence(CObjectIStream& in,
                             TTypeInfo containerType,
                             TObjectPtr containerPtr)
        {
            const CSequenceOfTypeInfo* seqType =
                CTypeConverter<CSequenceOfTypeInfo>::SafeCast(containerType);

            BEGIN_OBJECT_FRAME_OF2(in, eFrameArray, seqType);
            in.BeginContainer(seqType);

            TTypeInfo elementType = seqType->GetElementType();
            BEGIN_OBJECT_FRAME_OF2(in, eFrameArrayElement, elementType);

            TObjectPtr* nextNodePtr = &seqType->FirstNode(containerPtr);

            while ( in.BeginContainerElement(elementType) ) {
                // get current node pointer
                TObjectPtr node = *nextNodePtr;
        
                // create node
                _ASSERT(!node);
                node = *nextNodePtr = seqType->CreateNode();

                // read node data
                in.ReadObject(seqType->Data(node), elementType);

                // save next node for next read
                nextNodePtr = &seqType->NextNode(node);
        
                in.EndContainerElement();
            }

            END_OBJECT_FRAME_OF(in);

            in.EndContainer();
            END_OBJECT_FRAME_OF(in);
        }
};

void CSequenceOfTypeInfo::InitSequenceOfTypeInfo(void)
{
    TTypeInfo type = GetElementType();
    const CAutoPointerTypeInfo* ptrInfo =
        dynamic_cast<const CAutoPointerTypeInfo*>(type);
    if ( ptrInfo != 0 ) {
        // data type is auto_ptr
        TTypeInfo asnType = ptrInfo->GetPointedType();
        if ( asnType->GetTypeFamily() == eTypeFamilyChoice ) {
            // CHOICE
            SetChoiceNext();
            m_ElementType = asnType;
        }
        else if ( asnType->GetTypeFamily() == eTypeFamilyClass ) {
            // user types
            const CClassTypeInfo* classType =
                CTypeConverter<CClassTypeInfo>::SafeCast(asnType);
            if ( GetFirstItemOffset(classType->GetItems()) < sizeof(void*) ) {
                CNcbiOstrstream msg;
                msg << "CSequenceOfTypeInfo: incompatible type: " <<
                    type->GetName() << ": " << typeid(*type).name() <<
                    " size: " << type->GetSize();
                NCBI_THROW(CSerialException,eInvalidData, CNcbiOstrstreamToString(msg));
            }
            m_NextOffset = 0;
            m_DataOffset = 0;
            m_ElementType = asnType;
        }
        else if ( asnType->GetSize() <= sizeof(dataval) ) {
            // standard types and SET/SEQUENCE OF
            SetValNodeNext();
            m_ElementType = asnType;
        }
        else {
/*
            _ASSERT(type->GetSize() <= sizeof(dataval));
            SetValNodeNext();
*/
            CNcbiOstrstream msg;
            msg << "CSequenceOfTypeInfo: incompatible type: " <<
                type->GetName() << ": " << typeid(*type).name() <<
                " size: " << type->GetSize();
            NCBI_THROW(CSerialException,eInvalidData, CNcbiOstrstreamToString(msg));
        }
    }
    else if ( type->GetSize() <= sizeof(dataval) ) {
        // SEQUENCE OF, SET OF or primitive types
        SetValNodeNext();
    }
    else {
        CNcbiOstrstream msg;
        msg << "CSequenceOfTypeInfo: incompatible type: " <<
            type->GetName() << ": " << typeid(*type).name() <<
            " size: " << type->GetSize();
        NCBI_THROW(CSerialException,eInvalidData, CNcbiOstrstreamToString(msg));
    }

    {
        typedef CSequenceOfTypeInfoFunctions TFunc;
        SetReadFunction(&TFunc::ReadSequence);
    }
    {
        typedef CSequenceOfTypeInfoFunctionsCI TFunc;
        SetConstIteratorFunctions(&TFunc::InitIterator, &TFunc::ReleaseIterator,
                                  &TFunc::CopyIterator, &TFunc::NextElement,
                                  &TFunc::GetElementPtr);
    }
    {
        typedef CSequenceOfTypeInfoFunctionsI TFunc;
        SetIteratorFunctions(&TFunc::InitIterator, &TFunc::ReleaseIterator,
                             &TFunc::CopyIterator, &TFunc::NextElement,
                             &TFunc::GetElementPtr,
                             &TFunc::EraseElement, &TFunc::EraseAllElements);
    }
}

void CSequenceOfTypeInfo::SetChoiceNext(void)
{
    m_NextOffset = offsetof(valnode, next);
    m_DataOffset = 0;
}

void CSequenceOfTypeInfo::SetValNodeNext(void)
{
    m_NextOffset = offsetof(valnode, next);
    m_DataOffset = offsetof(valnode, data);
}

TObjectPtr CSequenceOfTypeInfo::CreateNode(void) const
{
    if ( m_DataOffset == 0 ) {
        _ASSERT(m_NextOffset == 0 || m_NextOffset == offsetof(valnode, next));
        return GetElementType()->Create();
    }
    else {
        _ASSERT(m_NextOffset == offsetof(valnode, next));
        _ASSERT(m_DataOffset == offsetof(valnode, data));
        return Alloc(sizeof(valnode));
    }
}

void CSequenceOfTypeInfo::DeleteNode(TObjectPtr node) const
{
    if ( m_DataOffset == 0 ) {
        _ASSERT(m_NextOffset == 0 || m_NextOffset == offsetof(valnode, next));
        GetElementType()->Delete(node);
    }
    else {
        _ASSERT(m_NextOffset == offsetof(valnode, next));
        _ASSERT(m_DataOffset == offsetof(valnode, data));
        Free(node);
    }
}

bool CSequenceOfTypeInfo::IsDefault(TConstObjectPtr object) const
{
    return FirstNode(object) == 0;
}

void CSequenceOfTypeInfo::SetDefault(TObjectPtr dst) const
{
    FirstNode(dst) = 0;
}

void CSequenceOfTypeInfo::Assign(TObjectPtr dst, TConstObjectPtr src,
                                 ESerialRecursionMode how) const
{
    src = FirstNode(src);
    if ( src == 0 ) {
        FirstNode(dst) = 0;
        return;
    }

    TTypeInfo dataType = GetElementType();
    dst = FirstNode(dst) = CreateNode();
    dataType->Assign(Data(dst), Data(src), how);
    while ( (src = NextNode(src)) != 0 ) {
        dst = NextNode(dst) = CreateNode();
        dataType->Assign(Data(dst), Data(src), how);
    }
}

static CTypeInfoMap s_SetOfTypeInfo_map;

TTypeInfo CSetOfTypeInfo::GetTypeInfo(TTypeInfo base)
{
    return s_SetOfTypeInfo_map.GetTypeInfo(base, &CreateTypeInfo);
}

CTypeInfo* CSetOfTypeInfo::CreateTypeInfo(TTypeInfo base)
{
    return new CSetOfTypeInfo(base);
}

CSetOfTypeInfo::CSetOfTypeInfo(TTypeInfo type)
    : CParent(type, true)
{
}

CSetOfTypeInfo::CSetOfTypeInfo(const char* name, TTypeInfo type)
    : CParent(name, type, true)
{
}

CSetOfTypeInfo::CSetOfTypeInfo(const string& name, TTypeInfo type)
    : CParent(name, type, true)
{
}

COctetStringTypeInfo::COctetStringTypeInfo(void)
    : CParent(sizeof(TObjectType), ePrimitiveValueOctetString)
{
    SetReadFunction(&ReadOctetString);
    SetWriteFunction(&WriteOctetString);
    SetCopyFunction(&CopyOctetString);
    SetSkipFunction(&SkipOctetString);
}

bool COctetStringTypeInfo::IsDefault(TConstObjectPtr object) const
{
    return Get(object)->totlen == 0;
}

bool COctetStringTypeInfo::Equals(TConstObjectPtr obj1, TConstObjectPtr obj2,
                                  ESerialRecursionMode) const
{
    bytestore* bs1 = Get(obj1);
    bytestore* bs2 = Get(obj2);
    if ( bs1 == 0 || bs2 == 0 )
        return bs1 == bs2;

    Int4 len = BSLen(bs1);
    if ( len != BSLen(bs2) )
        return false;
    
    BSSeek(bs1, 0, SEEK_SET);
    BSSeek(bs2, 0, SEEK_SET);
    char buff1[1024], buff2[1024];
    while ( len > 0 ) {
        Int4 chunk = Int4(sizeof(buff1));
        if ( chunk > len )
            chunk = len;
        BSRead(bs1, buff1, chunk);
        BSRead(bs2, buff2, chunk);
        if ( memcmp(buff1, buff2, chunk) != 0 )
            return false;
        len -= chunk;
    }
    return true;
}

void COctetStringTypeInfo::SetDefault(TObjectPtr dst) const
{
    BSFree(Get(dst));
    Get(dst) = BSNew(0);
}

void COctetStringTypeInfo::Assign(TObjectPtr dst, TConstObjectPtr src,
                                  ESerialRecursionMode) const
{
    if ( Get(src) == 0 ) {
        NCBI_THROW(CSerialException,eInvalidData, "null bytestore pointer");
    }
    BSFree(Get(dst));
    Get(dst) = BSDup(Get(src));
}

void COctetStringTypeInfo::ReadOctetString(CObjectIStream& in,
                                           TTypeInfo /*objectType*/,
                                           TObjectPtr objectPtr)
{
    CObjectIStream::ByteBlock block(in);
    BSFree(Get(objectPtr));
    char buffer[1024];
    Int4 count = Int4(block.Read(buffer, sizeof(buffer)));
    bytestore* bs = Get(objectPtr) = BSNew(count);
    BSWrite(bs, buffer, count);
    while ( (count = Int4(block.Read(buffer, sizeof(buffer)))) != 0 ) {
        BSWrite(bs, buffer, count);
    }
    block.End();
}