test_serial.cpp

ncbi源码

        CTypeConstIterator<CTestSerialObject> m3 = ConstBegin(cwrite);

        CTypesIterator n1; n1 = Begin(write);
        CTypesConstIterator n2; n2 = ConstBegin(write);
        CTypesConstIterator n3; n3 = ConstBegin(cwrite);
        //CTypesConstIterator n4; n4 = Begin(cwrite);

        {
            for ( CTypeIterator<CTestSerialObject> oi = Begin(write); oi; ++oi ) {
                const CTestSerialObject& obj = *oi;
                NcbiCerr<<"CTestSerialObject @ "<<NStr::PtrToString(&obj)<<
                    NcbiEndl;
                //            oi.Erase();
                CTypeIterator<CTestSerialObject> oi1(Begin(write));
                CTypeIterator<CTestSerialObject> oi2;
                oi2 = Begin(write);
            }
        }
        {
            for ( CTypeConstIterator<CTestSerialObject> oi = ConstBegin(write); oi;
                  ++oi ) {
                const CTestSerialObject& obj = *oi;
                NcbiCerr<<"CTestSerialObject @ "<<NStr::PtrToString(&obj)<<
                    NcbiEndl;
                //            oi.Erase();
                CTypeConstIterator<CTestSerialObject> oi1(Begin(write));
                CTypeConstIterator<CTestSerialObject> oi2;
                oi2 = Begin(write);
            }
        }
        {
            for ( CTypeConstIterator<CTestSerialObject> oi = ConstBegin(cwrite);
                  oi; ++oi ) {
                const CTestSerialObject& obj = *oi;
                NcbiCerr<<"CTestSerialObject @ "<<NStr::PtrToString(&obj)<<
                    NcbiEndl;
                //oi.Erase();
                CTypeConstIterator<CTestSerialObject> oi1(ConstBegin(cwrite));
                CTypeConstIterator<CTestSerialObject> oi2;
                oi2 = ConstBegin(cwrite);
            }
        }

        {
            for ( CStdTypeConstIterator<string> si = ConstBegin(cwrite); si;
                  ++si ) {
                NcbiCerr <<"String: \""<<*si<<"\""<<NcbiEndl;
            }
        }

        {
            for ( CObjectConstIterator oi = ConstBegin(cwrite); oi; ++oi ) {
                const CObject& obj = *oi;
                NcbiCerr <<"CObject: @ "<<NStr::PtrToString(&obj)<<NcbiEndl;
            }
        }

        {
            CTypesIterator i;
            CType<CTestSerialObject>::AddTo(i);
            CType<CTestSerialObject2>::AddTo(i);
            for ( i = Begin(write); i; ++i ) {
                CTestSerialObject* obj = CType<CTestSerialObject>::Get(i);
                if ( obj ) {
                    NcbiCerr <<"CObject: @ "<<NStr::PtrToString(obj)<<NcbiEndl;
                }
                else {
                    NcbiCerr <<"CObject2: @ "<<
                        NStr::PtrToString(CType<CTestSerialObject2>::Get(i))<<
                        NcbiEndl;
                }
            }
        }

        {
            CTypesConstIterator i;
            CType<CTestSerialObject>::AddTo(i);
            CType<CTestSerialObject2>::AddTo(i);
            for ( i = ConstBegin(write); i; ++i ) {
                const CTestSerialObject* obj = CType<CTestSerialObject>::Get(i);
                if ( obj ) {
                    NcbiCerr <<"CObject: @ "<<NStr::PtrToString(obj)<<NcbiEndl;
                }
                else {
                    NcbiCerr <<"CObject2: @ "<<
                        NStr::PtrToString(CType<CTestSerialObject2>::Get(i))<<
                        NcbiEndl;
                }
            }
        }

        {
            {
                auto_ptr<CObjectOStream> out(CObjectOStream::Open("test_serial.asno",
                                                                  eSerial_AsnText));
                *out << write;
            }
            {
                CNcbiOfstream out("test_serial.asno2");
                PrintAsn(out, ConstObjectInfo(write));
            }
            CTestSerialObject read;
            {
                auto_ptr<CObjectIStream> in(CObjectIStream::Open("test_serial.asn",
                                                                 eSerial_AsnText));
                *in >> read;
            }
#if HAVE_NCBI_C
            // Some functions does not work with C-style objects.
            // Reset WebEnv for SerialEquals() to work.
            TWebEnv* saved_env_read = read.m_WebEnv;
            TWebEnv* saved_env_write = write.m_WebEnv;
            read.m_WebEnv = 0;
            write.m_WebEnv = 0;
#endif
            _ASSERT(SerialEquals<CTestSerialObject>(read, write));
#if HAVE_NCBI_C
            // Restore C-style objects
            read.m_WebEnv = saved_env_read;
            write.m_WebEnv = saved_env_write;
#endif
            read.Dump(NcbiCerr);
            read.m_Next->Dump(NcbiCerr);
#if !defined(HAVE_NCBI_C)
            {
                auto_ptr<CObjectIStream> in(CObjectIStream::Open("test_serial.asn",
                                                                 eSerial_AsnText));
                in->Skip(ObjectType(read));
            }
#endif
        }

        {
            {
                auto_ptr<CObjectOStream> out(CObjectOStream::Open("test_serial.asbo",
                                                                  eSerial_AsnBinary));
                *out << write;
            }
            CTestSerialObject read;
            {
                auto_ptr<CObjectIStream> in(CObjectIStream::Open("test_serial.asb",
                                                                 eSerial_AsnBinary));
                *in >> read;
            }
#if HAVE_NCBI_C
            // Some functions does not work with C-style objects.
            // Reset WebEnv for SerialEquals() to work.
            TWebEnv* saved_env_read = read.m_WebEnv;
            TWebEnv* saved_env_write = write.m_WebEnv;
            read.m_WebEnv = 0;
            write.m_WebEnv = 0;
#endif
            _ASSERT(SerialEquals<CTestSerialObject>(read, write));
#if HAVE_NCBI_C
            // Restore C-style objects
            read.m_WebEnv = saved_env_read;
            write.m_WebEnv = saved_env_write;
#endif
            read.Dump(NcbiCerr);
            read.m_Next->Dump(NcbiCerr);
#if !defined(HAVE_NCBI_C)
            {
                auto_ptr<CObjectIStream> in(CObjectIStream::Open("test_serial.asb",
                                                                 eSerial_AsnBinary));
                in->Skip(ObjectType(read));
            }
#endif
        }

        NcbiCerr << "OK" << endl;
    }
    catch (NCBI_NS_STD::exception& e) {
        ERR_POST(typeid(e).name() << ": " << e.what());
    }
    catch (...) {
        ERR_POST("Unknown error");
    }
    SetDiagStream(&NcbiCerr);
    return 0;
}

