objostrasnb.cpp

ncbi源码

            // full length
            length = sizeof(data);
        }
    }
    out.WriteShortLength(length);
    WriteBytesOf(out, data, length);
}

void CObjectOStreamAsnBinary::WriteBool(bool data)
{
    WriteSysTag(eBoolean);
    WriteShortLength(1);
    WriteByte(data);
}

void CObjectOStreamAsnBinary::WriteChar(char data)
{
    WriteSysTag(eGeneralString);
    WriteShortLength(1);
    WriteByte(data);
}

void CObjectOStreamAsnBinary::WriteInt4(Int4 data)
{
    WriteSysTag(eInteger);
    WriteNumberValue(*this, data);
}

void CObjectOStreamAsnBinary::WriteUint4(Uint4 data)
{
    WriteSysTag(eInteger);
    WriteNumberValue(*this, data);
}

void CObjectOStreamAsnBinary::WriteInt8(Int8 data)
{
    WriteSysTag(eInteger);
    WriteNumberValue(*this, data);
}

void CObjectOStreamAsnBinary::WriteUint8(Uint8 data)
{
    WriteSysTag(eInteger);
    WriteNumberValue(*this, data);
}

static const size_t kMaxDoubleLength = 64;

void CObjectOStreamAsnBinary::WriteDouble2(double data, size_t digits)
{
    if (isnan(data)) {
        ThrowError(fInvalidData, "invalid double: not a number");
    }
    if (!finite(data)) {
        ThrowError(fInvalidData, "invalid double: infinite");
    }
    int shift = int(ceil(log10(fabs(data))));
    int precision = int(digits - shift);
    if ( precision < 0 )
        precision = 0;
    else if ( size_t(precision) > kMaxDoubleLength ) // limit precision of data
        precision = int(kMaxDoubleLength);

    // ensure buffer is large enough to fit result
    // (additional bytes are for sign, dot and exponent)
    char buffer[kMaxDoubleLength + 16];
    int width = sprintf(buffer, "%.*g", precision, data);
    if ( width <= 0 || width >= int(sizeof(buffer) - 1) )
        ThrowError(fOverflow, "buffer overflow");
    _ASSERT(strlen(buffer) == size_t(width));

    WriteSysTag(eReal);
    WriteLength(width + 1);
    WriteByte(eDecimal);
    WriteBytes(buffer, width);
}

void CObjectOStreamAsnBinary::WriteDouble(double data)
{
    WriteDouble2(data, DBL_DIG);
}

void CObjectOStreamAsnBinary::WriteFloat(float data)
{
    WriteDouble2(data, FLT_DIG);
}

void CObjectOStreamAsnBinary::WriteString(const string& str, EStringType type)
{
    size_t length = str.size();
    WriteSysTag(eVisibleString);
    WriteLength(length);
    if ( type == eStringTypeVisible && m_FixMethod != eFNP_Allow ) {
        size_t done = 0;
        for ( size_t i = 0; i < length; ++i ) {
            char c = str[i];
            if ( !GoodVisibleChar(c) ) {
                if ( i > done ) {
                    WriteBytes(str.data() + done, i - done);
                }
                FixVisibleChar(c, m_FixMethod);
                WriteByte(c);
                done = i + 1;
            }
        }
        if ( done < length ) {
            WriteBytes(str.data() + done, length - done);
        }
    }
    else {
        WriteBytes(str.data(), length);
    }
}

void CObjectOStreamAsnBinary::WriteStringStore(const string& str)
{
    WriteShortTag(eApplication, false, eStringStore);
    size_t length = str.size();
    WriteLength(length);
    WriteBytes(str.data(), length);
}

void CObjectOStreamAsnBinary::CopyStringValue(CObjectIStreamAsnBinary& in,
                                              bool checkVisible)
{
    size_t length = in.ReadLength();
    WriteLength(length);
    while ( length > 0 ) {
        char buffer[1024];
        size_t c = min(length, sizeof(buffer));
        in.ReadBytes(buffer, c);
        if ( checkVisible ) {
            // Check the string for non-printable characters
            for (size_t i = 0; i < c; i++) {
                FixVisibleChar(buffer[i], m_FixMethod);
            }
        }
        WriteBytes(buffer, c);
        length -= c;
    }
    in.EndOfTag();
}

