objistrasnb.cpp

ncbi源码

{
    ExpectEndOfContent();
}

bool CObjectIStreamAsnBinary::BeginContainerElement(TTypeInfo /*elementType*/)
{
    return HaveMoreElements();
}

#ifdef VIRTUAL_MID_LEVEL_IO
void CObjectIStreamAsnBinary::ReadContainer(const CContainerTypeInfo* cType,
                                            TObjectPtr containerPtr)
{
    if ( cType->RandomElementsOrder() )
        ExpectSysTag(eUniversal, true, eSet);
    else
        ExpectSysTag(eUniversal, true, eSequence);
    ExpectIndefiniteLength();

    BEGIN_OBJECT_FRAME(eFrameArrayElement);

    CContainerTypeInfo::CIterator iter;
    bool old_element = cType->InitIterator(iter, containerPtr);
    TTypeInfo elementType = cType->GetElementType();
    while ( HaveMoreElements() ) {
        if ( old_element ) {
            elementType->ReadData(*this, cType->GetElementPtr(iter));
            old_element = cType->NextElement(iter);
        }
        else {
            cType->AddElement(containerPtr, *this);
        }
    }
    if ( old_element ) {
        cType->EraseAllElements(iter);
    }

    END_OBJECT_FRAME();

    ExpectEndOfContent();
}

void CObjectIStreamAsnBinary::SkipContainer(const CContainerTypeInfo* cType)
{
    if ( cType->RandomElementsOrder() )
        ExpectSysTag(eUniversal, true, eSet);
    else
        ExpectSysTag(eUniversal, true, eSequence);
    ExpectIndefiniteLength();

    TTypeInfo elementType = cType->GetElementType();
    BEGIN_OBJECT_FRAME(eFrameArrayElement);

    while ( HaveMoreElements() ) {
        SkipObject(elementType);
    }

    END_OBJECT_FRAME();

    ExpectEndOfContent();
}
#endif

void CObjectIStreamAsnBinary::BeginClass(const CClassTypeInfo* classInfo)
{
    if ( classInfo->RandomOrder() )
        ExpectSysTag(eUniversal, true, eSet);
    else
        ExpectSysTag(eUniversal, true, eSequence);
    ExpectIndefiniteLength();
}

void CObjectIStreamAsnBinary::EndClass(void)
{
    ExpectEndOfContent();
}

void CObjectIStreamAsnBinary::UnexpectedMember(TTag tag)
{
    ThrowError(fFormatError,
               "unexpected member: ["+NStr::IntToString(tag)+"]");
}

TMemberIndex
CObjectIStreamAsnBinary::BeginClassMember(const CClassTypeInfo* classType)
{
    if ( !HaveMoreElements() )
        return kInvalidMember;

    TTag tag = PeekTag(eContextSpecific, true);
    ExpectIndefiniteLength();
    TMemberIndex index = classType->GetMembers().Find(tag);
    if ( index == kInvalidMember )
        if (GetSkipUnknownMembers() == eSerialSkipUnknown_Yes) {
            ReadAnyContent();
            ExpectEndOfContent();
            return BeginClassMember(classType);
        } else {
            UnexpectedMember(tag);
        }
    return index;
}

TMemberIndex
CObjectIStreamAsnBinary::BeginClassMember(const CClassTypeInfo* classType,
                                          TMemberIndex pos)
{
    if ( !HaveMoreElements() )
        return kInvalidMember;

    TTag tag = PeekTag(eContextSpecific, true);
    ExpectIndefiniteLength();
    TMemberIndex index = classType->GetMembers().Find(tag, pos);
    if ( index == kInvalidMember )
        if (GetSkipUnknownMembers() == eSerialSkipUnknown_Yes) {
            ReadAnyContent();
            ExpectEndOfContent();
            return BeginClassMember(classType, pos);
        } else {
            UnexpectedMember(tag);
        }
    return index;
}

void CObjectIStreamAsnBinary::EndClassMember(void)
{
    ExpectEndOfContent();
}

#ifdef VIRTUAL_MID_LEVEL_IO
void CObjectIStreamAsnBinary::ReadClassRandom(const CClassTypeInfo* classType,
                                              TObjectPtr classPtr)
{
    BeginClass(classType);

    ReadClassRandomContentsBegin(classType);

    TMemberIndex index;
    while ( (index = BeginClassMember(classType)) != kInvalidMember ) {
        ReadClassRandomContentsMember(classPtr);
        EndClassMember();
    }

    ReadClassRandomContentsEnd();

    EndClass();
}