void PrintAsnValue(CNcbiOstream& out, const CConstObjectInfo& object);
static int asnIndentLevel;

void ResetAsnIndent(void)
{
    asnIndentLevel = 0;
}

void IncAsnIndent(void)
{
    asnIndentLevel++;
}

void DecAsnIndent(void)
{
    _ASSERT(asnIndentLevel > 0);
    asnIndentLevel--;
}

void PrintAsnIndent(CNcbiOstream& out)
{
    for ( int i = 0; i < asnIndentLevel; ++i )
        out << "  ";
}

void PrintAsn(CNcbiOstream& out, const CConstObjectInfo& object)
{
    _ASSERT(object);
    _ASSERT(!object.GetTypeInfo()->GetName().empty());
    ResetAsnIndent();
    out << object.GetTypeInfo()->GetName() << " ::= ";
    PrintAsnValue(out, object);
}

class AsnBlock
{
public:
    AsnBlock(CNcbiOstream& out)
        : m_Out(out), m_Empty(true)
        {
            out << "{\n";
            IncAsnIndent();
        }
    ~AsnBlock(void)
        {
            if ( !m_Empty )
                m_Out << '\n';
            DecAsnIndent();
            PrintAsnIndent(m_Out);
            m_Out << '}';
        }

    void NextElement(void)
        {
            if ( m_Empty )
                m_Empty = false;
            else
                m_Out << ",\n";
            PrintAsnIndent(m_Out);
        }

private:
    CNcbiOstream& m_Out;
    bool m_Empty;
};

void PrintAsnPrimitiveValue(CNcbiOstream& out, const CConstObjectInfo& object);
void PrintAsnClassValue(CNcbiOstream& out, const CConstObjectInfo& object);
void PrintAsnChoiceValue(CNcbiOstream& out, const CConstObjectInfo& object);
void PrintAsnContainerValue(CNcbiOstream& out, const CConstObjectInfo& object);
void PrintAsnPointerValue(CNcbiOstream& out, const CConstObjectInfo& object);

