objistrxml.cpp

ncbi源码

{
    CLightString attr;
    while (HasAttlist()) {
        attr = ReadAttributeName();
        if ( attr == "value" ) {    
            break;
        }
        string value;
        ReadAttributeValue(value);
    }
    if ( attr != "value" ) {
        EndOpeningTagSelfClosed();
        ThrowError(fMissingValue,"attribute 'value' is missing");
    }
    string sValue;
    ReadAttributeValue(sValue);
    bool value;
    if ( sValue == "true" )
        value = true;
    else {
        if ( sValue != "false" ) {
            ThrowError(fFormatError,
                       "'true' or 'false' attrubute value expected: "+sValue);
        }
        value = false;
    }
    if ( !EndOpeningTagSelfClosed() && !NextTagIsClosing() )
        ThrowError(fFormatError, "boolean tag must have empty contents");
    return value;
}

char CObjectIStreamXml::ReadChar(void)
{
    BeginData();
    int c = ReadEscapedChar('<');
    if ( c < 0 || m_Input.PeekChar() != '<' )
        ThrowError(fFormatError, "one char tag content expected");
    return c;
}

Int4 CObjectIStreamXml::ReadInt4(void)
{
    BeginData();
    return m_Input.GetInt4();
}

Uint4 CObjectIStreamXml::ReadUint4(void)
{
    BeginData();
    return m_Input.GetUint4();
}

Int8 CObjectIStreamXml::ReadInt8(void)
{
    BeginData();
    return m_Input.GetInt8();
}

Uint8 CObjectIStreamXml::ReadUint8(void)
{
    BeginData();
    return m_Input.GetUint8();
}

double CObjectIStreamXml::ReadDouble(void)
{
    string s;
    ReadTagData(s);
    char* endptr;
    double data = strtod(s.c_str(), &endptr);
    if ( *endptr != 0 )
        ThrowError(fFormatError, "invalid float number");
    return data;
}

void CObjectIStreamXml::ReadNull(void)
{
    if ( !EndOpeningTagSelfClosed() && !NextTagIsClosing() )
        ThrowError(fFormatError, "empty tag expected");
}

void CObjectIStreamXml::ReadAnyContentTo(
    const string& ns_prefix, string& value, const CLightString& tagName)
{
    if (ThisTagIsSelfClosed()) {
        EndSelfClosedTag();
        return;
    }
    while (!NextTagIsClosing()) {
        while (NextIsTag()) {
            CLightString tagAny;
            tagAny = ReadName(BeginOpeningTag());
            value += '<';
            value += tagAny;
            while (HasAttlist()) {
                string attribName = ReadName(SkipWS());
                if (attribName.empty()) {
                    break;
                }
                if (m_CurrNsPrefix.empty() || m_CurrNsPrefix == ns_prefix) {
                    value += " ";
                    value += attribName;
                    value += "=\"";
                    string attribValue;
                    ReadAttributeValue(attribValue, true);
                    value += attribValue;
                    value += "\"";
                } else {
                    // skip attrib from different namespaces
                    string attribValue;
                    ReadAttributeValue(attribValue, true);
                }
            }
            string value2;
            ReadAnyContentTo(ns_prefix, value2,tagAny);
            if (value2.empty()) {
                value += "/>";
            } else {
                value += '>';
                value += value2;
                value += "</";
                value += tagAny;
                value += '>';
            }
        }
        string data;
        ReadTagData(data);
        value += data;
    }
    CloseTag(tagName);
}

void CObjectIStreamXml::ReadAnyContentObject(CAnyContentObject& obj)
{
    BEGIN_OBJECT_FRAME(eFrameOther);
    CLightString tagName;
    if (m_RejectedTag.empty()) {
        tagName = ReadName(BeginOpeningTag());
    } else {
        tagName = RejectedName();
    }
    obj.SetName( tagName);
    string ns_prefix(m_CurrNsPrefix);
    while (HasAttlist()) {
        string attribName = ReadName(SkipWS());
        if (attribName.empty()) {
            break;
        }
        string value;
        ReadAttributeValue(value, true);
        obj.AddAttribute( attribName, m_NsPrefixToName[m_CurrNsPrefix],value);
    }
    obj.SetNamespacePrefix(ns_prefix);
    obj.SetNamespaceName(m_NsPrefixToName[ns_prefix]);
    string value;
    ReadAnyContentTo(ns_prefix,value,tagName);
    obj.SetValue(value);
    END_OBJECT_FRAME();
}