void CObjectOStreamAsnBinary::CopyString(CObjectIStream& in)
{
    WriteSysTag(eVisibleString);
    if ( in.GetDataFormat() == eSerial_AsnBinary ) {
        CObjectIStreamAsnBinary& bIn =
            *CTypeConverter<CObjectIStreamAsnBinary>::SafeCast(&in);
        bIn.ExpectSysTag(eVisibleString);
        CopyStringValue(bIn, true);
    }
    else {
        string str;
        in.ReadStd(str);
        size_t length = str.size();
        if ( m_FixMethod != eFNP_Allow ) {
            // Check the string for non-printable characters
            NON_CONST_ITERATE(string, i, str) {
                FixVisibleChar(*i, m_FixMethod);
            }
        }
        WriteLength(length);
        WriteBytes(str.data(), length);
    }
}

void CObjectOStreamAsnBinary::CopyStringStore(CObjectIStream& in)
{
    WriteShortTag(eApplication, false, eStringStore);
    if ( in.GetDataFormat() == eSerial_AsnBinary ) {
        CObjectIStreamAsnBinary& bIn =
            *CTypeConverter<CObjectIStreamAsnBinary>::SafeCast(&in);
        bIn.ExpectSysTag(eApplication, false, eStringStore);
        CopyStringValue(bIn);
    }
    else {
        string str;
        in.ReadStringStore(str);
        size_t length = str.size();
        WriteLength(length);
        WriteBytes(str.data(), length);
    }
}

void CObjectOStreamAsnBinary::WriteCString(const char* str)
{
    if ( str == 0 ) {
        WriteSysTag(eNull);
        WriteShortLength(0);
    }
    else {
        size_t length = strlen(str);
        WriteSysTag(eVisibleString);
        WriteLength(length);
        if ( m_FixMethod != eFNP_Allow ) {
            size_t done = 0;
            for ( size_t i = 0; i < length; ++i ) {
                char c = str[i];
                if ( !GoodVisibleChar(c) ) {
                    if ( i > done ) {
                        WriteBytes(str + done, i - done);
                    }
                    FixVisibleChar(c, m_FixMethod);
                    WriteByte(c);
                    done = i + 1;
                }
            }
            if ( done < length ) {
                WriteBytes(str + done, length - done);
            }
        }
        else {
            WriteBytes(str, length);
        }
    }
}

void CObjectOStreamAsnBinary::WriteEnum(const CEnumeratedTypeValues& values,
                                        TEnumValueType value)
{
    if ( values.IsInteger() ) {
        WriteSysTag(eInteger);
    }
    else {
        values.FindName(value, false); // check value
        WriteSysTag(eEnumerated);
    }
    WriteNumberValue(*this, value);
}

void CObjectOStreamAsnBinary::CopyEnum(const CEnumeratedTypeValues& values,
                                       CObjectIStream& in)
{
    TEnumValueType value = in.ReadEnum(values);
    if ( values.IsInteger() )
        WriteSysTag(eInteger);
    else
        WriteSysTag(eEnumerated);
    WriteNumberValue(*this, value);
}

void CObjectOStreamAsnBinary::WriteObjectReference(TObjectIndex index)
{
    WriteTag(eApplication, false, eObjectReference);
    if ( sizeof(TObjectIndex) == sizeof(Int4) )
        WriteNumberValue(*this, Int4(index));
    else if ( sizeof(TObjectIndex) == sizeof(Int8) )
        WriteNumberValue(*this, Int8(index));
    else
        ThrowError(fIllegalCall, "invalid size of TObjectIndex"
            "must be either sizeof(Int4) or sizeof(Int4)");
}