void PrintAsnValue(CNcbiOstream& out, const CConstObjectInfo& object)
{
    _ASSERT(object);
    switch ( object.GetTypeFamily() ) {
    case eTypeFamilyPrimitive:
        PrintAsnPrimitiveValue(out, object);
        break;
    case eTypeFamilyClass:
        PrintAsnClassValue(out, object);
        break;
    case eTypeFamilyChoice:
        PrintAsnChoiceValue(out, object);
        break;
    case eTypeFamilyContainer:
        PrintAsnContainerValue(out, object);
        break;
    case eTypeFamilyPointer:
        PrintAsnPointerValue(out, object);
        break;
    }
}

static const char Hex[] = "0123456789ABCDEF";

void PrintAsnPrimitiveValue(CNcbiOstream& out, const CConstObjectInfo& object)
{
    switch ( object.GetPrimitiveValueType() ) {
    case ePrimitiveValueBool:
        out << (object.GetPrimitiveValueBool()? "TRUE": "FALSE");
        break;
    case ePrimitiveValueChar:
        out << '\'' << object.GetPrimitiveValueChar() << '\'';
        break;
    case ePrimitiveValueInteger:
        if ( object.IsPrimitiveValueSigned() )
            out << object.GetPrimitiveValueLong();
        else
            out << object.GetPrimitiveValueULong();
        break;
    case ePrimitiveValueReal:
        out << object.GetPrimitiveValueDouble();
        break;
    case ePrimitiveValueString:
        out << '"' << object.GetPrimitiveValueString() << '"';
        break;
    case ePrimitiveValueEnum:
        {
            string s;
            object.GetPrimitiveValueString(s);
            if ( !s.empty() )
                out << s;
            else if ( object.IsPrimitiveValueSigned() )
                out << object.GetPrimitiveValueLong();
            else
                out << object.GetPrimitiveValueULong();
        }
        break;
    case ePrimitiveValueOctetString:
        out << '\'';
        {
            vector<char> s;
            object.GetPrimitiveValueOctetString(s);
            ITERATE ( vector<char>, i, s ) {
                char c = *i;
                out << Hex[(c >> 4) & 15] << Hex[c & 15];
            }
        }
        out << "'H";
        break;
    default:
        out << "...";
        break;
    }
}

void PrintAsnClassValue(CNcbiOstream& out, const CConstObjectInfo& object)
{
    AsnBlock block(out);

    for ( CConstObjectInfo::CMemberIterator i(object); i; ++i ) {
        if ( i.IsSet() ) {
            // print member separator
            block.NextElement();

            // print member id if any
            const string& alias = i.GetAlias();
            if ( !alias.empty() )
                out << alias << ' ';

            // print member value
            PrintAsnValue(out, *i);
        }
    }
}

void PrintAsnChoiceValue(CNcbiOstream& out, const CConstObjectInfo& object)
{
    CConstObjectInfo::CChoiceVariant variant(object);
    if ( !variant )
        THROW1_TRACE(runtime_error, "cannot print empty choice");
    out << variant.GetAlias() << ' ';
    PrintAsnValue(out, *variant);
}

void PrintAsnContainerValue(CNcbiOstream& out, const CConstObjectInfo& object)
{
    AsnBlock block(out);
    
    for ( CConstObjectInfo::CElementIterator i(object); i; ++i ) {
        block.NextElement();
        
        PrintAsnValue(out, *i);
    }
}

void PrintAsnPointerValue(CNcbiOstream& out, const CConstObjectInfo& object)
{
    PrintAsnValue(out, object.GetPointedObject());
}



/*
 * ===========================================================================
 * $Log: test_serial.cpp,v $
 * Revision 1000.2  2004/06/01 19:44:51  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.64
 *
 * Revision 1.64  2004/05/17 21:03:33  gorelenk
 * Added include of PCH ncbi_pch.hpp
 *
 * Revision 1.63  2004/01/21 15:18:15  grichenk
 * Re-arranged webenv files for serial test
 *
 * Revision 1.62  2003/06/16 16:53:46  gouriano
 * corrections to make test run OK
 *
 * Revision 1.61  2003/06/13 20:44:33  ivanov
 * Changed names of the test files from "test.*" to "test_serial.*"
 *
 * Revision 1.60  2003/06/02 16:48:51  lavr
 * Renamed testserial -> test_serial
 *
 * Revision 1.59  2003/03/11 20:07:11  kuznets
 * iterate -> ITERATE
 *
 * Revision 1.58  2002/12/30 22:41:58  vakatov
 * Fixed for absent terminating '\0' when calling strstream::str().
 * Added standard NCBI header and log.
 *
 * ===========================================================================
 */