void CObjectIStreamXml::SkipAnyContentObject(void)
{
    CAnyContentObject obj;
    ReadAnyContentObject(obj);
}

void CObjectIStreamXml::ReadString(string& str, EStringType type)
{
    str.erase();
    if ( !EndOpeningTagSelfClosed() ) {
        EEncoding enc = m_Encoding;
        if (type == eStringTypeUTF8) {
            if (m_Encoding == eEncoding_UTF8 || m_Encoding == eEncoding_Unknown) {
                m_Encoding = eEncoding_ISO8859_1;
            } else {
                string tmp;
                ReadTagData(tmp);
                (static_cast<CStringUTF8&>(str)) = tmp;
                return;
            }
        }
        ReadTagData(str);
        m_Encoding = enc;
    }
}

char* CObjectIStreamXml::ReadCString(void)
{
    if ( EndOpeningTagSelfClosed() ) {
        // null pointer string
        return 0;
    }
    string str;
    ReadTagData(str);
    return strdup(str.c_str());
}

void CObjectIStreamXml::ReadTagData(string& str)
{
    BeginData();
    bool skip_spaces = false;
    bool encoded = false;
    for ( ;; ) {
        int c = ReadEscapedChar(m_Attlist ? '\"' : '<', &encoded);
        if ( c < 0 ) {
            break;
        }
        if (!encoded) {
            if (c == '\n' || c == '\r') {
                skip_spaces = true;
                continue;
            }
            if (skip_spaces) {
                if (IsWhiteSpace(c)) {
                    continue;
                } else {
                    skip_spaces = false;
                    str += ' ';
                }
            }
        }
        str += char(c);
        // pre-allocate memory for long strings
        if ( str.size() > 128  &&  double(str.capacity())/(str.size()+1.0) < 1.1 ) {
            str.reserve(str.size()*2);
        }
    }
    str.reserve(str.size());
}

TEnumValueType CObjectIStreamXml::ReadEnum(const CEnumeratedTypeValues& values)
{
    const string& enumName = values.GetName();
    if ( !enumName.empty() ) {
        // global enum
        OpenTag(enumName);
        _ASSERT(InsideOpeningTag());
    }
    TEnumValueType value;
    if ( InsideOpeningTag() ) {
        // try to read attribute 'value'
        if ( IsEndOfTagChar( SkipWS()) ) {
            // no attribute
            if ( !values.IsInteger() )
                ThrowError(fFormatError, "attribute 'value' expected");
            m_Input.SkipChar();
            Found_gt();
            BeginData();
            value = m_Input.GetInt4();
        }
        else {
            if (m_Attlist) {
                string valueName;
                ReadAttributeValue(valueName);
                value = values.FindValue(valueName);
            } else {
                CLightString attr;
                while (HasAttlist()) {
                    attr = ReadAttributeName();
                    if ( attr == "value" ) {    
                        break;
                    }
                    string value;
                    ReadAttributeValue(value);
                }
                if ( attr != "value" ) {
                    EndOpeningTagSelfClosed();
                    ThrowError(fMissingValue,"attribute 'value' is missing");
                }
                string valueName;
                ReadAttributeValue(valueName);
                value = values.FindValue(valueName);
                if ( !EndOpeningTagSelfClosed() && values.IsInteger() ) {
                    // read integer value
                    SkipWSAndComments();
                    if ( value != m_Input.GetInt4() )
                        ThrowError(fFormatError,
                                   "incompatible name and value of enum");
                }
            }
        }
    }
    else {
        // outside of tag
        if ( !values.IsInteger() )
            ThrowError(fFormatError, "attribute 'value' expected");
        BeginData();
        value = m_Input.GetInt4();
    }
    if ( !enumName.empty() ) {
        // global enum
        CloseTag(enumName);
    }
    return value;
}

CObjectIStream::EPointerType CObjectIStreamXml::ReadPointerType(void)
{
    if ( !HasAttlist() && InsideOpeningTag() && EndOpeningTagSelfClosed() ) {
        // self closed tag
        return eNullPointer;
    }
    return eThisPointer;
}