void CObjectOStreamAsnBinary::WriteNullPointer(void)
{
    WriteSysTag(eNull);
    WriteShortLength(0);
}

void CObjectOStreamAsnBinary::WriteOtherBegin(TTypeInfo typeInfo)
{
    WriteClassTag(typeInfo);
    WriteIndefiniteLength();
}

void CObjectOStreamAsnBinary::WriteOtherEnd(TTypeInfo /*typeInfo*/)
{
    WriteEndOfContent();
}

void CObjectOStreamAsnBinary::WriteOther(TConstObjectPtr object,
                                         TTypeInfo typeInfo)
{
    WriteClassTag(typeInfo);
    WriteIndefiniteLength();
    WriteObject(object, typeInfo);
    WriteEndOfContent();
}

void CObjectOStreamAsnBinary::BeginContainer(const CContainerTypeInfo* containerType)
{
    if ( containerType->RandomElementsOrder() )
        WriteShortTag(eUniversal, true, eSet);
    else
        WriteShortTag(eUniversal, true, eSequence);
    WriteIndefiniteLength();
}

void CObjectOStreamAsnBinary::EndContainer(void)
{
    WriteEndOfContent();
}

#ifdef VIRTUAL_MID_LEVEL_IO
void CObjectOStreamAsnBinary::WriteContainer(const CContainerTypeInfo* cType,
                                             TConstObjectPtr containerPtr)
{
    if ( cType->RandomElementsOrder() )
        WriteShortTag(eUniversal, true, eSet);
    else
        WriteShortTag(eUniversal, true, eSequence);
    WriteIndefiniteLength();
    
    CContainerTypeInfo::CConstIterator i;
    if ( cType->InitIterator(i, containerPtr) ) {
        TTypeInfo elementType = cType->GetElementType();
        BEGIN_OBJECT_FRAME2(eFrameArrayElement, elementType);

        do {
            if (elementType->GetTypeFamily() == eTypeFamilyPointer) {
                const CPointerTypeInfo* pointerType =
                    CTypeConverter<CPointerTypeInfo>::SafeCast(elementType);
                _ASSERT(pointerType->GetObjectPointer(cType->GetElementPtr(i)));
                if ( !pointerType->GetObjectPointer(cType->GetElementPtr(i)) ) {
                    ERR_POST(Warning << " NULL pointer found in container: skipping");
                    continue;
                }
            }
            WriteObject(cType->GetElementPtr(i), elementType);

        } while ( cType->NextElement(i) );

        END_OBJECT_FRAME();
    }

    WriteEndOfContent();
}

void CObjectOStreamAsnBinary::CopyContainer(const CContainerTypeInfo* cType,
                                            CObjectStreamCopier& copier)
{
    BEGIN_OBJECT_FRAME_OF2(copier.In(), eFrameArray, cType);
    copier.In().BeginContainer(cType);

    if ( cType->RandomElementsOrder() )
        WriteShortTag(eUniversal, true, eSet);
    else
        WriteShortTag(eUniversal, true, eSequence);
    WriteIndefiniteLength();

    TTypeInfo elementType = cType->GetElementType();
    BEGIN_OBJECT_2FRAMES_OF2(copier, eFrameArrayElement, elementType);

    while ( copier.In().BeginContainerElement(elementType) ) {

        CopyObject(elementType, copier);

        copier.In().EndContainerElement();
    }

    END_OBJECT_2FRAMES_OF(copier);
    
    WriteEndOfContent();

    copier.In().EndContainer();
    END_OBJECT_FRAME_OF(copier.In());
}

#endif

void CObjectOStreamAsnBinary::BeginClass(const CClassTypeInfo* classType)
{
    if ( classType->RandomOrder() )
        WriteShortTag(eUniversal, true, eSet);
    else
        WriteShortTag(eUniversal, true, eSequence);
    WriteIndefiniteLength();
}

void CObjectOStreamAsnBinary::EndClass(void)
{
    WriteEndOfContent();
}

