开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
test_serial.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：26k
源码类别：

生物技术

开发平台：

C/C++

test_serial.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: test_serial.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:44:51  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.64
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: test_serial.cpp,v 1000.2 2004/06/01 19:44:51 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Eugene Vasilchenko
  36.  *
  37.  * File Description:
  38.  *   .......
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include "test_serial.hpp"
  44. #include "serialobject.hpp"
  45. #include <serial/serial.hpp>
  46. #include <serial/serialasn.hpp>
  47. #include <serial/objistr.hpp>
  48. #include <serial/objostr.hpp>
  49. #include <serial/object.hpp>
  50. #include <serial/iterator.hpp>
  51. #include <serial/objhook.hpp>
  52. #include "cppwebenv.hpp"
  54. #include <serial/stdtypes.hpp>
  55. #include <serial/classinfo.hpp>
  56. #include <serial/choice.hpp>
  57. #include <serial/ptrinfo.hpp>
  58. #include <serial/continfo.hpp>
  60. #if HAVE_NCBI_C
  61. # include <asn.h>
  62. # include "twebenv.h"
  63. #else
  64. # include "webenv/Web_Env.hpp"
  65. #endif
  67. #include <test/test_assert.h>  /* This header must go last */
  71. int main(int argc, char** argv)
  72. {
  73.     CTestSerial().AppMain(argc, argv);
  74. return 0;
  75. }
  77. void PrintAsn(CNcbiOstream& out, const CConstObjectInfo& object);
  80. class CWriteSerialObjectHook : public CWriteObjectHook
  81. {
  82. public:
  83.     CWriteSerialObjectHook(CTestSerialObject* hooked)
  84.         : m_HookedObject(hooked) {}
  85.     void WriteObject(CObjectOStream& out,
  86.                      const CConstObjectInfo& object);
  87. private:
  88.     CTestSerialObject* m_HookedObject;
  89. };
  92. void CWriteSerialObjectHook::WriteObject(CObjectOStream& out,
  93.                                          const CConstObjectInfo& object)
  94. {
  95.     const CTestSerialObject& obj = *reinterpret_cast<const CTestSerialObject*>
  96.         (object.GetObjectPtr());
  97.     
  98.     if (&obj != m_HookedObject) {
  99.         // This is not the object we would like to process.
  100.         // Use default write method.
  101.         LOG_POST("CWriteSerialObjectHook::WriteObject()"
  102.             " -- using default writer");
  103.         DefaultWrite(out, object);
  104.         return;
  105.     }
  107.     // Special object processing
  108.     // Write object open tag
  109.     out.BeginClass(object.GetClassTypeInfo());
  110.     // Iterate object members
  111.     for (CConstObjectInfo::CMemberIterator member =
  112.         object.BeginMembers(); member; ++member) {
  113.         if (member.GetAlias() == "m_Name") {
  114.             // This member will be written using CharBlock instead of the
  115.             // default method.
  116.             LOG_POST("CWriteSerialObjectHook::WriteObject()"
  117.                 " -- using CharBlock to write " << member.GetAlias());
  118.             // Write the special member
  119.             out.BeginClassMember(member.GetMemberInfo()->GetId());
  120.             // Start char block, specify output stream and block size
  121.             CObjectOStream::CharBlock cb(out, obj.m_Name.size());
  122.                 cb.Write(obj.m_Name.c_str(), obj.m_Name.size());   
  123.             // End char block and member
  124.             cb.End();
  125.             out.EndClassMember();
  126.         }
  127.         else {
  128.             // Do not need special processing for this member -- use
  129.             // default write method. Do not write unset members (although
  130.             // it is possible).
  131.             if ( member.IsSet() ) {
  132.                 LOG_POST("CWriteSerialObjectHook::WriteObject()"
  133.                     " -- using default member writer for " <<
  134.                     member.GetAlias());
  135.                 out.WriteClassMember(member);
  136.             }
  137.         }
  138.     }
  139.     // Close the object
  140.     out.EndClass();
  141. }
  144. class CReadSerialObjectHook : public CReadObjectHook
  145. {
  146. public:
  147.     CReadSerialObjectHook(CTestSerialObject* hooked)
  148.         : m_HookedObject(hooked) {}
  149.     void ReadObject(CObjectIStream& in,
  150.                     const CObjectInfo& object);
  151. private:
  152.     CTestSerialObject* m_HookedObject;
  153. };
  156. void CReadSerialObjectHook::ReadObject(CObjectIStream& in,
  157.                                        const CObjectInfo& object)
  158. {
  159.     const CTestSerialObject& obj = *reinterpret_cast<const CTestSerialObject*>
  160.         (object.GetObjectPtr());
  161.     
  162.     if (&obj != m_HookedObject) {
  163.         // Use default read method.
  164.         LOG_POST("CReadSerialObjectHook::ReadObject()"
  165.             " -- using default reader");
  166.         DefaultRead(in, object);
  167.         return;
  168.     }
  170.     LOG_POST("CReadSerialObjectHook::ReadObject()"
  171.         " -- using overloaded reader");
  172.     // Read the object manually, member by member.
  173.     for ( CIStreamClassMemberIterator i(in, object); i; ++i ) {
  174.         const CObjectTypeInfo::CMemberIterator& nextMember = *i;
  175.         LOG_POST("CReadSerialObjectHook::ReadObject()"
  176.             " -- using default member reader for " <<
  177.             nextMember.GetAlias());
  178.         // Special pre-read processing may be put here
  179.         in.ReadClassMember(CObjectInfoMI(object, nextMember.GetMemberIndex()));
  180.         // Special post-read processing may be put here
  181.     }
  182. }
  185. class CWriteSerialObject_NameHook : public CWriteClassMemberHook
  186. {
  187. public:
  188.     virtual void WriteClassMember(CObjectOStream& out,
  189.                                   const CConstObjectInfoMI& member);
  190. };
  192. void CWriteSerialObject_NameHook::WriteClassMember
  193.     (CObjectOStream& out, const CConstObjectInfoMI& member)
  194. {
  195.     // No special processing -- just report writing the member
  196.     const string& name = *static_cast<const string*>
  197.         (member.GetMember().GetObjectPtr());
  198.     LOG_POST("CWriteSerialObject_NameHook::WriteClassMember()"
  199.         " -- writing m_Name: " << name);
  200.     DefaultWrite(out, member);
  201. }
  204. class CReadSerialObject_NameHook : public CReadClassMemberHook
  205. {
  206. public:
  207.     virtual void ReadClassMember(CObjectIStream& in,
  208.                                  const CObjectInfoMI& member);
  209. };
  211. void CReadSerialObject_NameHook::ReadClassMember
  212.     (CObjectIStream& in, const CObjectInfoMI& member)
  213. {
  214.     // No special processing -- just report reading the member
  215.     DefaultRead(in, member);
  216.     const string& name = *reinterpret_cast<const string*>
  217.         (member.GetMember().GetObjectPtr());
  218.     LOG_POST("CReadSerialObject_NameHook::ReadClassMember()"
  219.         " -- reading m_Name: " << name);
  220. }
  223. void TestHooks(CTestSerialObject& obj)
  224. {
  225.     // Test object hooks
  226.     char* buf = 0;
  227.     {{
  228.         CNcbiOstrstream ostrs;
  229.         auto_ptr<CObjectOStream> os(CObjectOStream::Open
  230.             (eSerial_AsnText, ostrs));
  231.         CObjectHookGuard<CTestSerialObject> w_hook
  232.             (*(new CWriteSerialObjectHook(&obj)), &(*os));
  233.         *os << obj;
  234.   os->FlushBuffer();
  235.   ostrs << '';
  236.   buf = ostrs.str();
  237.     }}
  238.     {{
  239.         CNcbiIstrstream istrs(buf);
  240.         auto_ptr<CObjectIStream> is(CObjectIStream::Open
  241.             (eSerial_AsnText, istrs));
  242.         CTestSerialObject obj_copy;
  243.         CObjectHookGuard<CTestSerialObject> r_hook
  244.             (*(new CReadSerialObjectHook(&obj_copy)), &(*is));
  245.         *is >> obj_copy;
  246. #if HAVE_NCBI_C
  247.         // Can not use SerialEquals<> with C-objects
  248. #else
  249.         _ASSERT(SerialEquals<CTestSerialObject>(obj, obj_copy));
  250. #endif
  251.     }}
  252.     delete[] buf;
  254.     // Test member hooks
  255.     char* buf2 = 0;
  256.     {{
  257.         CNcbiOstrstream ostrs;
  258.         auto_ptr<CObjectOStream> os(CObjectOStream::Open
  259.             (eSerial_AsnText, ostrs));
  260.         CObjectHookGuard<CTestSerialObject> w_hook
  261.             ("m_Name", *(new CWriteSerialObject_NameHook), &(*os));
  262.         *os << obj;
  263.   os->FlushBuffer();
  264.   ostrs << '';
  265.         buf2 = ostrs.str();
  266.     }}
  267.     {{
  268.         CNcbiIstrstream istrs(buf2);
  269.         auto_ptr<CObjectIStream> is(CObjectIStream::Open
  270.             (eSerial_AsnText, istrs));
  271.         CTestSerialObject obj_copy;
  272.         CObjectHookGuard<CTestSerialObject> r_hook
  273.             ("m_Name", *(new CReadSerialObject_NameHook), &(*is));
  274.         *is >> obj_copy;
  275. #if HAVE_NCBI_C
  276.         // Can not use SerialEquals<> with C-objects
  277. #else
  278.         _ASSERT(SerialEquals<CTestSerialObject>(obj, obj_copy));
  279. #endif
  280.     }}
  281.     delete[] buf2;
  282. }
  284. int CTestSerial::Run(void)
  285. {
  286.     CNcbiOfstream diag("test_serial.log");
  287.     SetDiagStream(&diag);
  288.     try {
  289. #if HAVE_NCBI_C
  290.         WebEnv* env = 0;
  291.         {
  292.             {
  293.                 auto_ptr<CObjectIStream> in(CObjectIStream::Open("webenv.ent",
  294.                                                                  eSerial_AsnText));
  295.                 in->Read(&env, GetSequenceTypeRef(&env).Get());
  296.             }
  297.             {
  298.                 auto_ptr<CObjectOStream> out(CObjectOStream::Open("webenv.bino",
  299.                                                                   eSerial_AsnBinary));
  300.                 out->Write(&env, GetSequenceTypeRef(&env).Get());
  301.             }
  302.             {
  303.                 // C-style Object must be clean before loading: using new WebEnv instance
  304.                 WebEnv* env2 = 0;
  305.                 auto_ptr<CObjectIStream> in(CObjectIStream::Open("webenv.bin",
  306.                                                                  eSerial_AsnBinary));
  307.                 in->Read(&env2, GetSequenceTypeRef(&env2).Get());
  308.                 auto_ptr<CObjectOStream> out(CObjectOStream::Open("webenv.ento",
  309.                                                                   eSerial_AsnText));
  310.                 out->Write(&env2, GetSequenceTypeRef(&env2).Get());
  311.             }
  312.             {
  313.                 CNcbiOfstream out("webenv.ento2");
  314.                 PrintAsn(out,
  315.                          CConstObjectInfo(&env,
  316.                                           GetSequenceTypeRef(&env).Get()));
  317.             }
  318.         }
  319. #else
  320.         CRef<CWeb_Env> env(new CWeb_Env);
  321.         {
  322.             {
  323.                 auto_ptr<CObjectIStream> in(CObjectIStream::Open("webenv.ent",
  324.                                                                  eSerial_AsnText));
  325.                 *in >> *env;
  326.             }
  327.             {
  328.                 auto_ptr<CObjectOStream> out(CObjectOStream::Open("webenv.bino",
  329.                                                                   eSerial_AsnBinary));
  330.                 *out << *env;
  331.             }
  332.             {
  333.                 CRef<CWeb_Env> env2(new CWeb_Env);
  334.                 auto_ptr<CObjectIStream> in(CObjectIStream::Open("webenv.bin",
  335.                                                                  eSerial_AsnBinary));
  336.                 *in >> *env2;
  338.                 auto_ptr<CObjectOStream> out(CObjectOStream::Open("webenv.ento",
  339.                                                                   eSerial_AsnText));
  340.                 out->SetAutoSeparator(false);
  341.                 *out << *env2;
  342.             }
  343.         }
  344.         {
  345.             CNcbiOfstream out("test_serial.asno2");
  346.             PrintAsn(out, ConstObjectInfo(*env));
  347.         }
  348. #endif
  350.         CTestSerialObject write;
  351.         CTestSerialObject2 write1;
  353.         _TRACE("CTestSerialObject(object1): " << long(&write));
  354.         _TRACE("CTestSerialObject2(object2): " << long(&write1));
  355.         _TRACE("CTestSerialObject(object2): " <<
  356.                long(static_cast<CTestSerialObject*>(&write1)));
  358.         write.m_Name = "name";
  359.         write.m_HaveName = false;
  360.         //        write.m_NamePtr = &write1.m_Name;
  361.         write.m_Size = -1;
  362.         write.m_Attributes.push_back("m_Attributes");
  363.         write.m_Attributes.push_back("m_Size");
  364.         write.m_Attributes.push_back("m_");
  365.         write.m_Next = &write1;
  366.         const char* s = "data";
  367.         write.m_Data.insert(write.m_Data.begin(), s, s + 4);
  368.         write.m_Offsets.push_back(25);
  369.         write.m_Offsets.push_back(-1024);
  370.         write.m_Names[0] = "zero";
  371.         write.m_Names[1] = "one";
  372.         write.m_Names[2] = "two";
  373.         write.m_Names[3] = "three";
  374.         write.m_Names[10] = "ten";
  375.         write.m_WebEnv = env;
  377.         write1.m_Name = "write1";
  378.         write1.m_HaveName = true;
  379.         write1.m_NamePtr = new string("test");
  380.         write1.m_Size = 0x7fff;
  381.         write1.m_Attributes.push_back("write1");
  382.         //        write1.m_Next = &write1;
  383.         write1.m_WebEnv = 0;
  384.         write1.m_Name2 = "name2";
  386.         TestHooks(write);
  388.         const CTestSerialObject& cwrite = write;
  390.         CTypeIterator<CTestSerialObject> j1; j1 = Begin(write);
  391.         CTypeIterator<CTestSerialObject> j2(Begin(write));
  392.         CTypeIterator<CTestSerialObject> j3 = Begin(write);
  394.         //j1.Erase();
  396.         CTypeConstIterator<CTestSerialObject> k1; k1 = Begin(write);
  397.         CTypeConstIterator<CTestSerialObject> k2(Begin(write));
  398.         CTypeConstIterator<CTestSerialObject> k3 = ConstBegin(write);
  400.         //k1.Erase();
  402.         CTypeConstIterator<CTestSerialObject> l1; l1 = ConstBegin(write);
  403.         CTypeConstIterator<CTestSerialObject> l2(ConstBegin(write));
  404.         CTypeConstIterator<CTestSerialObject> l3 = ConstBegin(write);
  406.         CTypeConstIterator<CTestSerialObject> m1; m1 = ConstBegin(cwrite);
  407.         CTypeConstIterator<CTestSerialObject> m2(ConstBegin(cwrite));
  408.         CTypeConstIterator<CTestSerialObject> m3 = ConstBegin(cwrite);
  410.         CTypesIterator n1; n1 = Begin(write);
  411.         CTypesConstIterator n2; n2 = ConstBegin(write);
  412.         CTypesConstIterator n3; n3 = ConstBegin(cwrite);
  413.         //CTypesConstIterator n4; n4 = Begin(cwrite);
  415.         {
  416.             for ( CTypeIterator<CTestSerialObject> oi = Begin(write); oi; ++oi ) {
  417.                 const CTestSerialObject& obj = *oi;
  418.                 NcbiCerr<<"CTestSerialObject @ "<<NStr::PtrToString(&obj)<<
  419.                     NcbiEndl;
  420.                 //            oi.Erase();
  421.                 CTypeIterator<CTestSerialObject> oi1(Begin(write));
  422.                 CTypeIterator<CTestSerialObject> oi2;
  423.                 oi2 = Begin(write);
  424.             }
  425.         }
  426.         {
  427.             for ( CTypeConstIterator<CTestSerialObject> oi = ConstBegin(write); oi;
  428.                   ++oi ) {
  429.                 const CTestSerialObject& obj = *oi;
  430.                 NcbiCerr<<"CTestSerialObject @ "<<NStr::PtrToString(&obj)<<
  431.                     NcbiEndl;
  432.                 //            oi.Erase();
  433.                 CTypeConstIterator<CTestSerialObject> oi1(Begin(write));
  434.                 CTypeConstIterator<CTestSerialObject> oi2;
  435.                 oi2 = Begin(write);
  436.             }
  437.         }
  438.         {
  439.             for ( CTypeConstIterator<CTestSerialObject> oi = ConstBegin(cwrite);
  440.                   oi; ++oi ) {
  441.                 const CTestSerialObject& obj = *oi;
  442.                 NcbiCerr<<"CTestSerialObject @ "<<NStr::PtrToString(&obj)<<
  443.                     NcbiEndl;
  444.                 //oi.Erase();
  445.                 CTypeConstIterator<CTestSerialObject> oi1(ConstBegin(cwrite));
  446.                 CTypeConstIterator<CTestSerialObject> oi2;
  447.                 oi2 = ConstBegin(cwrite);
  448.             }
  449.         }
  451.         {
  452.             for ( CStdTypeConstIterator<string> si = ConstBegin(cwrite); si;
  453.                   ++si ) {
  454.                 NcbiCerr <<"String: ""<<*si<<"""<<NcbiEndl;
  455.             }
  456.         }
  458.         {
  459.             for ( CObjectConstIterator oi = ConstBegin(cwrite); oi; ++oi ) {
  460.                 const CObject& obj = *oi;
  461.                 NcbiCerr <<"CObject: @ "<<NStr::PtrToString(&obj)<<NcbiEndl;
  462.             }
  463.         }
  465.         {
  466.             CTypesIterator i;
  467.             CType<CTestSerialObject>::AddTo(i);
  468.             CType<CTestSerialObject2>::AddTo(i);
  469.             for ( i = Begin(write); i; ++i ) {
  470.                 CTestSerialObject* obj = CType<CTestSerialObject>::Get(i);
  471.                 if ( obj ) {
  472.                     NcbiCerr <<"CObject: @ "<<NStr::PtrToString(obj)<<NcbiEndl;
  473.                 }
  474.                 else {
  475.                     NcbiCerr <<"CObject2: @ "<<
  476.                         NStr::PtrToString(CType<CTestSerialObject2>::Get(i))<<
  477.                         NcbiEndl;
  478.                 }
  479.             }
  480.         }
  482.         {
  483.             CTypesConstIterator i;
  484.             CType<CTestSerialObject>::AddTo(i);
  485.             CType<CTestSerialObject2>::AddTo(i);
  486.             for ( i = ConstBegin(write); i; ++i ) {
  487.                 const CTestSerialObject* obj = CType<CTestSerialObject>::Get(i);
  488.                 if ( obj ) {
  489.                     NcbiCerr <<"CObject: @ "<<NStr::PtrToString(obj)<<NcbiEndl;
  490.                 }
  491.                 else {
  492.                     NcbiCerr <<"CObject2: @ "<<
  493.                         NStr::PtrToString(CType<CTestSerialObject2>::Get(i))<<
  494.                         NcbiEndl;
  495.                 }
  496.             }
  497.         }
  499.         {
  500.             {
  501.                 auto_ptr<CObjectOStream> out(CObjectOStream::Open("test_serial.asno",
  502.                                                                   eSerial_AsnText));
  503.                 *out << write;
  504.             }
  505.             {
  506.                 CNcbiOfstream out("test_serial.asno2");
  507.                 PrintAsn(out, ConstObjectInfo(write));
  508.             }
  509.             CTestSerialObject read;
  510.             {
  511.                 auto_ptr<CObjectIStream> in(CObjectIStream::Open("test_serial.asn",
  512.                                                                  eSerial_AsnText));
  513.                 *in >> read;
  514.             }
  515. #if HAVE_NCBI_C
  516.             // Some functions does not work with C-style objects.
  517.             // Reset WebEnv for SerialEquals() to work.
  518.             TWebEnv* saved_env_read = read.m_WebEnv;
  519.             TWebEnv* saved_env_write = write.m_WebEnv;
  520.             read.m_WebEnv = 0;
  521.             write.m_WebEnv = 0;
  522. #endif
  523.             _ASSERT(SerialEquals<CTestSerialObject>(read, write));
  524. #if HAVE_NCBI_C
  525.             // Restore C-style objects
  526.             read.m_WebEnv = saved_env_read;
  527.             write.m_WebEnv = saved_env_write;
  528. #endif
  529.             read.Dump(NcbiCerr);
  530.             read.m_Next->Dump(NcbiCerr);
  531. #if !defined(HAVE_NCBI_C)
  532.             {
  533.                 auto_ptr<CObjectIStream> in(CObjectIStream::Open("test_serial.asn",
  534.                                                                  eSerial_AsnText));
  535.                 in->Skip(ObjectType(read));
  536.             }
  537. #endif
  538.         }
  540.         {
  541.             {
  542.                 auto_ptr<CObjectOStream> out(CObjectOStream::Open("test_serial.asbo",
  543.                                                                   eSerial_AsnBinary));
  544.                 *out << write;
  545.             }
  546.             CTestSerialObject read;
  547.             {
  548.                 auto_ptr<CObjectIStream> in(CObjectIStream::Open("test_serial.asb",
  549.                                                                  eSerial_AsnBinary));
  550.                 *in >> read;
  551.             }
  552. #if HAVE_NCBI_C
  553.             // Some functions does not work with C-style objects.
  554.             // Reset WebEnv for SerialEquals() to work.
  555.             TWebEnv* saved_env_read = read.m_WebEnv;
  556.             TWebEnv* saved_env_write = write.m_WebEnv;
  557.             read.m_WebEnv = 0;
  558.             write.m_WebEnv = 0;
  559. #endif
  560.             _ASSERT(SerialEquals<CTestSerialObject>(read, write));
  561. #if HAVE_NCBI_C
  562.             // Restore C-style objects
  563.             read.m_WebEnv = saved_env_read;
  564.             write.m_WebEnv = saved_env_write;
  565. #endif
  566.             read.Dump(NcbiCerr);
  567.             read.m_Next->Dump(NcbiCerr);
  568. #if !defined(HAVE_NCBI_C)
  569.             {
  570.                 auto_ptr<CObjectIStream> in(CObjectIStream::Open("test_serial.asb",
  571.                                                                  eSerial_AsnBinary));
  572.                 in->Skip(ObjectType(read));
  573.             }
  574. #endif
  575.         }
  577.         NcbiCerr << "OK" << endl;
  578.     }
  579.     catch (NCBI_NS_STD::exception& e) {
  580.         ERR_POST(typeid(e).name() << ": " << e.what());
  581.     }
  582.     catch (...) {
  583.         ERR_POST("Unknown error");
  584.     }
  585.     SetDiagStream(&NcbiCerr);
  586.     return 0;
  587. }
  589. void PrintAsnValue(CNcbiOstream& out, const CConstObjectInfo& object);
  590. static int asnIndentLevel;
  592. void ResetAsnIndent(void)
  593. {
  594.     asnIndentLevel = 0;
  595. }
  597. void IncAsnIndent(void)
  598. {
  599.     asnIndentLevel++;
  600. }
  602. void DecAsnIndent(void)
  603. {
  604.     _ASSERT(asnIndentLevel > 0);
  605.     asnIndentLevel--;
  606. }
  608. void PrintAsnIndent(CNcbiOstream& out)
  609. {
  610.     for ( int i = 0; i < asnIndentLevel; ++i )
  611.         out << "  ";
  612. }
  614. void PrintAsn(CNcbiOstream& out, const CConstObjectInfo& object)
  615. {
  616.     _ASSERT(object);
  617.     _ASSERT(!object.GetTypeInfo()->GetName().empty());
  618.     ResetAsnIndent();
  619.     out << object.GetTypeInfo()->GetName() << " ::= ";
  620.     PrintAsnValue(out, object);
  621. }
  623. class AsnBlock
  624. {
  625. public:
  626.     AsnBlock(CNcbiOstream& out)
  627.         : m_Out(out), m_Empty(true)
  628.         {
  629.             out << "{n";
  630.             IncAsnIndent();
  631.         }
  632.     ~AsnBlock(void)
  633.         {
  634.             if ( !m_Empty )
  635.                 m_Out << 'n';
  636.             DecAsnIndent();
  637.             PrintAsnIndent(m_Out);
  638.             m_Out << '}';
  639.         }
  641.     void NextElement(void)
  642.         {
  643.             if ( m_Empty )
  644.                 m_Empty = false;
  645.             else
  646.                 m_Out << ",n";
  647.             PrintAsnIndent(m_Out);
  648.         }
  650. private:
  651.     CNcbiOstream& m_Out;
  652.     bool m_Empty;
  653. };
  655. void PrintAsnPrimitiveValue(CNcbiOstream& out, const CConstObjectInfo& object);
  656. void PrintAsnClassValue(CNcbiOstream& out, const CConstObjectInfo& object);
  657. void PrintAsnChoiceValue(CNcbiOstream& out, const CConstObjectInfo& object);
  658. void PrintAsnContainerValue(CNcbiOstream& out, const CConstObjectInfo& object);
  659. void PrintAsnPointerValue(CNcbiOstream& out, const CConstObjectInfo& object);
  661. void PrintAsnValue(CNcbiOstream& out, const CConstObjectInfo& object)
  662. {
  663.     _ASSERT(object);
  664.     switch ( object.GetTypeFamily() ) {
  665.     case eTypeFamilyPrimitive:
  666.         PrintAsnPrimitiveValue(out, object);
  667.         break;
  668.     case eTypeFamilyClass:
  669.         PrintAsnClassValue(out, object);
  670.         break;
  671.     case eTypeFamilyChoice:
  672.         PrintAsnChoiceValue(out, object);
  673.         break;
  674.     case eTypeFamilyContainer:
  675.         PrintAsnContainerValue(out, object);
  676.         break;
  677.     case eTypeFamilyPointer:
  678.         PrintAsnPointerValue(out, object);
  679.         break;
  680.     }
  681. }
  683. static const char Hex[] = "0123456789ABCDEF";
  685. void PrintAsnPrimitiveValue(CNcbiOstream& out, const CConstObjectInfo& object)
  686. {
  687.     switch ( object.GetPrimitiveValueType() ) {
  688.     case ePrimitiveValueBool:
  689.         out << (object.GetPrimitiveValueBool()? "TRUE": "FALSE");
  690.         break;
  691.     case ePrimitiveValueChar:
  692.         out << ''' << object.GetPrimitiveValueChar() << ''';
  693.         break;
  694.     case ePrimitiveValueInteger:
  695.         if ( object.IsPrimitiveValueSigned() )
  696.             out << object.GetPrimitiveValueLong();
  697.         else
  698.             out << object.GetPrimitiveValueULong();
  699.         break;
  700.     case ePrimitiveValueReal:
  701.         out << object.GetPrimitiveValueDouble();
  702.         break;
  703.     case ePrimitiveValueString:
  704.         out << '"' << object.GetPrimitiveValueString() << '"';
  705.         break;
  706.     case ePrimitiveValueEnum:
  707.         {
  708.             string s;
  709.             object.GetPrimitiveValueString(s);
  710.             if ( !s.empty() )
  711.                 out << s;
  712.             else if ( object.IsPrimitiveValueSigned() )
  713.                 out << object.GetPrimitiveValueLong();
  714.             else
  715.                 out << object.GetPrimitiveValueULong();
  716.         }
  717.         break;
  718.     case ePrimitiveValueOctetString:
  719.         out << ''';
  720.         {
  721.             vector<char> s;
  722.             object.GetPrimitiveValueOctetString(s);
  723.             ITERATE ( vector<char>, i, s ) {
  724.                 char c = *i;
  725.                 out << Hex[(c >> 4) & 15] << Hex[c & 15];
  726.             }
  727.         }
  728.         out << "'H";
  729.         break;
  730.     default:
  731.         out << "...";
  732.         break;
  733.     }
  734. }
  736. void PrintAsnClassValue(CNcbiOstream& out, const CConstObjectInfo& object)
  737. {
  738.     AsnBlock block(out);
  740.     for ( CConstObjectInfo::CMemberIterator i(object); i; ++i ) {
  741.         if ( i.IsSet() ) {
  742.             // print member separator
  743.             block.NextElement();
  745.             // print member id if any
  746.             const string& alias = i.GetAlias();
  747.             if ( !alias.empty() )
  748.                 out << alias << ' ';
  750.             // print member value
  751.             PrintAsnValue(out, *i);
  752.         }
  753.     }
  754. }
  756. void PrintAsnChoiceValue(CNcbiOstream& out, const CConstObjectInfo& object)
  757. {
  758.     CConstObjectInfo::CChoiceVariant variant(object);
  759.     if ( !variant )
  760.         THROW1_TRACE(runtime_error, "cannot print empty choice");
  761.     out << variant.GetAlias() << ' ';
  762.     PrintAsnValue(out, *variant);
  763. }
  765. void PrintAsnContainerValue(CNcbiOstream& out, const CConstObjectInfo& object)
  766. {
  767.     AsnBlock block(out);
  768.     
  769.     for ( CConstObjectInfo::CElementIterator i(object); i; ++i ) {
  770.         block.NextElement();
  771.         
  772.         PrintAsnValue(out, *i);
  773.     }
  774. }
  776. void PrintAsnPointerValue(CNcbiOstream& out, const CConstObjectInfo& object)
  777. {
  778.     PrintAsnValue(out, object.GetPointedObject());
  779. }
  783. /*
  784.  * ===========================================================================
  785.  * $Log: test_serial.cpp,v $
  786.  * Revision 1000.2  2004/06/01 19:44:51  gouriano
  787.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.64
  788.  *
  789.  * Revision 1.64  2004/05/17 21:03:33  gorelenk
  790.  * Added include of PCH ncbi_pch.hpp
  791.  *
  792.  * Revision 1.63  2004/01/21 15:18:15  grichenk
  793.  * Re-arranged webenv files for serial test
  794.  *
  795.  * Revision 1.62  2003/06/16 16:53:46  gouriano
  796.  * corrections to make test run OK
  797.  *
  798.  * Revision 1.61  2003/06/13 20:44:33  ivanov
  799.  * Changed names of the test files from "test.*" to "test_serial.*"
  800.  *
  801.  * Revision 1.60  2003/06/02 16:48:51  lavr
  802.  * Renamed testserial -> test_serial
  803.  *
  804.  * Revision 1.59  2003/03/11 20:07:11  kuznets
  805.  * iterate -> ITERATE
  806.  *
  807.  * Revision 1.58  2002/12/30 22:41:58  vakatov
  808.  * Fixed for absent terminating '' when calling strstream::str().
  809.  * Added standard NCBI header and log.
  810.  *
  811.  * ===========================================================================
  812.  */