void CObjectIStreamAsnBinary::ReadClassSequential(const CClassTypeInfo* classType,
                                                  TObjectPtr classPtr)
{
    BeginClass(classType);
    ReadClassSequentialContentsBegin(classType);

    TMemberIndex index;
    while ( (index = BeginClassMember(classType,*pos)) != kInvalidMember ) {
        ReadClassSequentialContentsMember(classPtr);
        EndClassMember();
    }

    ReadClassSequentialContentsEnd(classPtr);
    EndClass();
}

void CObjectIStreamAsnBinary::SkipClassRandom(const CClassTypeInfo* classType)
{
    BeginClass(classType);
    SkipClassRandomContentsBegin(classType);

    TMemberIndex index;
    while ( (index = BeginClassMember(classType)) != kInvalidMember ) {
        SkipClassRandomContentsMember();
        EndClassMember();
    }

    SkipClassRandomContentsEnd();
    EndClass();
}

void CObjectIStreamAsnBinary::SkipClassSequential(const CClassTypeInfo* classType)
{
    BeginClass(classType);
    SkipClassSequentialContentsBegin(classType);

    TMemberIndex index;
    while ( (index = BeginClassMember(classType,*pos)) != kInvalidMember ) {
        SkipClassSequentialContentsMember();
        EndClassMember();
    }

    SkipClassSequentialContentsEnd();
    EndClass();
}
#endif

TMemberIndex CObjectIStreamAsnBinary::BeginChoiceVariant(const CChoiceTypeInfo* choiceType)
{
    TTag tag = PeekTag(eContextSpecific, true);
    ExpectIndefiniteLength();
    TMemberIndex index = choiceType->GetVariants().Find(tag);
    if ( index == kInvalidMember )
        UnexpectedMember(tag);
    return index;
}

void CObjectIStreamAsnBinary::EndChoiceVariant(void)
{
    ExpectEndOfContent();
}

#ifdef VIRTUAL_MID_LEVEL_IO
void CObjectIStreamAsnBinary::ReadChoice(const CChoiceTypeInfo* choiceType,
                                         TObjectPtr choicePtr)
{
    TMemberIndex index = BeginChoiceVariant(choiceType);

    const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
    BEGIN_OBJECT_FRAME2(eFrameChoiceVariant, variantInfo->GetId());

    variantInfo->ReadVariant(*this, choicePtr);

    END_OBJECT_FRAME();

    EndChoiceVariant();
}

void CObjectIStreamAsnBinary::SkipChoice(const CChoiceTypeInfo* choiceType)
{
    TMemberIndex index = BeginChoiceVariant(choiceType);

    const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
    BEGIN_OBJECT_FRAME2(eFrameChoiceVariant, variantInfo->GetId());

    variantInfo->SkipVariant(*this);

    END_OBJECT_FRAME();

    EndChoiceVariant();
}
#endif

void CObjectIStreamAsnBinary::BeginBytes(ByteBlock& block)
{
    ExpectSysTag(eOctetString);
    block.SetLength(ReadLength());
}

size_t CObjectIStreamAsnBinary::ReadBytes(ByteBlock& ,
                                          char* dst, size_t length)
{
    ReadBytes(dst, length);
    return length;
}

void CObjectIStreamAsnBinary::EndBytes(const ByteBlock& )
{
    EndOfTag();
}

void CObjectIStreamAsnBinary::BeginChars(CharBlock& block)
{
    ExpectSysTag(eVisibleString);
    block.SetLength(ReadLength());
}

size_t CObjectIStreamAsnBinary::ReadChars(CharBlock& ,
                                          char* dst, size_t length)
{
    ReadBytes(dst, length);
    return length;
}

void CObjectIStreamAsnBinary::EndChars(const CharBlock& )
{
    EndOfTag();
}

void CObjectIStreamAsnBinary::ReadNull(void)
{
    ExpectSysTag(eNull);
    ExpectShortLength(0);
    EndOfTag();
}

bool CObjectIStreamAsnBinary::ReadAnyContent()
{
    Uint1 byte = PeekAnyTag();
    if (ExtractConstructed(byte) && PeekIndefiniteLength()) {
        ExpectIndefiniteLength();
        if (ReadAnyContent()) {
            while (HaveMoreElements()) {
                ReadAnyContent();
            }
            ExpectEndOfContent();
        }
        return true;
    }
    size_t length = ReadLength();
    if (length) {
        SkipBytes(length);
    }
    EndOfTag();
    return (length != 0);
}

void CObjectIStreamAsnBinary::ReadAnyContentObject(CAnyContentObject& )
{
    NCBI_THROW(CSerialException,eNotImplemented,
        "CObjectIStreamAsnBinary::ReadAnyContentObject: "
        "unable to read AnyContent object in ASN binary");
}