CObjectIStreamXml::TObjectIndex CObjectIStreamXml::ReadObjectPointer(void)
{
    ThrowError(fIllegalCall, "unimplemented");
    return 0;
/*
    CLightString attr = ReadAttributeName();
    if ( attr != "index" )
        ThrowError(fIllegalCall, "attribute 'index' expected");
    string index;
    ReadAttributeValue(index);
    EndOpeningTagSelfClosed();
    return NStr::StringToInt(index);
*/
}

string CObjectIStreamXml::ReadOtherPointer(void)
{
    ThrowError(fIllegalCall, "unimplemented");
    return NcbiEmptyString;
}

CLightString CObjectIStreamXml::SkipTagName(CLightString tag,
                                            const char* str, size_t length)
{
    if ( tag.GetLength() < length ||
         memcmp(tag.GetString(), str, length) != 0 )
        ThrowError(fFormatError, "invalid tag name: "+string(tag));
    return CLightString(tag.GetString() + length, tag.GetLength() - length);
}

CLightString CObjectIStreamXml::SkipStackTagName(CLightString tag,
                                                 size_t level)
{
    const TFrame& frame = FetchFrameFromTop(level);
    switch ( frame.GetFrameType() ) {
    case TFrame::eFrameNamed:
    case TFrame::eFrameArray:
    case TFrame::eFrameClass:
    case TFrame::eFrameChoice:
        {
            const string& name = frame.GetTypeInfo()->GetName();
            if ( !name.empty() )
                return SkipTagName(tag, name);
            else
                return SkipStackTagName(tag, level + 1);
        }
    case TFrame::eFrameClassMember:
    case TFrame::eFrameChoiceVariant:
        {
            tag = SkipStackTagName(tag, level + 1, '_');
            return SkipTagName(tag, frame.GetMemberId().GetName());
        }
    case TFrame::eFrameArrayElement:
        {
            tag = SkipStackTagName(tag, level + 1);
            return SkipTagName(tag, "_E");
        }
    default:
        break;
    }
    ThrowError(fIllegalCall, "illegal frame type");
    return tag;
}

CLightString CObjectIStreamXml::SkipStackTagName(CLightString tag,
                                                 size_t level, char c)
{
    tag = SkipStackTagName(tag, level);
    if ( tag.Empty() || *tag.GetString() != c )
        ThrowError(fFormatError, "invalid tag name: "+string(tag));
    return CLightString(tag.GetString() + 1, tag.GetLength() - 1);
}

void CObjectIStreamXml::OpenTag(const string& e)
{
    CLightString tagName;
    if (m_RejectedTag.empty()) {
        tagName = ReadName(BeginOpeningTag());
    } else {
        tagName = RejectedName();
    }
    if ( tagName != e )
        ThrowError(fFormatError, "tag '"+e+"' expected: "+string(tagName));
}

void CObjectIStreamXml::CloseTag(const string& e)
{
    if ( SelfClosedTag() ) {
        EndSelfClosedTag();
    }
    else {
        CLightString tagName = ReadName(BeginClosingTag());
        if ( tagName != e )
            ThrowError(fFormatError, "tag '"+e+"' expected: "+string(tagName));
        EndClosingTag();
    }
}

void CObjectIStreamXml::OpenStackTag(size_t level)
{
    CLightString tagName;
    if (m_RejectedTag.empty()) {
        tagName = ReadName(BeginOpeningTag());
        if (!x_IsStdXml()) {
            CLightString rest = SkipStackTagName(tagName, level);
            if ( !rest.Empty() )
                ThrowError(fFormatError,
                    "unexpected tag: "+string(tagName)+string(rest));
        }
    } else {
        tagName = RejectedName();
    }
}

void CObjectIStreamXml::CloseStackTag(size_t level)
{
    if ( SelfClosedTag() ) {
        EndSelfClosedTag();
    }
    else {
        if (m_Attlist) {
            m_TagState = eTagInsideClosing;
        } else {
            CLightString tagName = ReadName(BeginClosingTag());
            if (!x_IsStdXml()) {
                CLightString rest = SkipStackTagName(tagName, level);
                if ( !rest.Empty() )
                    ThrowError(fFormatError,
                        "unexpected tag: "+string(tagName)+string(rest));
            }
        }
        EndClosingTag();
    }
}

void CObjectIStreamXml::OpenTagIfNamed(TTypeInfo type)
{
    if ( !type->GetName().empty() ) {
        OpenTag(type->GetName());
    }
}

void CObjectIStreamXml::CloseTagIfNamed(TTypeInfo type)
{
    if ( !type->GetName().empty() )