void CObjectOStreamAsnBinary::BeginClassMember(const CMemberId& id)
{
    WriteTag(eContextSpecific, true, id.GetTag());
    WriteIndefiniteLength();
}

void CObjectOStreamAsnBinary::EndClassMember(void)
{
    WriteEndOfContent();
}

#ifdef VIRTUAL_MID_LEVEL_IO
void CObjectOStreamAsnBinary::WriteClass(const CClassTypeInfo* classType,
                                         TConstObjectPtr classPtr)
{
    if ( classType->RandomOrder() )
        WriteShortTag(eUniversal, true, eSet);
    else
        WriteShortTag(eUniversal, true, eSequence);
    WriteIndefiniteLength();
    
    for ( CClassTypeInfo::CIterator i(classType); i.Valid(); ++i ) {
        classType->GetMemberInfo(i)->WriteMember(*this, classPtr);
    }
    
    WriteEndOfContent();
}

void CObjectOStreamAsnBinary::WriteClassMember(const CMemberId& memberId,
                                               TTypeInfo memberType,
                                               TConstObjectPtr memberPtr)
{
    BEGIN_OBJECT_FRAME2(eFrameClassMember, memberId);
    WriteTag(eContextSpecific, true, memberId.GetTag());
    WriteIndefiniteLength();
    
    WriteObject(memberPtr, memberType);
    
    WriteEndOfContent();
    END_OBJECT_FRAME();
}

bool CObjectOStreamAsnBinary::WriteClassMember(const CMemberId& memberId,
                                               const CDelayBuffer& buffer)
{
    if ( !buffer.HaveFormat(eSerial_AsnBinary) )
        return false;

    BEGIN_OBJECT_FRAME2(eFrameClassMember, memberId);
    WriteTag(eContextSpecific, true, memberId.GetTag());
    WriteIndefiniteLength();
    
    Write(buffer.GetSource());
    
    WriteEndOfContent();
    END_OBJECT_FRAME();

    return true;
}

void CObjectOStreamAsnBinary::CopyClassRandom(const CClassTypeInfo* classType,
                                              CObjectStreamCopier& copier)
{
    BEGIN_OBJECT_FRAME_OF2(copier.In(), eFrameClass, classType);
    copier.In().BeginClass(classType);

    if ( classType->RandomOrder() )
        WriteShortTag(eUniversal, true, eSet);
    else
        WriteShortTag(eUniversal, true, eSequence);
    WriteIndefiniteLength();

    vector<bool> read(classType->GetMembers().LastIndex() + 1);

    BEGIN_OBJECT_2FRAMES_OF(copier, eFrameClassMember);

    TMemberIndex index;
    while ( (index = copier.In().BeginClassMember(classType)) !=
            kInvalidMember ) {
        const CMemberInfo* memberInfo = classType->GetMemberInfo(index);
        copier.In().SetTopMemberId(memberInfo->GetId());
        SetTopMemberId(memberInfo->GetId());

        if ( read[index] ) {
            copier.DuplicatedMember(memberInfo);
        }
        else {
            read[index] = true;

            WriteTag(eContextSpecific, true, memberInfo->GetId().GetTag());
            WriteIndefiniteLength();

            memberInfo->CopyMember(copier);

            WriteEndOfContent();
        }
        
        copier.In().EndClassMember();
    }

    END_OBJECT_2FRAMES_OF(copier);

    // init all absent members
    for ( CClassTypeInfo::CIterator i(classType); i.Valid(); ++i ) {
        if ( !read[*i] ) {
            classType->GetMemberInfo(i)->CopyMissingMember(copier);
        }
    }

    WriteEndOfContent();

    copier.In().EndClass();
    END_OBJECT_FRAME_OF(copier.In());
}

void CObjectOStreamAsnBinary::CopyClassSequential(const CClassTypeInfo* classType,
                                                  CObjectStreamCopier& copier)
{
    BEGIN_OBJECT_FRAME_OF2(copier.In(), eFrameClass, classType);
    copier.In().BeginClass(classType);