void CObjectIStreamAsnBinary::SkipAnyContentObject(void)
{
    NCBI_THROW(CSerialException,eNotImplemented,
        "CObjectIStreamAsnBinary::SkipAnyContentObject: "
        "unable to skip AnyContent object in ASN binary");
}

CObjectIStream::EPointerType CObjectIStreamAsnBinary::ReadPointerType(void)
{
    Uint1 byte = PeekTagByte();
    // variants:
    //    eUniversal,   !constructed, eNull             -> NULL
    //    eApplication,  constructed, eMemberReference  -> member reference
    //    eApplication,  constructed, eLongTag          -> other class
    //    eApplication, !constructed, eObjectReference  -> object reference
    // any other -> this class
    if ( byte == eEndOfContentsByte ) {
        ExpectShortLength(0);
        EndOfTag();
        return eNullPointer;
    }
    else if ( byte == MakeTagByte(eApplication, true, eLongTag) ) {
        return eOtherPointer;
    }
    else if ( byte == MakeTagByte(eApplication, false, eObjectReference) ) {
        return eObjectPointer;
    }
    // by default: try this class
    return eThisPointer;
}

TEnumValueType CObjectIStreamAsnBinary::ReadEnum(const CEnumeratedTypeValues& values)
{
    TEnumValueType value;
    if ( values.IsInteger() ) {
        // allow any integer
        ExpectSysTag(eInteger);
        ReadStdSigned(*this, value);
    }
    else {
        // enum element by value
        ExpectSysTag(eEnumerated);
        ReadStdSigned(*this, value);
        values.FindName(value, false); // check value
    }
    return value;
}

CObjectIStream::TObjectIndex CObjectIStreamAsnBinary::ReadObjectPointer(void)
{
    TObjectIndex data;
    ReadStdSigned(*this, data);
    return data;
}

string CObjectIStreamAsnBinary::ReadOtherPointer(void)
{
    string className = PeekClassTag();
    ExpectIndefiniteLength();
    return className;
}

void CObjectIStreamAsnBinary::ReadOtherPointerEnd(void)
{
    ExpectEndOfContent();
}

bool CObjectIStreamAsnBinary::SkipRealValue(void)
{
    if ( PeekTagByte() == 0 && PeekTagByte(1) == 0 )
        return false;
    Uint1 byte = PeekAnyTag();
    if ( ExtractConstructed(byte) ) {
        // constructed
        ExpectIndefiniteLength();
        while ( SkipRealValue() )
            ;
        ExpectEndOfContent();
    }
    else {
        SkipTagData();
    }
    return true;
}


void CObjectIStreamAsnBinary::SkipBool(void)
{
    ExpectSysTag(eBoolean);
    ExpectShortLength(1);
    ReadByte();
    EndOfTag();
}

void CObjectIStreamAsnBinary::SkipChar(void)
{
    ExpectSysTag(eGeneralString);
    ExpectShortLength(1);
    ReadByte();
    EndOfTag();
}

void CObjectIStreamAsnBinary::SkipSNumber(void)
{
    ExpectSysTag(eInteger);
    SkipTagData();
}

void CObjectIStreamAsnBinary::SkipUNumber(void)
{
    ExpectSysTag(eInteger);
    SkipTagData();
}

void CObjectIStreamAsnBinary::SkipFNumber(void)
{
    ExpectSysTag(eReal);
    size_t length = ReadLength();
    if ( length < 2 )
        ThrowError(fFormatError, "too short REAL data: length < 2");
    if ( length > kMaxDoubleLength )
        ThrowError(fFormatError, "too long REAL data: length > "
            + NStr::UIntToString(kMaxDoubleLength));

    ExpectByte(eDecimal);
    length--;
    SkipBytes(length);
    EndOfTag();
}

void CObjectIStreamAsnBinary::SkipString(EStringType /*type*/)
{
    ExpectSysTag(eVisibleString);
    SkipTagData();
}

void CObjectIStreamAsnBinary::SkipStringStore(void)
{
    ExpectSysTag(eApplication, false, eStringStore);
    SkipTagData();
}

void CObjectIStreamAsnBinary::SkipNull(void)
{
    ExpectSysTag(eNull);
    ExpectShortLength(0);
    EndOfTag();
}

void CObjectIStreamAsnBinary::SkipByteBlock(void)
{
    ExpectSysTag(eOctetString);
    SkipTagData();
}

void CObjectIStreamAsnBinary::SkipTagData(void)
{
    SkipBytes(ReadLength());
    EndOfTag();
}

END_NCBI_SCOPE