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

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

生物技术

开发平台：

C/C++

twebenv.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: twebenv.c,v $
  4.  * PRODUCTION Revision 1000.0  2003/10/29 17:59:36  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.3
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #include <ncbiconf.h>
  11. #if HAVE_NCBI_C
  12. #include <asn.h>
  14. #define NLM_GENERATED_CODE_PROTO
  16. #include "twebenv.h"
  18. static Boolean loaded = FALSE;
  20. #include "twebenvasn.h"
  22. #ifndef NLM_EXTERN_LOADS
  23. #define NLM_EXTERN_LOADS {}
  24. #endif
  26. NLM_EXTERN Boolean LIBCALL
  27. twebenvAsnLoad(void)
  28. {
  30.    if ( ! loaded) {
  31.       NLM_EXTERN_LOADS
  33.       if ( ! AsnLoad ())
  34.       return FALSE;
  35.       loaded = TRUE;
  36.    }
  38.    return TRUE;
  39. }
  43. /**************************************************
  44. *    Generated object loaders for Module NCBI-Env
  45. *    Generated using ASNCODE Revision: 6.0 at Oct 4, 1999  4:26 PM
  46. *
  47. **************************************************/
  50. /**************************************************
  51. *
  52. *    WebEnvNew()
  53. *
  54. **************************************************/
  55. NLM_EXTERN 
  56. WebEnvPtr LIBCALL
  57. WebEnvNew(void)
  58. {
  59.    WebEnvPtr ptr = MemNew((size_t) sizeof(WebEnv));
  61.    return ptr;
  63. }
  66. /**************************************************
  67. *
  68. *    WebEnvFree()
  69. *
  70. **************************************************/
  71. NLM_EXTERN 
  72. WebEnvPtr LIBCALL
  73. WebEnvFree(WebEnvPtr ptr)
  74. {
  76.    if(ptr == NULL) {
  77.       return NULL;
  78.    }
  79.    AsnGenericUserSeqOfFree(ptr -> arguments, (AsnOptFreeFunc) ArgumentFree);
  80.    AsnGenericUserSeqOfFree(ptr -> db_Env, (AsnOptFreeFunc) DbEnvFree);
  81.    AsnGenericUserSeqOfFree(ptr -> queries, (AsnOptFreeFunc) QueryHistoryFree);
  82.    return MemFree(ptr);
  83. }
  86. /**************************************************
  87. *
  88. *    WebEnvAsnRead()
  89. *
  90. **************************************************/
  91. NLM_EXTERN 
  92. WebEnvPtr LIBCALL
  93. WebEnvAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  94. {
  95.    DataVal av;
  96.    AsnTypePtr atp;
  97.    Boolean isError = FALSE;
  98.    AsnReadFunc func;
  99.    WebEnvPtr ptr;
  101.    if (! loaded)
  102.    {
  103.       if (! twebenvAsnLoad()) {
  104.          return NULL;
  105.       }
  106.    }
  108.    if (aip == NULL) {
  109.       return NULL;
  110.    }
  112.    if (orig == NULL) {         /* WebEnv ::= (self contained) */
  113.       atp = AsnReadId(aip, amp, WEB_ENV);
  114.    } else {
  115.       atp = AsnLinkType(orig, WEB_ENV);
  116.    }
  117.    /* link in local tree */
  118.    if (atp == NULL) {
  119.       return NULL;
  120.    }
  122.    ptr = WebEnvNew();
  123.    if (ptr == NULL) {
  124.       goto erret;
  125.    }
  126.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  127.       goto erret;
  128.    }
  130.    atp = AsnReadId(aip,amp, atp);
  131.    func = NULL;
  133.    if (atp == WEB_ENV_arguments) {
  134.       ptr -> arguments = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) ArgumentAsnRead, (AsnOptFreeFunc) ArgumentFree);
  135.       if (isError && ptr -> arguments == NULL) {
  136.          goto erret;
  137.       }
  138.       atp = AsnReadId(aip,amp, atp);
  139.    }
  140.    if (atp == WEB_ENV_db_Env) {
  141.       ptr -> db_Env = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DbEnvAsnRead, (AsnOptFreeFunc) DbEnvFree);
  142.       if (isError && ptr -> db_Env == NULL) {
  143.          goto erret;
  144.       }
  145.       atp = AsnReadId(aip,amp, atp);
  146.    }
  147.    if (atp == WEB_ENV_queries) {
  148.       ptr -> queries = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) QueryHistoryAsnRead, (AsnOptFreeFunc) QueryHistoryFree);
  149.       if (isError && ptr -> queries == NULL) {
  150.          goto erret;
  151.       }
  152.       atp = AsnReadId(aip,amp, atp);
  153.    }
  155.    if (AsnReadVal(aip, atp, &av) <= 0) {
  156.       goto erret;
  157.    }
  158.    /* end struct */
  160. ret:
  161.    AsnUnlinkType(orig);       /* unlink local tree */
  162.    return ptr;
  164. erret:
  165.    aip -> io_failure = TRUE;
  166.    ptr = WebEnvFree(ptr);
  167.    goto ret;
  168. }
  172. /**************************************************
  173. *
  174. *    WebEnvAsnWrite()
  175. *
  176. **************************************************/
  177. NLM_EXTERN Boolean LIBCALL 
  178. WebEnvAsnWrite(WebEnvPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  179. {
  180.    DataVal av;
  181.    AsnTypePtr atp;
  182.    Boolean retval = FALSE;
  184.    if (! loaded)
  185.    {
  186.       if (! twebenvAsnLoad()) {
  187.          return FALSE;
  188.       }
  189.    }
  191.    if (aip == NULL) {
  192.       return FALSE;
  193.    }
  195.    atp = AsnLinkType(orig, WEB_ENV);   /* link local tree */
  196.    if (atp == NULL) {
  197.       return FALSE;
  198.    }
  200.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  201.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  202.       goto erret;
  203.    }
  205.    AsnGenericUserSeqOfAsnWrite(ptr -> arguments, (AsnWriteFunc) ArgumentAsnWrite, aip, WEB_ENV_arguments, WEB_ENV_arguments_E);
  206.    AsnGenericUserSeqOfAsnWrite(ptr -> db_Env, (AsnWriteFunc) DbEnvAsnWrite, aip, WEB_ENV_db_Env, WEB_ENV_db_Env_E);
  207.    AsnGenericUserSeqOfAsnWrite(ptr -> queries, (AsnWriteFunc) QueryHistoryAsnWrite, aip, WEB_ENV_queries, WEB_ENV_queries_E);
  208.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  209.       goto erret;
  210.    }
  211.    retval = TRUE;
  213. erret:
  214.    AsnUnlinkType(orig);       /* unlink local tree */
  215.    return retval;
  216. }
  220. /**************************************************
  221. *
  222. *    ArgumentNew()
  223. *
  224. **************************************************/
  225. NLM_EXTERN 
  226. ArgumentPtr LIBCALL
  227. ArgumentNew(void)
  228. {
  229.    ArgumentPtr ptr = MemNew((size_t) sizeof(Argument));
  231.    return ptr;
  233. }
  236. /**************************************************
  237. *
  238. *    ArgumentFree()
  239. *
  240. **************************************************/
  241. NLM_EXTERN 
  242. ArgumentPtr LIBCALL
  243. ArgumentFree(ArgumentPtr ptr)
  244. {
  246.    if(ptr == NULL) {
  247.       return NULL;
  248.    }
  249.    MemFree(ptr -> name);
  250.    MemFree(ptr -> value);
  251.    return MemFree(ptr);
  252. }
  255. /**************************************************
  256. *
  257. *    ArgumentAsnRead()
  258. *
  259. **************************************************/
  260. NLM_EXTERN 
  261. ArgumentPtr LIBCALL
  262. ArgumentAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  263. {
  264.    DataVal av;
  265.    AsnTypePtr atp;
  266.    Boolean isError = FALSE;
  267.    AsnReadFunc func;
  268.    ArgumentPtr ptr;
  270.    if (! loaded)
  271.    {
  272.       if (! twebenvAsnLoad()) {
  273.          return NULL;
  274.       }
  275.    }
  277.    if (aip == NULL) {
  278.       return NULL;
  279.    }
  281.    if (orig == NULL) {         /* Argument ::= (self contained) */
  282.       atp = AsnReadId(aip, amp, ARGUMENT);
  283.    } else {
  284.       atp = AsnLinkType(orig, ARGUMENT);
  285.    }
  286.    /* link in local tree */
  287.    if (atp == NULL) {
  288.       return NULL;
  289.    }
  291.    ptr = ArgumentNew();
  292.    if (ptr == NULL) {
  293.       goto erret;
  294.    }
  295.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  296.       goto erret;
  297.    }
  299.    atp = AsnReadId(aip,amp, atp);
  300.    func = NULL;
  302.    if (atp == ARGUMENT_name) {
  303.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  304.          goto erret;
  305.       }
  306.       ptr -> name = av.ptrvalue;
  307.       atp = AsnReadId(aip,amp, atp);
  308.    }
  309.    if (atp == ARGUMENT_value) {
  310.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  311.          goto erret;
  312.       }
  313.       ptr -> value = av.ptrvalue;
  314.       atp = AsnReadId(aip,amp, atp);
  315.    }
  317.    if (AsnReadVal(aip, atp, &av) <= 0) {
  318.       goto erret;
  319.    }
  320.    /* end struct */
  322. ret:
  323.    AsnUnlinkType(orig);       /* unlink local tree */
  324.    return ptr;
  326. erret:
  327.    aip -> io_failure = TRUE;
  328.    ptr = ArgumentFree(ptr);
  329.    goto ret;
  330. }
  334. /**************************************************
  335. *
  336. *    ArgumentAsnWrite()
  337. *
  338. **************************************************/
  339. NLM_EXTERN Boolean LIBCALL 
  340. ArgumentAsnWrite(ArgumentPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  341. {
  342.    DataVal av;
  343.    AsnTypePtr atp;
  344.    Boolean retval = FALSE;
  346.    if (! loaded)
  347.    {
  348.       if (! twebenvAsnLoad()) {
  349.          return FALSE;
  350.       }
  351.    }
  353.    if (aip == NULL) {
  354.       return FALSE;
  355.    }
  357.    atp = AsnLinkType(orig, ARGUMENT);   /* link local tree */
  358.    if (atp == NULL) {
  359.       return FALSE;
  360.    }
  362.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  363.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  364.       goto erret;
  365.    }
  367.    if (ptr -> name != NULL) {
  368.       av.ptrvalue = ptr -> name;
  369.       retval = AsnWrite(aip, ARGUMENT_name,  &av);
  370.    }
  371.    if (ptr -> value != NULL) {
  372.       av.ptrvalue = ptr -> value;
  373.       retval = AsnWrite(aip, ARGUMENT_value,  &av);
  374.    }
  375.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  376.       goto erret;
  377.    }
  378.    retval = TRUE;
  380. erret:
  381.    AsnUnlinkType(orig);       /* unlink local tree */
  382.    return retval;
  383. }
  387. /**************************************************
  388. *
  389. *    DbEnvNew()
  390. *
  391. **************************************************/
  392. NLM_EXTERN 
  393. DbEnvPtr LIBCALL
  394. DbEnvNew(void)
  395. {
  396.    DbEnvPtr ptr = MemNew((size_t) sizeof(DbEnv));
  398.    return ptr;
  400. }
  403. /**************************************************
  404. *
  405. *    DbEnvFree()
  406. *
  407. **************************************************/
  408. NLM_EXTERN 
  409. DbEnvPtr LIBCALL
  410. DbEnvFree(DbEnvPtr ptr)
  411. {
  413.    if(ptr == NULL) {
  414.       return NULL;
  415.    }
  416.    MemFree(ptr -> name);
  417.    AsnGenericUserSeqOfFree(ptr -> arguments, (AsnOptFreeFunc) ArgumentFree);
  418.    AsnGenericUserSeqOfFree(ptr -> filters, (AsnOptFreeFunc) FilterValueFree);
  419.    AsnGenericUserSeqOfFree(ptr -> clipboard, (AsnOptFreeFunc) DbClipboardFree);
  420.    return MemFree(ptr);
  421. }
  424. /**************************************************
  425. *
  426. *    DbEnvAsnRead()
  427. *
  428. **************************************************/
  429. NLM_EXTERN 
  430. DbEnvPtr LIBCALL
  431. DbEnvAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  432. {
  433.    DataVal av;
  434.    AsnTypePtr atp;
  435.    Boolean isError = FALSE;
  436.    AsnReadFunc func;
  437.    DbEnvPtr ptr;
  439.    if (! loaded)
  440.    {
  441.       if (! twebenvAsnLoad()) {
  442.          return NULL;
  443.       }
  444.    }
  446.    if (aip == NULL) {
  447.       return NULL;
  448.    }
  450.    if (orig == NULL) {         /* DbEnv ::= (self contained) */
  451.       atp = AsnReadId(aip, amp, DB_ENV);
  452.    } else {
  453.       atp = AsnLinkType(orig, DB_ENV);
  454.    }
  455.    /* link in local tree */
  456.    if (atp == NULL) {
  457.       return NULL;
  458.    }
  460.    ptr = DbEnvNew();
  461.    if (ptr == NULL) {
  462.       goto erret;
  463.    }
  464.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  465.       goto erret;
  466.    }
  468.    atp = AsnReadId(aip,amp, atp);
  469.    func = NULL;
  471.    if (atp == DB_ENV_name) {
  472.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  473.          goto erret;
  474.       }
  475.       ptr -> name = av.ptrvalue;
  476.       atp = AsnReadId(aip,amp, atp);
  477.    }
  478.    if (atp == DB_ENV_arguments) {
  479.       ptr -> arguments = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) ArgumentAsnRead, (AsnOptFreeFunc) ArgumentFree);
  480.       if (isError && ptr -> arguments == NULL) {
  481.          goto erret;
  482.       }
  483.       atp = AsnReadId(aip,amp, atp);
  484.    }
  485.    if (atp == DB_ENV_filters) {
  486.       ptr -> filters = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) FilterValueAsnRead, (AsnOptFreeFunc) FilterValueFree);
  487.       if (isError && ptr -> filters == NULL) {
  488.          goto erret;
  489.       }
  490.       atp = AsnReadId(aip,amp, atp);
  491.    }
  492.    if (atp == DB_ENV_clipboard) {
  493.       ptr -> clipboard = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DbClipboardAsnRead, (AsnOptFreeFunc) DbClipboardFree);
  494.       if (isError && ptr -> clipboard == NULL) {
  495.          goto erret;
  496.       }
  497.       atp = AsnReadId(aip,amp, atp);
  498.    }
  500.    if (AsnReadVal(aip, atp, &av) <= 0) {
  501.       goto erret;
  502.    }
  503.    /* end struct */
  505. ret:
  506.    AsnUnlinkType(orig);       /* unlink local tree */
  507.    return ptr;
  509. erret:
  510.    aip -> io_failure = TRUE;
  511.    ptr = DbEnvFree(ptr);
  512.    goto ret;
  513. }
  517. /**************************************************
  518. *
  519. *    DbEnvAsnWrite()
  520. *
  521. **************************************************/
  522. NLM_EXTERN Boolean LIBCALL 
  523. DbEnvAsnWrite(DbEnvPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  524. {
  525.    DataVal av;
  526.    AsnTypePtr atp;
  527.    Boolean retval = FALSE;
  529.    if (! loaded)
  530.    {
  531.       if (! twebenvAsnLoad()) {
  532.          return FALSE;
  533.       }
  534.    }
  536.    if (aip == NULL) {
  537.       return FALSE;
  538.    }
  540.    atp = AsnLinkType(orig, DB_ENV);   /* link local tree */
  541.    if (atp == NULL) {
  542.       return FALSE;
  543.    }
  545.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  546.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  547.       goto erret;
  548.    }
  550.    if (ptr -> name != NULL) {
  551.       av.ptrvalue = ptr -> name;
  552.       retval = AsnWrite(aip, DB_ENV_name,  &av);
  553.    }
  554.    AsnGenericUserSeqOfAsnWrite(ptr -> arguments, (AsnWriteFunc) ArgumentAsnWrite, aip, DB_ENV_arguments, DB_ENV_arguments_E);
  555.    AsnGenericUserSeqOfAsnWrite(ptr -> filters, (AsnWriteFunc) FilterValueAsnWrite, aip, DB_ENV_filters, DB_ENV_filters_E);
  556.    AsnGenericUserSeqOfAsnWrite(ptr -> clipboard, (AsnWriteFunc) DbClipboardAsnWrite, aip, DB_ENV_clipboard, DB_ENV_clipboard_E);
  557.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  558.       goto erret;
  559.    }
  560.    retval = TRUE;
  562. erret:
  563.    AsnUnlinkType(orig);       /* unlink local tree */
  564.    return retval;
  565. }
  569. /**************************************************
  570. *
  571. *    QueryHistoryNew()
  572. *
  573. **************************************************/
  574. NLM_EXTERN 
  575. QueryHistoryPtr LIBCALL
  576. QueryHistoryNew(void)
  577. {
  578.    QueryHistoryPtr ptr = MemNew((size_t) sizeof(QueryHistory));
  580.    return ptr;
  582. }
  585. /**************************************************
  586. *
  587. *    QueryHistoryFree()
  588. *
  589. **************************************************/
  590. NLM_EXTERN 
  591. QueryHistoryPtr LIBCALL
  592. QueryHistoryFree(QueryHistoryPtr ptr)
  593. {
  595.    if(ptr == NULL) {
  596.       return NULL;
  597.    }
  598.    MemFree(ptr -> name);
  599.    TimeFree(ptr -> time);
  600.    QueryCommandFree(ptr -> command);
  601.    return MemFree(ptr);
  602. }
  605. /**************************************************
  606. *
  607. *    QueryHistoryAsnRead()
  608. *
  609. **************************************************/
  610. NLM_EXTERN 
  611. QueryHistoryPtr LIBCALL
  612. QueryHistoryAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  613. {
  614.    DataVal av;
  615.    AsnTypePtr atp;
  616.    Boolean isError = FALSE;
  617.    AsnReadFunc func;
  618.    QueryHistoryPtr ptr;
  620.    if (! loaded)
  621.    {
  622.       if (! twebenvAsnLoad()) {
  623.          return NULL;
  624.       }
  625.    }
  627.    if (aip == NULL) {
  628.       return NULL;
  629.    }
  631.    if (orig == NULL) {         /* QueryHistory ::= (self contained) */
  632.       atp = AsnReadId(aip, amp, QUERY_HISTORY);
  633.    } else {
  634.       atp = AsnLinkType(orig, QUERY_HISTORY);
  635.    }
  636.    /* link in local tree */
  637.    if (atp == NULL) {
  638.       return NULL;
  639.    }
  641.    ptr = QueryHistoryNew();
  642.    if (ptr == NULL) {
  643.       goto erret;
  644.    }
  645.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  646.       goto erret;
  647.    }
  649.    atp = AsnReadId(aip,amp, atp);
  650.    func = NULL;
  652.    if (atp == QUERY_HISTORY_name) {
  653.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  654.          goto erret;
  655.       }
  656.       ptr -> name = av.ptrvalue;
  657.       atp = AsnReadId(aip,amp, atp);
  658.    }
  659.    if (atp == QUERY_HISTORY_seqNumber) {
  660.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  661.          goto erret;
  662.       }
  663.       ptr -> seqNumber = av.intvalue;
  664.       atp = AsnReadId(aip,amp, atp);
  665.    }
  666.    if (atp == QUERY_HISTORY_time) {
  667.       ptr -> time = TimeAsnRead(aip, atp);
  668.       if (aip -> io_failure) {
  669.          goto erret;
  670.       }
  671.       atp = AsnReadId(aip,amp, atp);
  672.    }
  673.    if (atp == QUERY_HISTORY_command) {
  674.       ptr -> command = QueryCommandAsnRead(aip, atp);
  675.       if (aip -> io_failure) {
  676.          goto erret;
  677.       }
  678.       atp = AsnReadId(aip,amp, atp);
  679.    }
  681.    if (AsnReadVal(aip, atp, &av) <= 0) {
  682.       goto erret;
  683.    }
  684.    /* end struct */
  686. ret:
  687.    AsnUnlinkType(orig);       /* unlink local tree */
  688.    return ptr;
  690. erret:
  691.    aip -> io_failure = TRUE;
  692.    ptr = QueryHistoryFree(ptr);
  693.    goto ret;
  694. }
  698. /**************************************************
  699. *
  700. *    QueryHistoryAsnWrite()
  701. *
  702. **************************************************/
  703. NLM_EXTERN Boolean LIBCALL 
  704. QueryHistoryAsnWrite(QueryHistoryPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  705. {
  706.    DataVal av;
  707.    AsnTypePtr atp;
  708.    Boolean retval = FALSE;
  710.    if (! loaded)
  711.    {
  712.       if (! twebenvAsnLoad()) {
  713.          return FALSE;
  714.       }
  715.    }
  717.    if (aip == NULL) {
  718.       return FALSE;
  719.    }
  721.    atp = AsnLinkType(orig, QUERY_HISTORY);   /* link local tree */
  722.    if (atp == NULL) {
  723.       return FALSE;
  724.    }
  726.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  727.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  728.       goto erret;
  729.    }
  731.    if (ptr -> name != NULL) {
  732.       av.ptrvalue = ptr -> name;
  733.       retval = AsnWrite(aip, QUERY_HISTORY_name,  &av);
  734.    }
  735.    av.intvalue = ptr -> seqNumber;
  736.    retval = AsnWrite(aip, QUERY_HISTORY_seqNumber,  &av);
  737.    if (ptr -> time != NULL) {
  738.       if ( ! TimeAsnWrite(ptr -> time, aip, QUERY_HISTORY_time)) {
  739.          goto erret;
  740.       }
  741.    }
  742.    if (ptr -> command != NULL) {
  743.       if ( ! QueryCommandAsnWrite(ptr -> command, aip, QUERY_HISTORY_command)) {
  744.          goto erret;
  745.       }
  746.    }
  747.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  748.       goto erret;
  749.    }
  750.    retval = TRUE;
  752. erret:
  753.    AsnUnlinkType(orig);       /* unlink local tree */
  754.    return retval;
  755. }
  759. /**************************************************
  760. *
  761. *    WebSettingsNew()
  762. *
  763. **************************************************/
  764. NLM_EXTERN 
  765. WebSettingsPtr LIBCALL
  766. WebSettingsNew(void)
  767. {
  768.    WebSettingsPtr ptr = MemNew((size_t) sizeof(WebSettings));
  770.    return ptr;
  772. }
  775. /**************************************************
  776. *
  777. *    WebSettingsFree()
  778. *
  779. **************************************************/
  780. NLM_EXTERN 
  781. WebSettingsPtr LIBCALL
  782. WebSettingsFree(WebSettingsPtr ptr)
  783. {
  785.    if(ptr == NULL) {
  786.       return NULL;
  787.    }
  788.    AsnGenericUserSeqOfFree(ptr -> arguments, (AsnOptFreeFunc) ArgumentFree);
  789.    AsnGenericUserSeqOfFree(ptr -> db_Env, (AsnOptFreeFunc) DbEnvFree);
  790.    return MemFree(ptr);
  791. }
  794. /**************************************************
  795. *
  796. *    WebSettingsAsnRead()
  797. *
  798. **************************************************/
  799. NLM_EXTERN 
  800. WebSettingsPtr LIBCALL
  801. WebSettingsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  802. {
  803.    DataVal av;
  804.    AsnTypePtr atp;
  805.    Boolean isError = FALSE;
  806.    AsnReadFunc func;
  807.    WebSettingsPtr ptr;
  809.    if (! loaded)
  810.    {
  811.       if (! twebenvAsnLoad()) {
  812.          return NULL;
  813.       }
  814.    }
  816.    if (aip == NULL) {
  817.       return NULL;
  818.    }
  820.    if (orig == NULL) {         /* WebSettings ::= (self contained) */
  821.       atp = AsnReadId(aip, amp, WEB_SETTINGS);
  822.    } else {
  823.       atp = AsnLinkType(orig, WEB_SETTINGS);
  824.    }
  825.    /* link in local tree */
  826.    if (atp == NULL) {
  827.       return NULL;
  828.    }
  830.    ptr = WebSettingsNew();
  831.    if (ptr == NULL) {
  832.       goto erret;
  833.    }
  834.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  835.       goto erret;
  836.    }
  838.    atp = AsnReadId(aip,amp, atp);
  839.    func = NULL;
  841.    if (atp == WEB_SETTINGS_arguments) {
  842.       ptr -> arguments = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) ArgumentAsnRead, (AsnOptFreeFunc) ArgumentFree);
  843.       if (isError && ptr -> arguments == NULL) {
  844.          goto erret;
  845.       }
  846.       atp = AsnReadId(aip,amp, atp);
  847.    }
  848.    if (atp == WEB_SETTINGS_db_Env) {
  849.       ptr -> db_Env = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DbEnvAsnRead, (AsnOptFreeFunc) DbEnvFree);
  850.       if (isError && ptr -> db_Env == NULL) {
  851.          goto erret;
  852.       }
  853.       atp = AsnReadId(aip,amp, atp);
  854.    }
  856.    if (AsnReadVal(aip, atp, &av) <= 0) {
  857.       goto erret;
  858.    }
  859.    /* end struct */
  861. ret:
  862.    AsnUnlinkType(orig);       /* unlink local tree */
  863.    return ptr;
  865. erret:
  866.    aip -> io_failure = TRUE;
  867.    ptr = WebSettingsFree(ptr);
  868.    goto ret;
  869. }
  873. /**************************************************
  874. *
  875. *    WebSettingsAsnWrite()
  876. *
  877. **************************************************/
  878. NLM_EXTERN Boolean LIBCALL 
  879. WebSettingsAsnWrite(WebSettingsPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  880. {
  881.    DataVal av;
  882.    AsnTypePtr atp;
  883.    Boolean retval = FALSE;
  885.    if (! loaded)
  886.    {
  887.       if (! twebenvAsnLoad()) {
  888.          return FALSE;
  889.       }
  890.    }
  892.    if (aip == NULL) {
  893.       return FALSE;
  894.    }
  896.    atp = AsnLinkType(orig, WEB_SETTINGS);   /* link local tree */
  897.    if (atp == NULL) {
  898.       return FALSE;
  899.    }
  901.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  902.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  903.       goto erret;
  904.    }
  906.    AsnGenericUserSeqOfAsnWrite(ptr -> arguments, (AsnWriteFunc) ArgumentAsnWrite, aip, WEB_SETTINGS_arguments, WEB_SETTINGS_arguments_E);
  907.    AsnGenericUserSeqOfAsnWrite(ptr -> db_Env, (AsnWriteFunc) DbEnvAsnWrite, aip, WEB_SETTINGS_db_Env, WEB_SETTINGS_db_Env_E);
  908.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  909.       goto erret;
  910.    }
  911.    retval = TRUE;
  913. erret:
  914.    AsnUnlinkType(orig);       /* unlink local tree */
  915.    return retval;
  916. }
  920. /**************************************************
  921. *
  922. *    WebSavedNew()
  923. *
  924. **************************************************/
  925. NLM_EXTERN 
  926. WebSavedPtr LIBCALL
  927. WebSavedNew(void)
  928. {
  929.    WebSavedPtr ptr = MemNew((size_t) sizeof(WebSaved));
  931.    return ptr;
  933. }
  936. /**************************************************
  937. *
  938. *    WebSavedFree()
  939. *
  940. **************************************************/
  941. NLM_EXTERN 
  942. WebSavedPtr LIBCALL
  943. WebSavedFree(WebSavedPtr ptr)
  944. {
  946.    if(ptr == NULL) {
  947.       return NULL;
  948.    }
  949.    AsnGenericUserSeqOfFree(ptr -> queries, (AsnOptFreeFunc) NamedQueryFree);
  950.    AsnGenericUserSeqOfFree(ptr -> item_Sets, (AsnOptFreeFunc) NamedItemSetFree);
  951.    return MemFree(ptr);
  952. }
  955. /**************************************************
  956. *
  957. *    WebSavedAsnRead()
  958. *
  959. **************************************************/
  960. NLM_EXTERN 
  961. WebSavedPtr LIBCALL
  962. WebSavedAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  963. {
  964.    DataVal av;
  965.    AsnTypePtr atp;
  966.    Boolean isError = FALSE;
  967.    AsnReadFunc func;
  968.    WebSavedPtr ptr;
  970.    if (! loaded)
  971.    {
  972.       if (! twebenvAsnLoad()) {
  973.          return NULL;
  974.       }
  975.    }
  977.    if (aip == NULL) {
  978.       return NULL;
  979.    }
  981.    if (orig == NULL) {         /* WebSaved ::= (self contained) */
  982.       atp = AsnReadId(aip, amp, WEB_SAVED);
  983.    } else {
  984.       atp = AsnLinkType(orig, WEB_SAVED);
  985.    }
  986.    /* link in local tree */
  987.    if (atp == NULL) {
  988.       return NULL;
  989.    }
  991.    ptr = WebSavedNew();
  992.    if (ptr == NULL) {
  993.       goto erret;
  994.    }
  995.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  996.       goto erret;
  997.    }
  999.    atp = AsnReadId(aip,amp, atp);
  1000.    func = NULL;
  1002.    if (atp == WEB_SAVED_queries) {
  1003.       ptr -> queries = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) NamedQueryAsnRead, (AsnOptFreeFunc) NamedQueryFree);
  1004.       if (isError && ptr -> queries == NULL) {
  1005.          goto erret;
  1006.       }
  1007.       atp = AsnReadId(aip,amp, atp);
  1008.    }
  1009.    if (atp == WEB_SAVED_item_Sets) {
  1010.       ptr -> item_Sets = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) NamedItemSetAsnRead, (AsnOptFreeFunc) NamedItemSetFree);
  1011.       if (isError && ptr -> item_Sets == NULL) {
  1012.          goto erret;
  1013.       }
  1014.       atp = AsnReadId(aip,amp, atp);
  1015.    }
  1017.    if (AsnReadVal(aip, atp, &av) <= 0) {
  1018.       goto erret;
  1019.    }
  1020.    /* end struct */
  1022. ret:
  1023.    AsnUnlinkType(orig);       /* unlink local tree */
  1024.    return ptr;
  1026. erret:
  1027.    aip -> io_failure = TRUE;
  1028.    ptr = WebSavedFree(ptr);
  1029.    goto ret;
  1030. }
  1034. /**************************************************
  1035. *
  1036. *    WebSavedAsnWrite()
  1037. *
  1038. **************************************************/
  1039. NLM_EXTERN Boolean LIBCALL 
  1040. WebSavedAsnWrite(WebSavedPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  1041. {
  1042.    DataVal av;
  1043.    AsnTypePtr atp;
  1044.    Boolean retval = FALSE;
  1046.    if (! loaded)
  1047.    {
  1048.       if (! twebenvAsnLoad()) {
  1049.          return FALSE;
  1050.       }
  1051.    }
  1053.    if (aip == NULL) {
  1054.       return FALSE;
  1055.    }
  1057.    atp = AsnLinkType(orig, WEB_SAVED);   /* link local tree */
  1058.    if (atp == NULL) {
  1059.       return FALSE;
  1060.    }
  1062.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  1063.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  1064.       goto erret;
  1065.    }
  1067.    AsnGenericUserSeqOfAsnWrite(ptr -> queries, (AsnWriteFunc) NamedQueryAsnWrite, aip, WEB_SAVED_queries, WEB_SAVED_queries_E);
  1068.    AsnGenericUserSeqOfAsnWrite(ptr -> item_Sets, (AsnWriteFunc) NamedItemSetAsnWrite, aip, WEB_SAVED_item_Sets, WEB_SAVED_item_Sets_E);
  1069.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  1070.       goto erret;
  1071.    }
  1072.    retval = TRUE;
  1074. erret:
  1075.    AsnUnlinkType(orig);       /* unlink local tree */
  1076.    return retval;
  1077. }
  1081. /**************************************************
  1082. *
  1083. *    NamedQueryNew()
  1084. *
  1085. **************************************************/
  1086. NLM_EXTERN 
  1087. NamedQueryPtr LIBCALL
  1088. NamedQueryNew(void)
  1089. {
  1090.    NamedQueryPtr ptr = MemNew((size_t) sizeof(NamedQuery));
  1092.    return ptr;
  1094. }
  1097. /**************************************************
  1098. *
  1099. *    NamedQueryFree()
  1100. *
  1101. **************************************************/
  1102. NLM_EXTERN 
  1103. NamedQueryPtr LIBCALL
  1104. NamedQueryFree(NamedQueryPtr ptr)
  1105. {
  1107.    if(ptr == NULL) {
  1108.       return NULL;
  1109.    }
  1110.    NameFree(ptr -> name);
  1111.    TimeFree(ptr -> time);
  1112.    QueryCommandFree(ptr -> command);
  1113.    return MemFree(ptr);
  1114. }
  1117. /**************************************************
  1118. *
  1119. *    NamedQueryAsnRead()
  1120. *
  1121. **************************************************/
  1122. NLM_EXTERN 
  1123. NamedQueryPtr LIBCALL
  1124. NamedQueryAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  1125. {
  1126.    DataVal av;
  1127.    AsnTypePtr atp;
  1128.    Boolean isError = FALSE;
  1129.    AsnReadFunc func;
  1130.    NamedQueryPtr ptr;
  1132.    if (! loaded)
  1133.    {
  1134.       if (! twebenvAsnLoad()) {
  1135.          return NULL;
  1136.       }
  1137.    }
  1139.    if (aip == NULL) {
  1140.       return NULL;
  1141.    }
  1143.    if (orig == NULL) {         /* NamedQuery ::= (self contained) */
  1144.       atp = AsnReadId(aip, amp, NAMED_QUERY);
  1145.    } else {
  1146.       atp = AsnLinkType(orig, NAMED_QUERY);
  1147.    }
  1148.    /* link in local tree */
  1149.    if (atp == NULL) {
  1150.       return NULL;
  1151.    }
  1153.    ptr = NamedQueryNew();
  1154.    if (ptr == NULL) {
  1155.       goto erret;
  1156.    }
  1157.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  1158.       goto erret;
  1159.    }
  1161.    atp = AsnReadId(aip,amp, atp);
  1162.    func = NULL;
  1164.    if (atp == NAMED_QUERY_name) {
  1165.       ptr -> name = NameAsnRead(aip, atp);
  1166.       if (aip -> io_failure) {
  1167.          goto erret;
  1168.       }
  1169.       atp = AsnReadId(aip,amp, atp);
  1170.    }
  1171.    if (atp == NAMED_QUERY_time) {
  1172.       ptr -> time = TimeAsnRead(aip, atp);
  1173.       if (aip -> io_failure) {
  1174.          goto erret;
  1175.       }
  1176.       atp = AsnReadId(aip,amp, atp);
  1177.    }
  1178.    if (atp == NAMED_QUERY_command) {
  1179.       ptr -> command = QueryCommandAsnRead(aip, atp);
  1180.       if (aip -> io_failure) {
  1181.          goto erret;
  1182.       }
  1183.       atp = AsnReadId(aip,amp, atp);
  1184.    }
  1186.    if (AsnReadVal(aip, atp, &av) <= 0) {
  1187.       goto erret;
  1188.    }
  1189.    /* end struct */
  1191. ret:
  1192.    AsnUnlinkType(orig);       /* unlink local tree */
  1193.    return ptr;
  1195. erret:
  1196.    aip -> io_failure = TRUE;
  1197.    ptr = NamedQueryFree(ptr);
  1198.    goto ret;
  1199. }
  1203. /**************************************************
  1204. *
  1205. *    NamedQueryAsnWrite()
  1206. *
  1207. **************************************************/
  1208. NLM_EXTERN Boolean LIBCALL 
  1209. NamedQueryAsnWrite(NamedQueryPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  1210. {
  1211.    DataVal av;
  1212.    AsnTypePtr atp;
  1213.    Boolean retval = FALSE;
  1215.    if (! loaded)
  1216.    {
  1217.       if (! twebenvAsnLoad()) {
  1218.          return FALSE;
  1219.       }
  1220.    }
  1222.    if (aip == NULL) {
  1223.       return FALSE;
  1224.    }
  1226.    atp = AsnLinkType(orig, NAMED_QUERY);   /* link local tree */
  1227.    if (atp == NULL) {
  1228.       return FALSE;
  1229.    }
  1231.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  1232.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  1233.       goto erret;
  1234.    }
  1236.    if (ptr -> name != NULL) {
  1237.       if ( ! NameAsnWrite(ptr -> name, aip, NAMED_QUERY_name)) {
  1238.          goto erret;
  1239.       }
  1240.    }
  1241.    if (ptr -> time != NULL) {
  1242.       if ( ! TimeAsnWrite(ptr -> time, aip, NAMED_QUERY_time)) {
  1243.          goto erret;
  1244.       }
  1245.    }
  1246.    if (ptr -> command != NULL) {
  1247.       if ( ! QueryCommandAsnWrite(ptr -> command, aip, NAMED_QUERY_command)) {
  1248.          goto erret;
  1249.       }
  1250.    }
  1251.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  1252.       goto erret;
  1253.    }
  1254.    retval = TRUE;
  1256. erret:
  1257.    AsnUnlinkType(orig);       /* unlink local tree */
  1258.    return retval;
  1259. }
  1263. /**************************************************
  1264. *
  1265. *    NamedItemSetNew()
  1266. *
  1267. **************************************************/
  1268. NLM_EXTERN 
  1269. NamedItemSetPtr LIBCALL
  1270. NamedItemSetNew(void)
  1271. {
  1272.    NamedItemSetPtr ptr = MemNew((size_t) sizeof(NamedItemSet));
  1274.    return ptr;
  1276. }
  1279. /**************************************************
  1280. *
  1281. *    NamedItemSetFree()
  1282. *
  1283. **************************************************/
  1284. NLM_EXTERN 
  1285. NamedItemSetPtr LIBCALL
  1286. NamedItemSetFree(NamedItemSetPtr ptr)
  1287. {
  1289.    if(ptr == NULL) {
  1290.       return NULL;
  1291.    }
  1292.    NameFree(ptr -> name);
  1293.    MemFree(ptr -> db);
  1294.    ItemSetFree(ptr -> item_Set);
  1295.    return MemFree(ptr);
  1296. }
  1299. /**************************************************
  1300. *
  1301. *    NamedItemSetAsnRead()
  1302. *
  1303. **************************************************/
  1304. NLM_EXTERN 
  1305. NamedItemSetPtr LIBCALL
  1306. NamedItemSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  1307. {
  1308.    DataVal av;
  1309.    AsnTypePtr atp;
  1310.    Boolean isError = FALSE;
  1311.    AsnReadFunc func;
  1312.    NamedItemSetPtr ptr;
  1314.    if (! loaded)
  1315.    {
  1316.       if (! twebenvAsnLoad()) {
  1317.          return NULL;
  1318.       }
  1319.    }
  1321.    if (aip == NULL) {
  1322.       return NULL;
  1323.    }
  1325.    if (orig == NULL) {         /* NamedItemSet ::= (self contained) */
  1326.       atp = AsnReadId(aip, amp, NAMED_ITEM_SET);
  1327.    } else {
  1328.       atp = AsnLinkType(orig, NAMED_ITEM_SET);
  1329.    }
  1330.    /* link in local tree */
  1331.    if (atp == NULL) {
  1332.       return NULL;
  1333.    }
  1335.    ptr = NamedItemSetNew();
  1336.    if (ptr == NULL) {
  1337.       goto erret;
  1338.    }
  1339.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  1340.       goto erret;
  1341.    }
  1343.    atp = AsnReadId(aip,amp, atp);
  1344.    func = NULL;
  1346.    if (atp == NAMED_ITEM_SET_name) {
  1347.       ptr -> name = NameAsnRead(aip, atp);
  1348.       if (aip -> io_failure) {
  1349.          goto erret;
  1350.       }
  1351.       atp = AsnReadId(aip,amp, atp);
  1352.    }
  1353.    if (atp == NAMED_ITEM_SET_db) {
  1354.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  1355.          goto erret;
  1356.       }
  1357.       ptr -> db = av.ptrvalue;
  1358.       atp = AsnReadId(aip,amp, atp);
  1359.    }
  1360.    if (atp == NAMED_ITEM_SET_item_Set) {
  1361.       ptr -> item_Set = ItemSetAsnRead(aip, atp);
  1362.       if (aip -> io_failure) {
  1363.          goto erret;
  1364.       }
  1365.       atp = AsnReadId(aip,amp, atp);
  1366.    }
  1368.    if (AsnReadVal(aip, atp, &av) <= 0) {
  1369.       goto erret;
  1370.    }
  1371.    /* end struct */
  1373. ret:
  1374.    AsnUnlinkType(orig);       /* unlink local tree */
  1375.    return ptr;
  1377. erret:
  1378.    aip -> io_failure = TRUE;
  1379.    ptr = NamedItemSetFree(ptr);
  1380.    goto ret;
  1381. }
  1385. /**************************************************
  1386. *
  1387. *    NamedItemSetAsnWrite()
  1388. *
  1389. **************************************************/
  1390. NLM_EXTERN Boolean LIBCALL 
  1391. NamedItemSetAsnWrite(NamedItemSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  1392. {
  1393.    DataVal av;
  1394.    AsnTypePtr atp;
  1395.    Boolean retval = FALSE;
  1397.    if (! loaded)
  1398.    {
  1399.       if (! twebenvAsnLoad()) {
  1400.          return FALSE;
  1401.       }
  1402.    }
  1404.    if (aip == NULL) {
  1405.       return FALSE;
  1406.    }
  1408.    atp = AsnLinkType(orig, NAMED_ITEM_SET);   /* link local tree */
  1409.    if (atp == NULL) {
  1410.       return FALSE;
  1411.    }
  1413.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  1414.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  1415.       goto erret;
  1416.    }
  1418.    if (ptr -> name != NULL) {
  1419.       if ( ! NameAsnWrite(ptr -> name, aip, NAMED_ITEM_SET_name)) {
  1420.          goto erret;
  1421.       }
  1422.    }
  1423.    if (ptr -> db != NULL) {
  1424.       av.ptrvalue = ptr -> db;
  1425.       retval = AsnWrite(aip, NAMED_ITEM_SET_db,  &av);
  1426.    }
  1427.    if (ptr -> item_Set != NULL) {
  1428.       if ( ! ItemSetAsnWrite(ptr -> item_Set, aip, NAMED_ITEM_SET_item_Set)) {
  1429.          goto erret;
  1430.       }
  1431.    }
  1432.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  1433.       goto erret;
  1434.    }
  1435.    retval = TRUE;
  1437. erret:
  1438.    AsnUnlinkType(orig);       /* unlink local tree */
  1439.    return retval;
  1440. }
  1444. /**************************************************
  1445. *
  1446. *    FilterValueNew()
  1447. *
  1448. **************************************************/
  1449. NLM_EXTERN 
  1450. FilterValuePtr LIBCALL
  1451. FilterValueNew(void)
  1452. {
  1453.    FilterValuePtr ptr = MemNew((size_t) sizeof(FilterValue));
  1455.    return ptr;
  1457. }
  1460. /**************************************************
  1461. *
  1462. *    FilterValueFree()
  1463. *
  1464. **************************************************/
  1465. NLM_EXTERN 
  1466. FilterValuePtr LIBCALL
  1467. FilterValueFree(FilterValuePtr ptr)
  1468. {
  1470.    if(ptr == NULL) {
  1471.       return NULL;
  1472.    }
  1473.    MemFree(ptr -> name);
  1474.    MemFree(ptr -> value);
  1475.    return MemFree(ptr);
  1476. }
  1479. /**************************************************
  1480. *
  1481. *    FilterValueAsnRead()
  1482. *
  1483. **************************************************/
  1484. NLM_EXTERN 
  1485. FilterValuePtr LIBCALL
  1486. FilterValueAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  1487. {
  1488.    DataVal av;
  1489.    AsnTypePtr atp;
  1490.    Boolean isError = FALSE;
  1491.    AsnReadFunc func;
  1492.    FilterValuePtr ptr;
  1494.    if (! loaded)
  1495.    {
  1496.       if (! twebenvAsnLoad()) {
  1497.          return NULL;
  1498.       }
  1499.    }
  1501.    if (aip == NULL) {
  1502.       return NULL;
  1503.    }
  1505.    if (orig == NULL) {         /* FilterValue ::= (self contained) */
  1506.       atp = AsnReadId(aip, amp, FILTER_VALUE);
  1507.    } else {
  1508.       atp = AsnLinkType(orig, FILTER_VALUE);
  1509.    }
  1510.    /* link in local tree */
  1511.    if (atp == NULL) {
  1512.       return NULL;
  1513.    }
  1515.    ptr = FilterValueNew();
  1516.    if (ptr == NULL) {
  1517.       goto erret;
  1518.    }
  1519.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  1520.       goto erret;
  1521.    }
  1523.    atp = AsnReadId(aip,amp, atp);
  1524.    func = NULL;
  1526.    if (atp == FILTER_VALUE_name) {
  1527.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  1528.          goto erret;
  1529.       }
  1530.       ptr -> name = av.ptrvalue;
  1531.       atp = AsnReadId(aip,amp, atp);
  1532.    }
  1533.    if (atp == FILTER_VALUE_value) {
  1534.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  1535.          goto erret;
  1536.       }
  1537.       ptr -> value = av.ptrvalue;
  1538.       atp = AsnReadId(aip,amp, atp);
  1539.    }
  1541.    if (AsnReadVal(aip, atp, &av) <= 0) {
  1542.       goto erret;
  1543.    }
  1544.    /* end struct */
  1546. ret:
  1547.    AsnUnlinkType(orig);       /* unlink local tree */
  1548.    return ptr;
  1550. erret:
  1551.    aip -> io_failure = TRUE;
  1552.    ptr = FilterValueFree(ptr);
  1553.    goto ret;
  1554. }
  1558. /**************************************************
  1559. *
  1560. *    FilterValueAsnWrite()
  1561. *
  1562. **************************************************/
  1563. NLM_EXTERN Boolean LIBCALL 
  1564. FilterValueAsnWrite(FilterValuePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  1565. {
  1566.    DataVal av;
  1567.    AsnTypePtr atp;
  1568.    Boolean retval = FALSE;
  1570.    if (! loaded)
  1571.    {
  1572.       if (! twebenvAsnLoad()) {
  1573.          return FALSE;
  1574.       }
  1575.    }
  1577.    if (aip == NULL) {
  1578.       return FALSE;
  1579.    }
  1581.    atp = AsnLinkType(orig, FILTER_VALUE);   /* link local tree */
  1582.    if (atp == NULL) {
  1583.       return FALSE;
  1584.    }
  1586.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  1587.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  1588.       goto erret;
  1589.    }
  1591.    if (ptr -> name != NULL) {
  1592.       av.ptrvalue = ptr -> name;
  1593.       retval = AsnWrite(aip, FILTER_VALUE_name,  &av);
  1594.    }
  1595.    if (ptr -> value != NULL) {
  1596.       av.ptrvalue = ptr -> value;
  1597.       retval = AsnWrite(aip, FILTER_VALUE_value,  &av);
  1598.    }
  1599.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  1600.       goto erret;
  1601.    }
  1602.    retval = TRUE;
  1604. erret:
  1605.    AsnUnlinkType(orig);       /* unlink local tree */
  1606.    return retval;
  1607. }
  1611. /**************************************************
  1612. *
  1613. *    DbClipboardNew()
  1614. *
  1615. **************************************************/
  1616. NLM_EXTERN 
  1617. DbClipboardPtr LIBCALL
  1618. DbClipboardNew(void)
  1619. {
  1620.    DbClipboardPtr ptr = MemNew((size_t) sizeof(DbClipboard));
  1622.    return ptr;
  1624. }
  1627. /**************************************************
  1628. *
  1629. *    DbClipboardFree()
  1630. *
  1631. **************************************************/
  1632. NLM_EXTERN 
  1633. DbClipboardPtr LIBCALL
  1634. DbClipboardFree(DbClipboardPtr ptr)
  1635. {
  1637.    if(ptr == NULL) {
  1638.       return NULL;
  1639.    }
  1640.    MemFree(ptr -> name);
  1641.    ItemSetFree(ptr -> items);
  1642.    return MemFree(ptr);
  1643. }
  1646. /**************************************************
  1647. *
  1648. *    DbClipboardAsnRead()
  1649. *
  1650. **************************************************/
  1651. NLM_EXTERN 
  1652. DbClipboardPtr LIBCALL
  1653. DbClipboardAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  1654. {
  1655.    DataVal av;
  1656.    AsnTypePtr atp;
  1657.    Boolean isError = FALSE;
  1658.    AsnReadFunc func;
  1659.    DbClipboardPtr ptr;
  1661.    if (! loaded)
  1662.    {
  1663.       if (! twebenvAsnLoad()) {
  1664.          return NULL;
  1665.       }
  1666.    }
  1668.    if (aip == NULL) {
  1669.       return NULL;
  1670.    }
  1672.    if (orig == NULL) {         /* DbClipboard ::= (self contained) */
  1673.       atp = AsnReadId(aip, amp, DB_CLIPBOARD);
  1674.    } else {
  1675.       atp = AsnLinkType(orig, DB_CLIPBOARD);
  1676.    }
  1677.    /* link in local tree */
  1678.    if (atp == NULL) {
  1679.       return NULL;
  1680.    }
  1682.    ptr = DbClipboardNew();
  1683.    if (ptr == NULL) {
  1684.       goto erret;
  1685.    }
  1686.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  1687.       goto erret;
  1688.    }
  1690.    atp = AsnReadId(aip,amp, atp);
  1691.    func = NULL;
  1693.    if (atp == DB_CLIPBOARD_name) {
  1694.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  1695.          goto erret;
  1696.       }
  1697.       ptr -> name = av.ptrvalue;
  1698.       atp = AsnReadId(aip,amp, atp);
  1699.    }
  1700.    if (atp == DB_CLIPBOARD_count) {
  1701.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  1702.          goto erret;
  1703.       }
  1704.       ptr -> count = av.intvalue;
  1705.       atp = AsnReadId(aip,amp, atp);
  1706.    }
  1707.    if (atp == DB_CLIPBOARD_items) {
  1708.       ptr -> items = ItemSetAsnRead(aip, atp);
  1709.       if (aip -> io_failure) {
  1710.          goto erret;
  1711.       }
  1712.       atp = AsnReadId(aip,amp, atp);
  1713.    }
  1715.    if (AsnReadVal(aip, atp, &av) <= 0) {
  1716.       goto erret;
  1717.    }
  1718.    /* end struct */
  1720. ret:
  1721.    AsnUnlinkType(orig);       /* unlink local tree */
  1722.    return ptr;
  1724. erret:
  1725.    aip -> io_failure = TRUE;
  1726.    ptr = DbClipboardFree(ptr);
  1727.    goto ret;
  1728. }
  1732. /**************************************************
  1733. *
  1734. *    DbClipboardAsnWrite()
  1735. *
  1736. **************************************************/
  1737. NLM_EXTERN Boolean LIBCALL 
  1738. DbClipboardAsnWrite(DbClipboardPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  1739. {
  1740.    DataVal av;
  1741.    AsnTypePtr atp;
  1742.    Boolean retval = FALSE;
  1744.    if (! loaded)
  1745.    {
  1746.       if (! twebenvAsnLoad()) {
  1747.          return FALSE;
  1748.       }
  1749.    }
  1751.    if (aip == NULL) {
  1752.       return FALSE;
  1753.    }
  1755.    atp = AsnLinkType(orig, DB_CLIPBOARD);   /* link local tree */
  1756.    if (atp == NULL) {
  1757.       return FALSE;
  1758.    }
  1760.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  1761.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  1762.       goto erret;
  1763.    }
  1765.    if (ptr -> name != NULL) {
  1766.       av.ptrvalue = ptr -> name;
  1767.       retval = AsnWrite(aip, DB_CLIPBOARD_name,  &av);
  1768.    }
  1769.    av.intvalue = ptr -> count;
  1770.    retval = AsnWrite(aip, DB_CLIPBOARD_count,  &av);
  1771.    if (ptr -> items != NULL) {
  1772.       if ( ! ItemSetAsnWrite(ptr -> items, aip, DB_CLIPBOARD_items)) {
  1773.          goto erret;
  1774.       }
  1775.    }
  1776.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  1777.       goto erret;
  1778.    }
  1779.    retval = TRUE;
  1781. erret:
  1782.    AsnUnlinkType(orig);       /* unlink local tree */
  1783.    return retval;
  1784. }
  1788. /**************************************************
  1789. *
  1790. *    TimeFree()
  1791. *
  1792. **************************************************/
  1793. NLM_EXTERN 
  1794. TimePtr LIBCALL
  1795. TimeFree(ValNodePtr anp)
  1796. {
  1797.    Pointer pnt;
  1799.    if (anp == NULL) {
  1800.       return NULL;
  1801.    }
  1803.    pnt = anp->data.ptrvalue;
  1804.    switch (anp->choice)
  1805.    {
  1806.    default:
  1807.       break;
  1808.    case Time_full:
  1809.       FullTimeFree(anp -> data.ptrvalue);
  1810.       break;
  1811.    }
  1812.    return MemFree(anp);
  1813. }
  1816. /**************************************************
  1817. *
  1818. *    TimeAsnRead()
  1819. *
  1820. **************************************************/
  1821. NLM_EXTERN 
  1822. TimePtr LIBCALL
  1823. TimeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  1824. {
  1825.    DataVal av;
  1826.    AsnTypePtr atp;
  1827.    ValNodePtr anp;
  1828.    Uint1 choice;
  1829.    Boolean isError = FALSE;
  1830.    Boolean nullIsError = FALSE;
  1831.    AsnReadFunc func;
  1833.    if (! loaded)
  1834.    {
  1835.       if (! twebenvAsnLoad()) {
  1836.          return NULL;
  1837.       }
  1838.    }
  1840.    if (aip == NULL) {
  1841.       return NULL;
  1842.    }
  1844.    if (orig == NULL) {         /* Time ::= (self contained) */
  1845.       atp = AsnReadId(aip, amp, TIME);
  1846.    } else {
  1847.       atp = AsnLinkType(orig, TIME);    /* link in local tree */
  1848.    }
  1849.    if (atp == NULL) {
  1850.       return NULL;
  1851.    }
  1853.    anp = ValNodeNew(NULL);
  1854.    if (anp == NULL) {
  1855.       goto erret;
  1856.    }
  1857.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
  1858.       goto erret;
  1859.    }
  1861.    func = NULL;
  1863.    atp = AsnReadId(aip, amp, atp);  /* find the choice */
  1864.    if (atp == NULL) {
  1865.       goto erret;
  1866.    }
  1867.    if (atp == TIME_unix) {
  1868.       choice = Time_unix;
  1869.       if (AsnReadVal(aip, atp, &av) <= 0) {
  1870.          goto erret;
  1871.       }
  1872.       anp->data.intvalue = av.intvalue;
  1873.    }
  1874.    else if (atp == TIME_full) {
  1875.       choice = Time_full;
  1876.       func = (AsnReadFunc) FullTimeAsnRead;
  1877.    }
  1878.    anp->choice = choice;
  1879.    if (func != NULL)
  1880.    {
  1881.       anp->data.ptrvalue = (* func)(aip, atp);
  1882.       if (aip -> io_failure) goto erret;
  1884.       if (nullIsError && anp->data.ptrvalue == NULL) {
  1885.          goto erret;
  1886.       }
  1887.    }
  1889. ret:
  1890.    AsnUnlinkType(orig);       /* unlink local tree */
  1891.    return anp;
  1893. erret:
  1894.    anp = MemFree(anp);
  1895.    aip -> io_failure = TRUE;
  1896.    goto ret;
  1897. }
  1900. /**************************************************
  1901. *
  1902. *    TimeAsnWrite()
  1903. *
  1904. **************************************************/
  1905. NLM_EXTERN Boolean LIBCALL 
  1906. TimeAsnWrite(TimePtr anp, AsnIoPtr aip, AsnTypePtr orig)
  1908. {
  1909.    DataVal av;
  1910.    AsnTypePtr atp, writetype = NULL;
  1911.    Pointer pnt;
  1912.    AsnWriteFunc func = NULL;
  1913.    Boolean retval = FALSE;
  1915.    if (! loaded)
  1916.    {
  1917.       if (! twebenvAsnLoad())
  1918.       return FALSE;
  1919.    }
  1921.    if (aip == NULL)
  1922.    return FALSE;
  1924.    atp = AsnLinkType(orig, TIME);   /* link local tree */
  1925.    if (atp == NULL) {
  1926.       return FALSE;
  1927.    }
  1929.    if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  1931.    av.ptrvalue = (Pointer)anp;
  1932.    if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
  1933.       goto erret;
  1934.    }
  1936.    pnt = anp->data.ptrvalue;
  1937.    switch (anp->choice)
  1938.    {
  1939.    case Time_unix:
  1940.       av.intvalue = anp->data.intvalue;
  1941.       retval = AsnWrite(aip, TIME_unix, &av);
  1942.       break;
  1943.    case Time_full:
  1944.       writetype = TIME_full;
  1945.       func = (AsnWriteFunc) FullTimeAsnWrite;
  1946.       break;
  1947.    }
  1948.    if (writetype != NULL) {
  1949.       retval = (* func)(pnt, aip, writetype);   /* write it out */
  1950.    }
  1951.    if (!retval) {
  1952.       goto erret;
  1953.    }
  1954.    retval = TRUE;
  1956. erret:
  1957.    AsnUnlinkType(orig);       /* unlink local tree */
  1958.    return retval;
  1959. }
  1962. /**************************************************
  1963. *
  1964. *    QueryCommandFree()
  1965. *
  1966. **************************************************/
  1967. NLM_EXTERN 
  1968. QueryCommandPtr LIBCALL
  1969. QueryCommandFree(ValNodePtr anp)
  1970. {
  1971.    Pointer pnt;
  1973.    if (anp == NULL) {
  1974.       return NULL;
  1975.    }
  1977.    pnt = anp->data.ptrvalue;
  1978.    switch (anp->choice)
  1979.    {
  1980.    default:
  1981.       break;
  1982.    case QueryCommand_search:
  1983.       QuerySearchFree(anp -> data.ptrvalue);
  1984.       break;
  1985.    case QueryCommand_select:
  1986.       QuerySelectFree(anp -> data.ptrvalue);
  1987.       break;
  1988.    case QueryCommand_related:
  1989.       QueryRelatedFree(anp -> data.ptrvalue);
  1990.       break;
  1991.    }
  1992.    return MemFree(anp);
  1993. }
  1996. /**************************************************
  1997. *
  1998. *    QueryCommandAsnRead()
  1999. *
  2000. **************************************************/
  2001. NLM_EXTERN 
  2002. QueryCommandPtr LIBCALL
  2003. QueryCommandAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  2004. {
  2005.    DataVal av;
  2006.    AsnTypePtr atp;
  2007.    ValNodePtr anp;
  2008.    Uint1 choice;
  2009.    Boolean isError = FALSE;
  2010.    Boolean nullIsError = FALSE;
  2011.    AsnReadFunc func;
  2013.    if (! loaded)
  2014.    {
  2015.       if (! twebenvAsnLoad()) {
  2016.          return NULL;
  2017.       }
  2018.    }
  2020.    if (aip == NULL) {
  2021.       return NULL;
  2022.    }
  2024.    if (orig == NULL) {         /* QueryCommand ::= (self contained) */
  2025.       atp = AsnReadId(aip, amp, QUERY_COMMAND);
  2026.    } else {
  2027.       atp = AsnLinkType(orig, QUERY_COMMAND);    /* link in local tree */
  2028.    }
  2029.    if (atp == NULL) {
  2030.       return NULL;
  2031.    }
  2033.    anp = ValNodeNew(NULL);
  2034.    if (anp == NULL) {
  2035.       goto erret;
  2036.    }
  2037.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
  2038.       goto erret;
  2039.    }
  2041.    func = NULL;
  2043.    atp = AsnReadId(aip, amp, atp);  /* find the choice */
  2044.    if (atp == NULL) {
  2045.       goto erret;
  2046.    }
  2047.    if (atp == QUERY_COMMAND_search) {
  2048.       choice = QueryCommand_search;
  2049.       func = (AsnReadFunc) QuerySearchAsnRead;
  2050.    }
  2051.    else if (atp == QUERY_COMMAND_select) {
  2052.       choice = QueryCommand_select;
  2053.       func = (AsnReadFunc) QuerySelectAsnRead;
  2054.    }
  2055.    else if (atp == QUERY_COMMAND_related) {
  2056.       choice = QueryCommand_related;
  2057.       func = (AsnReadFunc) QueryRelatedAsnRead;
  2058.    }
  2059.    anp->choice = choice;
  2060.    if (func != NULL)
  2061.    {
  2062.       anp->data.ptrvalue = (* func)(aip, atp);
  2063.       if (aip -> io_failure) goto erret;
  2065.       if (nullIsError && anp->data.ptrvalue == NULL) {
  2066.          goto erret;
  2067.       }
  2068.    }
  2070. ret:
  2071.    AsnUnlinkType(orig);       /* unlink local tree */
  2072.    return anp;
  2074. erret:
  2075.    anp = MemFree(anp);
  2076.    aip -> io_failure = TRUE;
  2077.    goto ret;
  2078. }
  2081. /**************************************************
  2082. *
  2083. *    QueryCommandAsnWrite()
  2084. *
  2085. **************************************************/
  2086. NLM_EXTERN Boolean LIBCALL 
  2087. QueryCommandAsnWrite(QueryCommandPtr anp, AsnIoPtr aip, AsnTypePtr orig)
  2089. {
  2090.    DataVal av;
  2091.    AsnTypePtr atp, writetype = NULL;
  2092.    Pointer pnt;
  2093.    AsnWriteFunc func = NULL;
  2094.    Boolean retval = FALSE;
  2096.    if (! loaded)
  2097.    {
  2098.       if (! twebenvAsnLoad())
  2099.       return FALSE;
  2100.    }
  2102.    if (aip == NULL)
  2103.    return FALSE;
  2105.    atp = AsnLinkType(orig, QUERY_COMMAND);   /* link local tree */
  2106.    if (atp == NULL) {
  2107.       return FALSE;
  2108.    }
  2110.    if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  2112.    av.ptrvalue = (Pointer)anp;
  2113.    if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
  2114.       goto erret;
  2115.    }
  2117.    pnt = anp->data.ptrvalue;
  2118.    switch (anp->choice)
  2119.    {
  2120.    case QueryCommand_search:
  2121.       writetype = QUERY_COMMAND_search;
  2122.       func = (AsnWriteFunc) QuerySearchAsnWrite;
  2123.       break;
  2124.    case QueryCommand_select:
  2125.       writetype = QUERY_COMMAND_select;
  2126.       func = (AsnWriteFunc) QuerySelectAsnWrite;
  2127.       break;
  2128.    case QueryCommand_related:
  2129.       writetype = QUERY_COMMAND_related;
  2130.       func = (AsnWriteFunc) QueryRelatedAsnWrite;
  2131.       break;
  2132.    }
  2133.    if (writetype != NULL) {
  2134.       retval = (* func)(pnt, aip, writetype);   /* write it out */
  2135.    }
  2136.    if (!retval) {
  2137.       goto erret;
  2138.    }
  2139.    retval = TRUE;
  2141. erret:
  2142.    AsnUnlinkType(orig);       /* unlink local tree */
  2143.    return retval;
  2144. }
  2147. /**************************************************
  2148. *
  2149. *    QuerySearchNew()
  2150. *
  2151. **************************************************/
  2152. NLM_EXTERN 
  2153. QuerySearchPtr LIBCALL
  2154. QuerySearchNew(void)
  2155. {
  2156.    QuerySearchPtr ptr = MemNew((size_t) sizeof(QuerySearch));
  2158.    return ptr;
  2160. }
  2163. /**************************************************
  2164. *
  2165. *    QuerySearchFree()
  2166. *
  2167. **************************************************/
  2168. NLM_EXTERN 
  2169. QuerySearchPtr LIBCALL
  2170. QuerySearchFree(QuerySearchPtr ptr)
  2171. {
  2173.    if(ptr == NULL) {
  2174.       return NULL;
  2175.    }
  2176.    MemFree(ptr -> db);
  2177.    MemFree(ptr -> term);
  2178.    MemFree(ptr -> field);
  2179.    AsnGenericUserSeqOfFree(ptr -> filters, (AsnOptFreeFunc) FilterValueFree);
  2180.    return MemFree(ptr);
  2181. }
  2184. /**************************************************
  2185. *
  2186. *    QuerySearchAsnRead()
  2187. *
  2188. **************************************************/
  2189. NLM_EXTERN 
  2190. QuerySearchPtr LIBCALL
  2191. QuerySearchAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  2192. {
  2193.    DataVal av;
  2194.    AsnTypePtr atp;
  2195.    Boolean isError = FALSE;
  2196.    AsnReadFunc func;
  2197.    QuerySearchPtr ptr;
  2199.    if (! loaded)
  2200.    {
  2201.       if (! twebenvAsnLoad()) {
  2202.          return NULL;
  2203.       }
  2204.    }
  2206.    if (aip == NULL) {
  2207.       return NULL;
  2208.    }
  2210.    if (orig == NULL) {         /* QuerySearch ::= (self contained) */
  2211.       atp = AsnReadId(aip, amp, QUERY_SEARCH);
  2212.    } else {
  2213.       atp = AsnLinkType(orig, QUERY_SEARCH);
  2214.    }
  2215.    /* link in local tree */
  2216.    if (atp == NULL) {
  2217.       return NULL;
  2218.    }
  2220.    ptr = QuerySearchNew();
  2221.    if (ptr == NULL) {
  2222.       goto erret;
  2223.    }
  2224.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  2225.       goto erret;
  2226.    }
  2228.    atp = AsnReadId(aip,amp, atp);
  2229.    func = NULL;
  2231.    if (atp == QUERY_SEARCH_db) {
  2232.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2233.          goto erret;
  2234.       }
  2235.       ptr -> db = av.ptrvalue;
  2236.       atp = AsnReadId(aip,amp, atp);
  2237.    }
  2238.    if (atp == QUERY_SEARCH_term) {
  2239.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2240.          goto erret;
  2241.       }
  2242.       ptr -> term = av.ptrvalue;
  2243.       atp = AsnReadId(aip,amp, atp);
  2244.    }
  2245.    if (atp == QUERY_SEARCH_field) {
  2246.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2247.          goto erret;
  2248.       }
  2249.       ptr -> field = av.ptrvalue;
  2250.       atp = AsnReadId(aip,amp, atp);
  2251.    }
  2252.    if (atp == QUERY_SEARCH_filters) {
  2253.       ptr -> filters = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) FilterValueAsnRead, (AsnOptFreeFunc) FilterValueFree);
  2254.       if (isError && ptr -> filters == NULL) {
  2255.          goto erret;
  2256.       }
  2257.       atp = AsnReadId(aip,amp, atp);
  2258.    }
  2259.    if (atp == QUERY_SEARCH_count) {
  2260.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2261.          goto erret;
  2262.       }
  2263.       ptr -> count = av.intvalue;
  2264.       atp = AsnReadId(aip,amp, atp);
  2265.    }
  2266.    if (atp == QUERY_SEARCH_flags) {
  2267.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2268.          goto erret;
  2269.       }
  2270.       ptr -> flags = av.intvalue;
  2271.       atp = AsnReadId(aip,amp, atp);
  2272.    }
  2274.    if (AsnReadVal(aip, atp, &av) <= 0) {
  2275.       goto erret;
  2276.    }
  2277.    /* end struct */
  2279. ret:
  2280.    AsnUnlinkType(orig);       /* unlink local tree */
  2281.    return ptr;
  2283. erret:
  2284.    aip -> io_failure = TRUE;
  2285.    ptr = QuerySearchFree(ptr);
  2286.    goto ret;
  2287. }
  2291. /**************************************************
  2292. *
  2293. *    QuerySearchAsnWrite()
  2294. *
  2295. **************************************************/
  2296. NLM_EXTERN Boolean LIBCALL 
  2297. QuerySearchAsnWrite(QuerySearchPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  2298. {
  2299.    DataVal av;
  2300.    AsnTypePtr atp;
  2301.    Boolean retval = FALSE;
  2303.    if (! loaded)
  2304.    {
  2305.       if (! twebenvAsnLoad()) {
  2306.          return FALSE;
  2307.       }
  2308.    }
  2310.    if (aip == NULL) {
  2311.       return FALSE;
  2312.    }
  2314.    atp = AsnLinkType(orig, QUERY_SEARCH);   /* link local tree */
  2315.    if (atp == NULL) {
  2316.       return FALSE;
  2317.    }
  2319.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  2320.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  2321.       goto erret;
  2322.    }
  2324.    if (ptr -> db != NULL) {
  2325.       av.ptrvalue = ptr -> db;
  2326.       retval = AsnWrite(aip, QUERY_SEARCH_db,  &av);
  2327.    }
  2328.    if (ptr -> term != NULL) {
  2329.       av.ptrvalue = ptr -> term;
  2330.       retval = AsnWrite(aip, QUERY_SEARCH_term,  &av);
  2331.    }
  2332.    if (ptr -> field != NULL) {
  2333.       av.ptrvalue = ptr -> field;
  2334.       retval = AsnWrite(aip, QUERY_SEARCH_field,  &av);
  2335.    }
  2336.    AsnGenericUserSeqOfAsnWrite(ptr -> filters, (AsnWriteFunc) FilterValueAsnWrite, aip, QUERY_SEARCH_filters, QUERY_SEARCH_filters_E);
  2337.    av.intvalue = ptr -> count;
  2338.    retval = AsnWrite(aip, QUERY_SEARCH_count,  &av);
  2339.    av.intvalue = ptr -> flags;
  2340.    retval = AsnWrite(aip, QUERY_SEARCH_flags,  &av);
  2341.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  2342.       goto erret;
  2343.    }
  2344.    retval = TRUE;
  2346. erret:
  2347.    AsnUnlinkType(orig);       /* unlink local tree */
  2348.    return retval;
  2349. }
  2353. /**************************************************
  2354. *
  2355. *    QuerySelectNew()
  2356. *
  2357. **************************************************/
  2358. NLM_EXTERN 
  2359. QuerySelectPtr LIBCALL
  2360. QuerySelectNew(void)
  2361. {
  2362.    QuerySelectPtr ptr = MemNew((size_t) sizeof(QuerySelect));
  2364.    return ptr;
  2366. }
  2369. /**************************************************
  2370. *
  2371. *    QuerySelectFree()
  2372. *
  2373. **************************************************/
  2374. NLM_EXTERN 
  2375. QuerySelectPtr LIBCALL
  2376. QuerySelectFree(QuerySelectPtr ptr)
  2377. {
  2379.    if(ptr == NULL) {
  2380.       return NULL;
  2381.    }
  2382.    MemFree(ptr -> db);
  2383.    ItemSetFree(ptr -> items);
  2384.    return MemFree(ptr);
  2385. }
  2388. /**************************************************
  2389. *
  2390. *    QuerySelectAsnRead()
  2391. *
  2392. **************************************************/
  2393. NLM_EXTERN 
  2394. QuerySelectPtr LIBCALL
  2395. QuerySelectAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  2396. {
  2397.    DataVal av;
  2398.    AsnTypePtr atp;
  2399.    Boolean isError = FALSE;
  2400.    AsnReadFunc func;
  2401.    QuerySelectPtr ptr;
  2403.    if (! loaded)
  2404.    {
  2405.       if (! twebenvAsnLoad()) {
  2406.          return NULL;
  2407.       }
  2408.    }
  2410.    if (aip == NULL) {
  2411.       return NULL;
  2412.    }
  2414.    if (orig == NULL) {         /* QuerySelect ::= (self contained) */
  2415.       atp = AsnReadId(aip, amp, QUERY_SELECT);
  2416.    } else {
  2417.       atp = AsnLinkType(orig, QUERY_SELECT);
  2418.    }
  2419.    /* link in local tree */
  2420.    if (atp == NULL) {
  2421.       return NULL;
  2422.    }
  2424.    ptr = QuerySelectNew();
  2425.    if (ptr == NULL) {
  2426.       goto erret;
  2427.    }
  2428.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  2429.       goto erret;
  2430.    }
  2432.    atp = AsnReadId(aip,amp, atp);
  2433.    func = NULL;
  2435.    if (atp == QUERY_SELECT_db) {
  2436.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2437.          goto erret;
  2438.       }
  2439.       ptr -> db = av.ptrvalue;
  2440.       atp = AsnReadId(aip,amp, atp);
  2441.    }
  2442.    if (atp == QUERY_SELECT_items) {
  2443.       ptr -> items = ItemSetAsnRead(aip, atp);
  2444.       if (aip -> io_failure) {
  2445.          goto erret;
  2446.       }
  2447.       atp = AsnReadId(aip,amp, atp);
  2448.    }
  2450.    if (AsnReadVal(aip, atp, &av) <= 0) {
  2451.       goto erret;
  2452.    }
  2453.    /* end struct */
  2455. ret:
  2456.    AsnUnlinkType(orig);       /* unlink local tree */
  2457.    return ptr;
  2459. erret:
  2460.    aip -> io_failure = TRUE;
  2461.    ptr = QuerySelectFree(ptr);
  2462.    goto ret;
  2463. }
  2467. /**************************************************
  2468. *
  2469. *    QuerySelectAsnWrite()
  2470. *
  2471. **************************************************/
  2472. NLM_EXTERN Boolean LIBCALL 
  2473. QuerySelectAsnWrite(QuerySelectPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  2474. {
  2475.    DataVal av;
  2476.    AsnTypePtr atp;
  2477.    Boolean retval = FALSE;
  2479.    if (! loaded)
  2480.    {
  2481.       if (! twebenvAsnLoad()) {
  2482.          return FALSE;
  2483.       }
  2484.    }
  2486.    if (aip == NULL) {
  2487.       return FALSE;
  2488.    }
  2490.    atp = AsnLinkType(orig, QUERY_SELECT);   /* link local tree */
  2491.    if (atp == NULL) {
  2492.       return FALSE;
  2493.    }
  2495.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  2496.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  2497.       goto erret;
  2498.    }
  2500.    if (ptr -> db != NULL) {
  2501.       av.ptrvalue = ptr -> db;
  2502.       retval = AsnWrite(aip, QUERY_SELECT_db,  &av);
  2503.    }
  2504.    if (ptr -> items != NULL) {
  2505.       if ( ! ItemSetAsnWrite(ptr -> items, aip, QUERY_SELECT_items)) {
  2506.          goto erret;
  2507.       }
  2508.    }
  2509.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  2510.       goto erret;
  2511.    }
  2512.    retval = TRUE;
  2514. erret:
  2515.    AsnUnlinkType(orig);       /* unlink local tree */
  2516.    return retval;
  2517. }
  2521. /**************************************************
  2522. *
  2523. *    QueryRelatedNew()
  2524. *
  2525. **************************************************/
  2526. NLM_EXTERN 
  2527. QueryRelatedPtr LIBCALL
  2528. QueryRelatedNew(void)
  2529. {
  2530.    QueryRelatedPtr ptr = MemNew((size_t) sizeof(QueryRelated));
  2532.    return ptr;
  2534. }
  2537. /**************************************************
  2538. *
  2539. *    QueryRelatedFree()
  2540. *
  2541. **************************************************/
  2542. NLM_EXTERN 
  2543. QueryRelatedPtr LIBCALL
  2544. QueryRelatedFree(QueryRelatedPtr ptr)
  2545. {
  2547.    if(ptr == NULL) {
  2548.       return NULL;
  2549.    }
  2550.    QueryCommandFree(ptr -> base);
  2551.    MemFree(ptr -> relation);
  2552.    MemFree(ptr -> db);
  2553.    Items_itemsFree(ptr -> Items_items);
  2554.    return MemFree(ptr);
  2555. }
  2558. /**************************************************
  2559. *
  2560. *    Items_itemsFree()
  2561. *
  2562. **************************************************/
  2563. static 
  2564. Items_itemsPtr LIBCALL
  2565. Items_itemsFree(ValNodePtr anp)
  2566. {
  2567.    Pointer pnt;
  2569.    if (anp == NULL) {
  2570.       return NULL;
  2571.    }
  2573.    pnt = anp->data.ptrvalue;
  2574.    switch (anp->choice)
  2575.    {
  2576.    default:
  2577.       break;
  2578.    case Items_items_items:
  2579.       ItemSetFree(anp -> data.ptrvalue);
  2580.       break;
  2581.    }
  2582.    return MemFree(anp);
  2583. }
  2586. /**************************************************
  2587. *
  2588. *    QueryRelatedAsnRead()
  2589. *
  2590. **************************************************/
  2591. NLM_EXTERN 
  2592. QueryRelatedPtr LIBCALL
  2593. QueryRelatedAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  2594. {
  2595.    DataVal av;
  2596.    AsnTypePtr atp;
  2597.    Boolean isError = FALSE;
  2598.    AsnReadFunc func;
  2599.    QueryRelatedPtr ptr;
  2601.    if (! loaded)
  2602.    {
  2603.       if (! twebenvAsnLoad()) {
  2604.          return NULL;
  2605.       }
  2606.    }
  2608.    if (aip == NULL) {
  2609.       return NULL;
  2610.    }
  2612.    if (orig == NULL) {         /* QueryRelated ::= (self contained) */
  2613.       atp = AsnReadId(aip, amp, QUERY_RELATED);
  2614.    } else {
  2615.       atp = AsnLinkType(orig, QUERY_RELATED);
  2616.    }
  2617.    /* link in local tree */
  2618.    if (atp == NULL) {
  2619.       return NULL;
  2620.    }
  2622.    ptr = QueryRelatedNew();
  2623.    if (ptr == NULL) {
  2624.       goto erret;
  2625.    }
  2626.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  2627.       goto erret;
  2628.    }
  2630.    atp = AsnReadId(aip,amp, atp);
  2631.    func = NULL;
  2633.    if (atp == QUERY_RELATED_base) {
  2634.       ptr -> base = QueryCommandAsnRead(aip, atp);
  2635.       if (aip -> io_failure) {
  2636.          goto erret;
  2637.       }
  2638.       atp = AsnReadId(aip,amp, atp);
  2639.    }
  2640.    if (atp == QUERY_RELATED_relation) {
  2641.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2642.          goto erret;
  2643.       }
  2644.       ptr -> relation = av.ptrvalue;
  2645.       atp = AsnReadId(aip,amp, atp);
  2646.    }
  2647.    if (atp == QUERY_RELATED_db) {
  2648.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2649.          goto erret;
  2650.       }
  2651.       ptr -> db = av.ptrvalue;
  2652.       atp = AsnReadId(aip,amp, atp);
  2653.    }
  2654.    if (atp == QUERY_RELATED_items) {
  2655.       ptr -> Items_items = Items_itemsAsnRead(aip, atp);
  2656.       if (aip -> io_failure) {
  2657.          goto erret;
  2658.       }
  2659.       atp = AsnReadId(aip,amp, atp);
  2660.    }
  2662.    if (AsnReadVal(aip, atp, &av) <= 0) {
  2663.       goto erret;
  2664.    }
  2665.    /* end struct */
  2667. ret:
  2668.    AsnUnlinkType(orig);       /* unlink local tree */
  2669.    return ptr;
  2671. erret:
  2672.    aip -> io_failure = TRUE;
  2673.    ptr = QueryRelatedFree(ptr);
  2674.    goto ret;
  2675. }
  2679. /**************************************************
  2680. *
  2681. *    Items_itemsAsnRead()
  2682. *
  2683. **************************************************/
  2684. static 
  2685. Items_itemsPtr LIBCALL
  2686. Items_itemsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  2687. {
  2688.    DataVal av;
  2689.    AsnTypePtr atp;
  2690.    ValNodePtr anp;
  2691.    Uint1 choice;
  2692.    Boolean isError = FALSE;
  2693.    Boolean nullIsError = FALSE;
  2694.    AsnReadFunc func;
  2696.    if (! loaded)
  2697.    {
  2698.       if (! twebenvAsnLoad()) {
  2699.          return NULL;
  2700.       }
  2701.    }
  2703.    if (aip == NULL) {
  2704.       return NULL;
  2705.    }
  2707.    if (orig == NULL) {         /* Items_items ::= (self contained) */
  2708.       atp = AsnReadId(aip, amp, QUERY_RELATED_items);
  2709.    } else {
  2710.       atp = AsnLinkType(orig, QUERY_RELATED_items);    /* link in local tree */
  2711.    }
  2712.    if (atp == NULL) {
  2713.       return NULL;
  2714.    }
  2716.    anp = ValNodeNew(NULL);
  2717.    if (anp == NULL) {
  2718.       goto erret;
  2719.    }
  2720.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
  2721.       goto erret;
  2722.    }
  2724.    func = NULL;
  2726.    atp = AsnReadId(aip, amp, atp);  /* find the choice */
  2727.    if (atp == NULL) {
  2728.       goto erret;
  2729.    }
  2730.    if (atp == QUERY_RELATED_items_items) {
  2731.       choice = Items_items_items;
  2732.       func = (AsnReadFunc) ItemSetAsnRead;
  2733.    }
  2734.    else if (atp == QUERY_RELATED_items_itemCount) {
  2735.       choice = Items_items_itemCount;
  2736.       if (AsnReadVal(aip, atp, &av) <= 0) {
  2737.          goto erret;
  2738.       }
  2739.       anp->data.intvalue = av.intvalue;
  2740.    }
  2741.    anp->choice = choice;
  2742.    if (func != NULL)
  2743.    {
  2744.       anp->data.ptrvalue = (* func)(aip, atp);
  2745.       if (aip -> io_failure) goto erret;
  2747.       if (nullIsError && anp->data.ptrvalue == NULL) {
  2748.          goto erret;
  2749.       }
  2750.    }
  2752. ret:
  2753.    AsnUnlinkType(orig);       /* unlink local tree */
  2754.    return anp;
  2756. erret:
  2757.    anp = MemFree(anp);
  2758.    aip -> io_failure = TRUE;
  2759.    goto ret;
  2760. }
  2763. /**************************************************
  2764. *
  2765. *    QueryRelatedAsnWrite()
  2766. *
  2767. **************************************************/
  2768. NLM_EXTERN Boolean LIBCALL 
  2769. QueryRelatedAsnWrite(QueryRelatedPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  2770. {
  2771.    DataVal av;
  2772.    AsnTypePtr atp;
  2773.    Boolean retval = FALSE;
  2775.    if (! loaded)
  2776.    {
  2777.       if (! twebenvAsnLoad()) {
  2778.          return FALSE;
  2779.       }
  2780.    }
  2782.    if (aip == NULL) {
  2783.       return FALSE;
  2784.    }
  2786.    atp = AsnLinkType(orig, QUERY_RELATED);   /* link local tree */
  2787.    if (atp == NULL) {
  2788.       return FALSE;
  2789.    }
  2791.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  2792.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  2793.       goto erret;
  2794.    }
  2796.    if (ptr -> base != NULL) {
  2797.       if ( ! QueryCommandAsnWrite(ptr -> base, aip, QUERY_RELATED_base)) {
  2798.          goto erret;
  2799.       }
  2800.    }
  2801.    if (ptr -> relation != NULL) {
  2802.       av.ptrvalue = ptr -> relation;
  2803.       retval = AsnWrite(aip, QUERY_RELATED_relation,  &av);
  2804.    }
  2805.    if (ptr -> db != NULL) {
  2806.       av.ptrvalue = ptr -> db;
  2807.       retval = AsnWrite(aip, QUERY_RELATED_db,  &av);
  2808.    }
  2809.    if (ptr -> Items_items != NULL) {
  2810.       if ( ! Items_itemsAsnWrite(ptr -> Items_items, aip, QUERY_RELATED_items)) {
  2811.          goto erret;
  2812.       }
  2813.    }
  2814.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  2815.       goto erret;
  2816.    }
  2817.    retval = TRUE;
  2819. erret:
  2820.    AsnUnlinkType(orig);       /* unlink local tree */
  2821.    return retval;
  2822. }
  2826. /**************************************************
  2827. *
  2828. *    Items_itemsAsnWrite()
  2829. *
  2830. **************************************************/
  2831. static Boolean LIBCALL 
  2832. Items_itemsAsnWrite(Items_itemsPtr anp, AsnIoPtr aip, AsnTypePtr orig)
  2834. {
  2835.    DataVal av;
  2836.    AsnTypePtr atp, writetype = NULL;
  2837.    Pointer pnt;
  2838.    AsnWriteFunc func = NULL;
  2839.    Boolean retval = FALSE;
  2841.    if (! loaded)
  2842.    {
  2843.       if (! twebenvAsnLoad())
  2844.       return FALSE;
  2845.    }
  2847.    if (aip == NULL)
  2848.    return FALSE;
  2850.    atp = AsnLinkType(orig, QUERY_RELATED_items);   /* link local tree */
  2851.    if (atp == NULL) {
  2852.       return FALSE;
  2853.    }
  2855.    if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  2857.    av.ptrvalue = (Pointer)anp;
  2858.    if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
  2859.       goto erret;
  2860.    }
  2862.    pnt = anp->data.ptrvalue;
  2863.    switch (anp->choice)
  2864.    {
  2865.    case Items_items_items:
  2866.       writetype = QUERY_RELATED_items_items;
  2867.       func = (AsnWriteFunc) ItemSetAsnWrite;
  2868.       break;
  2869.    case Items_items_itemCount:
  2870.       av.intvalue = anp->data.intvalue;
  2871.       retval = AsnWrite(aip, QUERY_RELATED_items_itemCount, &av);
  2872.       break;
  2873.    }
  2874.    if (writetype != NULL) {
  2875.       retval = (* func)(pnt, aip, writetype);   /* write it out */
  2876.    }
  2877.    if (!retval) {
  2878.       goto erret;
  2879.    }
  2880.    retval = TRUE;
  2882. erret:
  2883.    AsnUnlinkType(orig);       /* unlink local tree */
  2884.    return retval;
  2885. }
  2888. /**************************************************
  2889. *
  2890. *    ItemSetNew()
  2891. *
  2892. **************************************************/
  2893. NLM_EXTERN 
  2894. ItemSetPtr LIBCALL
  2895. ItemSetNew(void)
  2896. {
  2897.    ItemSetPtr ptr = MemNew((size_t) sizeof(ItemSet));
  2899.    return ptr;
  2901. }
  2904. /**************************************************
  2905. *
  2906. *    ItemSetFree()
  2907. *
  2908. **************************************************/
  2909. NLM_EXTERN 
  2910. ItemSetPtr LIBCALL
  2911. ItemSetFree(ItemSetPtr ptr)
  2912. {
  2914.    if(ptr == NULL) {
  2915.       return NULL;
  2916.    }
  2917.    BSFree(ptr -> items);
  2918.    return MemFree(ptr);
  2919. }
  2922. /**************************************************
  2923. *
  2924. *    ItemSetAsnRead()
  2925. *
  2926. **************************************************/
  2927. NLM_EXTERN 
  2928. ItemSetPtr LIBCALL
  2929. ItemSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  2930. {
  2931.    DataVal av;
  2932.    AsnTypePtr atp;
  2933.    Boolean isError = FALSE;
  2934.    AsnReadFunc func;
  2935.    ItemSetPtr ptr;
  2937.    if (! loaded)
  2938.    {
  2939.       if (! twebenvAsnLoad()) {
  2940.          return NULL;
  2941.       }
  2942.    }
  2944.    if (aip == NULL) {
  2945.       return NULL;
  2946.    }
  2948.    if (orig == NULL) {         /* ItemSet ::= (self contained) */
  2949.       atp = AsnReadId(aip, amp, ITEM_SET);
  2950.    } else {
  2951.       atp = AsnLinkType(orig, ITEM_SET);
  2952.    }
  2953.    /* link in local tree */
  2954.    if (atp == NULL) {
  2955.       return NULL;
  2956.    }
  2958.    ptr = ItemSetNew();
  2959.    if (ptr == NULL) {
  2960.       goto erret;
  2961.    }
  2962.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  2963.       goto erret;
  2964.    }
  2966.    atp = AsnReadId(aip,amp, atp);
  2967.    func = NULL;
  2969.    if (atp == ITEM_SET_items) {
  2970.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2971.          goto erret;
  2972.       }
  2973.       ptr -> items = av.ptrvalue;
  2974.       atp = AsnReadId(aip,amp, atp);
  2975.    }
  2976.    if (atp == ITEM_SET_count) {
  2977.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  2978.          goto erret;
  2979.       }
  2980.       ptr -> count = av.intvalue;
  2981.       atp = AsnReadId(aip,amp, atp);
  2982.    }
  2984.    if (AsnReadVal(aip, atp, &av) <= 0) {
  2985.       goto erret;
  2986.    }
  2987.    /* end struct */
  2989. ret:
  2990.    AsnUnlinkType(orig);       /* unlink local tree */
  2991.    return ptr;
  2993. erret:
  2994.    aip -> io_failure = TRUE;
  2995.    ptr = ItemSetFree(ptr);
  2996.    goto ret;
  2997. }
  3001. /**************************************************
  3002. *
  3003. *    ItemSetAsnWrite()
  3004. *
  3005. **************************************************/
  3006. NLM_EXTERN Boolean LIBCALL 
  3007. ItemSetAsnWrite(ItemSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  3008. {
  3009.    DataVal av;
  3010.    AsnTypePtr atp;
  3011.    Boolean retval = FALSE;
  3013.    if (! loaded)
  3014.    {
  3015.       if (! twebenvAsnLoad()) {
  3016.          return FALSE;
  3017.       }
  3018.    }
  3020.    if (aip == NULL) {
  3021.       return FALSE;
  3022.    }
  3024.    atp = AsnLinkType(orig, ITEM_SET);   /* link local tree */
  3025.    if (atp == NULL) {
  3026.       return FALSE;
  3027.    }
  3029.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  3030.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  3031.       goto erret;
  3032.    }
  3034.    if (ptr -> items != NULL) {
  3035.       av.ptrvalue = ptr -> items;
  3036.       retval = AsnWrite(aip, ITEM_SET_items,  &av);
  3037.    }
  3038.    av.intvalue = ptr -> count;
  3039.    retval = AsnWrite(aip, ITEM_SET_count,  &av);
  3040.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  3041.       goto erret;
  3042.    }
  3043.    retval = TRUE;
  3045. erret:
  3046.    AsnUnlinkType(orig);       /* unlink local tree */
  3047.    return retval;
  3048. }
  3052. /**************************************************
  3053. *
  3054. *    FullTimeNew()
  3055. *
  3056. **************************************************/
  3057. NLM_EXTERN 
  3058. FullTimePtr LIBCALL
  3059. FullTimeNew(void)
  3060. {
  3061.    FullTimePtr ptr = MemNew((size_t) sizeof(FullTime));
  3063.    return ptr;
  3065. }
  3068. /**************************************************
  3069. *
  3070. *    FullTimeFree()
  3071. *
  3072. **************************************************/
  3073. NLM_EXTERN 
  3074. FullTimePtr LIBCALL
  3075. FullTimeFree(FullTimePtr ptr)
  3076. {
  3078.    if(ptr == NULL) {
  3079.       return NULL;
  3080.    }
  3081.    return MemFree(ptr);
  3082. }
  3085. /**************************************************
  3086. *
  3087. *    FullTimeAsnRead()
  3088. *
  3089. **************************************************/
  3090. NLM_EXTERN 
  3091. FullTimePtr LIBCALL
  3092. FullTimeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  3093. {
  3094.    DataVal av;
  3095.    AsnTypePtr atp;
  3096.    Boolean isError = FALSE;
  3097.    AsnReadFunc func;
  3098.    FullTimePtr ptr;
  3100.    if (! loaded)
  3101.    {
  3102.       if (! twebenvAsnLoad()) {
  3103.          return NULL;
  3104.       }
  3105.    }
  3107.    if (aip == NULL) {
  3108.       return NULL;
  3109.    }
  3111.    if (orig == NULL) {         /* FullTime ::= (self contained) */
  3112.       atp = AsnReadId(aip, amp, FULL_TIME);
  3113.    } else {
  3114.       atp = AsnLinkType(orig, FULL_TIME);
  3115.    }
  3116.    /* link in local tree */
  3117.    if (atp == NULL) {
  3118.       return NULL;
  3119.    }
  3121.    ptr = FullTimeNew();
  3122.    if (ptr == NULL) {
  3123.       goto erret;
  3124.    }
  3125.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  3126.       goto erret;
  3127.    }
  3129.    atp = AsnReadId(aip,amp, atp);
  3130.    func = NULL;
  3132.    if (atp == FULL_TIME_year) {
  3133.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  3134.          goto erret;
  3135.       }
  3136.       ptr -> year = av.intvalue;
  3137.       atp = AsnReadId(aip,amp, atp);
  3138.    }
  3139.    if (atp == FULL_TIME_month) {
  3140.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  3141.          goto erret;
  3142.       }
  3143.       ptr -> month = av.intvalue;
  3144.       atp = AsnReadId(aip,amp, atp);
  3145.    }
  3146.    if (atp == FULL_TIME_day) {
  3147.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  3148.          goto erret;
  3149.       }
  3150.       ptr -> day = av.intvalue;
  3151.       atp = AsnReadId(aip,amp, atp);
  3152.    }
  3153.    if (atp == FULL_TIME_hour) {
  3154.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  3155.          goto erret;
  3156.       }
  3157.       ptr -> hour = av.intvalue;
  3158.       atp = AsnReadId(aip,amp, atp);
  3159.    }
  3160.    if (atp == FULL_TIME_minute) {
  3161.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  3162.          goto erret;
  3163.       }
  3164.       ptr -> minute = av.intvalue;
  3165.       atp = AsnReadId(aip,amp, atp);
  3166.    }
  3167.    if (atp == FULL_TIME_second) {
  3168.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  3169.          goto erret;
  3170.       }
  3171.       ptr -> second = av.intvalue;
  3172.       atp = AsnReadId(aip,amp, atp);
  3173.    }
  3175.    if (AsnReadVal(aip, atp, &av) <= 0) {
  3176.       goto erret;
  3177.    }
  3178.    /* end struct */
  3180. ret:
  3181.    AsnUnlinkType(orig);       /* unlink local tree */
  3182.    return ptr;
  3184. erret:
  3185.    aip -> io_failure = TRUE;
  3186.    ptr = FullTimeFree(ptr);
  3187.    goto ret;
  3188. }
  3192. /**************************************************
  3193. *
  3194. *    FullTimeAsnWrite()
  3195. *
  3196. **************************************************/
  3197. NLM_EXTERN Boolean LIBCALL 
  3198. FullTimeAsnWrite(FullTimePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  3199. {
  3200.    DataVal av;
  3201.    AsnTypePtr atp;
  3202.    Boolean retval = FALSE;
  3204.    if (! loaded)
  3205.    {
  3206.       if (! twebenvAsnLoad()) {
  3207.          return FALSE;
  3208.       }
  3209.    }
  3211.    if (aip == NULL) {
  3212.       return FALSE;
  3213.    }
  3215.    atp = AsnLinkType(orig, FULL_TIME);   /* link local tree */
  3216.    if (atp == NULL) {
  3217.       return FALSE;
  3218.    }
  3220.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  3221.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  3222.       goto erret;
  3223.    }
  3225.    av.intvalue = ptr -> year;
  3226.    retval = AsnWrite(aip, FULL_TIME_year,  &av);
  3227.    av.intvalue = ptr -> month;
  3228.    retval = AsnWrite(aip, FULL_TIME_month,  &av);
  3229.    av.intvalue = ptr -> day;
  3230.    retval = AsnWrite(aip, FULL_TIME_day,  &av);
  3231.    av.intvalue = ptr -> hour;
  3232.    retval = AsnWrite(aip, FULL_TIME_hour,  &av);
  3233.    av.intvalue = ptr -> minute;
  3234.    retval = AsnWrite(aip, FULL_TIME_minute,  &av);
  3235.    av.intvalue = ptr -> second;
  3236.    retval = AsnWrite(aip, FULL_TIME_second,  &av);
  3237.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  3238.       goto erret;
  3239.    }
  3240.    retval = TRUE;
  3242. erret:
  3243.    AsnUnlinkType(orig);       /* unlink local tree */
  3244.    return retval;
  3245. }
  3249. /**************************************************
  3250. *
  3251. *    NameNew()
  3252. *
  3253. **************************************************/
  3254. NLM_EXTERN 
  3255. NamePtr LIBCALL
  3256. NameNew(void)
  3257. {
  3258.    NamePtr ptr = MemNew((size_t) sizeof(Name));
  3260.    return ptr;
  3262. }
  3265. /**************************************************
  3266. *
  3267. *    NameFree()
  3268. *
  3269. **************************************************/
  3270. NLM_EXTERN 
  3271. NamePtr LIBCALL
  3272. NameFree(NamePtr ptr)
  3273. {
  3275.    if(ptr == NULL) {
  3276.       return NULL;
  3277.    }
  3278.    MemFree(ptr -> name);
  3279.    MemFree(ptr -> description);
  3280.    return MemFree(ptr);
  3281. }
  3284. /**************************************************
  3285. *
  3286. *    NameAsnRead()
  3287. *
  3288. **************************************************/
  3289. NLM_EXTERN 
  3290. NamePtr LIBCALL
  3291. NameAsnRead(AsnIoPtr aip, AsnTypePtr orig)
  3292. {
  3293.    DataVal av;
  3294.    AsnTypePtr atp;
  3295.    Boolean isError = FALSE;
  3296.    AsnReadFunc func;
  3297.    NamePtr ptr;
  3299.    if (! loaded)
  3300.    {
  3301.       if (! twebenvAsnLoad()) {
  3302.          return NULL;
  3303.       }
  3304.    }
  3306.    if (aip == NULL) {
  3307.       return NULL;
  3308.    }
  3310.    if (orig == NULL) {         /* Name ::= (self contained) */
  3311.       atp = AsnReadId(aip, amp, NAME);
  3312.    } else {
  3313.       atp = AsnLinkType(orig, NAME);
  3314.    }
  3315.    /* link in local tree */
  3316.    if (atp == NULL) {
  3317.       return NULL;
  3318.    }
  3320.    ptr = NameNew();
  3321.    if (ptr == NULL) {
  3322.       goto erret;
  3323.    }
  3324.    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
  3325.       goto erret;
  3326.    }
  3328.    atp = AsnReadId(aip,amp, atp);
  3329.    func = NULL;
  3331.    if (atp == NAME_name) {
  3332.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  3333.          goto erret;
  3334.       }
  3335.       ptr -> name = av.ptrvalue;
  3336.       atp = AsnReadId(aip,amp, atp);
  3337.    }
  3338.    if (atp == NAME_description) {
  3339.       if ( AsnReadVal(aip, atp, &av) <= 0) {
  3340.          goto erret;
  3341.       }
  3342.       ptr -> description = av.ptrvalue;
  3343.       atp = AsnReadId(aip,amp, atp);
  3344.    }
  3346.    if (AsnReadVal(aip, atp, &av) <= 0) {
  3347.       goto erret;
  3348.    }
  3349.    /* end struct */
  3351. ret:
  3352.    AsnUnlinkType(orig);       /* unlink local tree */
  3353.    return ptr;
  3355. erret:
  3356.    aip -> io_failure = TRUE;
  3357.    ptr = NameFree(ptr);
  3358.    goto ret;
  3359. }
  3363. /**************************************************
  3364. *
  3365. *    NameAsnWrite()
  3366. *
  3367. **************************************************/
  3368. NLM_EXTERN Boolean LIBCALL 
  3369. NameAsnWrite(NamePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
  3370. {
  3371.    DataVal av;
  3372.    AsnTypePtr atp;
  3373.    Boolean retval = FALSE;
  3375.    if (! loaded)
  3376.    {
  3377.       if (! twebenvAsnLoad()) {
  3378.          return FALSE;
  3379.       }
  3380.    }
  3382.    if (aip == NULL) {
  3383.       return FALSE;
  3384.    }
  3386.    atp = AsnLinkType(orig, NAME);   /* link local tree */
  3387.    if (atp == NULL) {
  3388.       return FALSE;
  3389.    }
  3391.    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
  3392.    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
  3393.       goto erret;
  3394.    }
  3396.    if (ptr -> name != NULL) {
  3397.       av.ptrvalue = ptr -> name;
  3398.       retval = AsnWrite(aip, NAME_name,  &av);
  3399.    }
  3400.    if (ptr -> description != NULL) {
  3401.       av.ptrvalue = ptr -> description;
  3402.       retval = AsnWrite(aip, NAME_description,  &av);
  3403.    }
  3404.    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
  3405.       goto erret;
  3406.    }
  3407.    retval = TRUE;
  3409. erret:
  3410.    AsnUnlinkType(orig);       /* unlink local tree */
  3411.    return retval;
  3412. }
  3413. #endif