From 51ce48f9d3319a9f8952c4c6deb2c39692403376 Mon Sep 17 00:00:00 2001 From: Adam Dickmeiss Date: Tue, 29 Feb 2000 15:52:33 +0000 Subject: [PATCH] Added compiled ASN.1 C files. --- Makefile.am | 4 +- Makefile.in | 9 +- client/Makefile.am | 4 +- client/Makefile.in | 69 ++- configure.in | 3 +- include/yaz/Makefile.am | 24 +- include/yaz/Makefile.in | 5 +- include/yaz/ill-core.h | 1329 +++++++++++++++++++++++++++++++++++++++++++++ include/yaz/z-accdes1.h | 42 ++ include/yaz/z-accform1.h | 134 +++++ include/yaz/z-acckrb1.h | 51 ++ include/yaz/z-core.h | 1220 +++++++++++++++++++++++++++++++++++++++++ include/yaz/z-date.h | 134 +++++ include/yaz/z-diag1.h | 354 ++++++++++++ include/yaz/z-espec1.h | 142 +++++ include/yaz/z-estask.h | 43 ++ include/yaz/z-exp.h | 1012 ++++++++++++++++++++++++++++++++++ include/yaz/z-grs.h | 178 ++++++ include/yaz/z-opac.h | 95 ++++ include/yaz/z-rrf1.h | 59 ++ include/yaz/z-rrf2.h | 38 ++ include/yaz/z-sum.h | 51 ++ include/yaz/z-sutrs.h | 36 ++ include/yaz/z-uifr1.h | 95 ++++ include/yaz/z-univ.h | 50 ++ include/yaz/zes-expi.h | 105 ++++ include/yaz/zes-exps.h | 93 ++++ include/yaz/zes-order.h | 132 +++++ include/yaz/zes-pquery.h | 77 +++ include/yaz/zes-psched.h | 118 ++++ include/yaz/zes-pset.h | 68 +++ include/yaz/zes-update.h | 163 ++++++ include/yaz/zes-update0.h | 151 +++++ z39.50/zes-expi.c | 124 +++++ z39.50/zes-exps.c | 100 ++++ z39.50/zes-order.c | 157 ++++++ z39.50/zes-pquery.c | 80 +++ z39.50/zes-psched.c | 139 +++++ z39.50/zes-pset.c | 69 +++ z39.50/zes-update.c | 188 +++++++ z39.50/zes-update0.c | 172 ++++++ 41 files changed, 7073 insertions(+), 44 deletions(-) create mode 100644 include/yaz/ill-core.h create mode 100644 include/yaz/z-accdes1.h create mode 100644 include/yaz/z-accform1.h create mode 100644 include/yaz/z-acckrb1.h create mode 100644 include/yaz/z-core.h create mode 100644 include/yaz/z-date.h create mode 100644 include/yaz/z-diag1.h create mode 100644 include/yaz/z-espec1.h create mode 100644 include/yaz/z-estask.h create mode 100644 include/yaz/z-exp.h create mode 100644 include/yaz/z-grs.h create mode 100644 include/yaz/z-opac.h create mode 100644 include/yaz/z-rrf1.h create mode 100644 include/yaz/z-rrf2.h create mode 100644 include/yaz/z-sum.h create mode 100644 include/yaz/z-sutrs.h create mode 100644 include/yaz/z-uifr1.h create mode 100644 include/yaz/z-univ.h create mode 100644 include/yaz/zes-expi.h create mode 100644 include/yaz/zes-exps.h create mode 100644 include/yaz/zes-order.h create mode 100644 include/yaz/zes-pquery.h create mode 100644 include/yaz/zes-psched.h create mode 100644 include/yaz/zes-pset.h create mode 100644 include/yaz/zes-update.h create mode 100644 include/yaz/zes-update0.h create mode 100644 z39.50/zes-expi.c create mode 100644 z39.50/zes-exps.c create mode 100644 z39.50/zes-order.c create mode 100644 z39.50/zes-pquery.c create mode 100644 z39.50/zes-psched.c create mode 100644 z39.50/zes-pset.c create mode 100644 z39.50/zes-update.c create mode 100644 z39.50/zes-update0.c diff --git a/Makefile.am b/Makefile.am index c8c7796..ea5aa36 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,6 +1,6 @@ -## $Id: Makefile.am,v 1.3 2000-02-29 13:44:54 adam Exp $ +## $Id: Makefile.am,v 1.4 2000-02-29 15:52:33 adam Exp $ -AUTOMAKE_OPTIONS = foreign no-dependencies +AUTOMAKE_OPTIONS = foreign DIST_SUBDIRS=util odr z39.50 asn ill zutil comstack ccl tab retrieval server lib include client ztest doc diff --git a/Makefile.in b/Makefile.in index 8af8e6f..f026688 100644 --- a/Makefile.in +++ b/Makefile.in @@ -68,7 +68,7 @@ RANLIB = @RANLIB@ SUBDIRS_VAR = @SUBDIRS_VAR@ VERSION = @VERSION@ -AUTOMAKE_OPTIONS = foreign no-dependencies +AUTOMAKE_OPTIONS = foreign DIST_SUBDIRS = util odr z39.50 asn ill zutil comstack ccl tab retrieval server lib include client ztest doc @@ -95,7 +95,7 @@ all: all-redirect $(srcdir)/Makefile.in: Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile -Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES) cd $(top_builddir) \ && CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status @@ -234,6 +234,11 @@ distdir: $(DISTFILES) -rm -rf $(distdir) mkdir $(distdir) -chmod 777 $(distdir) + here=`cd $(top_builddir) && pwd`; \ + top_distdir=`cd $(distdir) && pwd`; \ + distdir=`cd $(distdir) && pwd`; \ + cd $(top_srcdir) \ + && $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --foreign Makefile @for file in $(DISTFILES); do \ d=$(srcdir); \ if test -d $$d/$$file; then \ diff --git a/client/Makefile.am b/client/Makefile.am index eaea1a2..7b6b45a 100644 --- a/client/Makefile.am +++ b/client/Makefile.am @@ -1,8 +1,6 @@ ## Copyright (C) 1995-2000, Index Data ## All rights reserved. -## $Id: Makefile.am,v 1.3 2000-02-29 13:44:55 adam Exp $ - -AUTOMAKE_OPTIONS=no-dependencies +## $Id: Makefile.am,v 1.4 2000-02-29 15:52:33 adam Exp $ bin_PROGRAMS=yaz-client diff --git a/client/Makefile.in b/client/Makefile.in index 71d04ea..1f6afca 100644 --- a/client/Makefile.in +++ b/client/Makefile.in @@ -68,8 +68,6 @@ RANLIB = @RANLIB@ SUBDIRS_VAR = @SUBDIRS_VAR@ VERSION = @VERSION@ -AUTOMAKE_OPTIONS = no-dependencies - bin_PROGRAMS = yaz-client yaz_client_SOURCES = client.c @@ -101,6 +99,7 @@ DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) TAR = gtar GZIP_ENV = --best +DEP_FILES = .deps/client.P SOURCES = $(yaz_client_SOURCES) OBJECTS = $(yaz_client_OBJECTS) @@ -110,7 +109,7 @@ all: all-redirect $(srcdir)/Makefile.in: Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) cd $(top_srcdir) && $(AUTOMAKE) --gnu client/Makefile -Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES) cd $(top_builddir) \ && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status @@ -140,9 +139,6 @@ uninstall-binPROGRAMS: rm -f $(DESTDIR)$(bindir)/`echo $$p|sed 's/$(EXEEXT)$$//'|sed '$(transform)'|sed 's/$$/$(EXEEXT)/'`; \ done -.c.o: - $(COMPILE) -c $< - .s.o: $(COMPILE) -c $< @@ -197,6 +193,11 @@ distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir) subdir = client distdir: $(DISTFILES) + here=`cd $(top_builddir) && pwd`; \ + top_distdir=`cd $(top_distdir) && pwd`; \ + distdir=`cd $(distdir) && pwd`; \ + cd $(top_srcdir) \ + && $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --gnu client/Makefile @for file in $(DISTFILES); do \ d=$(srcdir); \ if test -d $$d/$$file; then \ @@ -207,6 +208,38 @@ distdir: $(DISTFILES) || cp -p $$d/$$file $(distdir)/$$file || :; \ fi; \ done + +DEPS_MAGIC := $(shell mkdir .deps > /dev/null 2>&1 || :) + +-include $(DEP_FILES) + +mostlyclean-depend: + +clean-depend: + +distclean-depend: + -rm -rf .deps + +maintainer-clean-depend: + +%.o: %.c + @echo '$(COMPILE) -c $<'; \ + $(COMPILE) -Wp,-MD,.deps/$(*F).pp -c $< + @-cp .deps/$(*F).pp .deps/$(*F).P; \ + tr ' ' '\012' < .deps/$(*F).pp \ + | sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \ + >> .deps/$(*F).P; \ + rm .deps/$(*F).pp + +%.lo: %.c + @echo '$(LTCOMPILE) -c $<'; \ + $(LTCOMPILE) -Wp,-MD,.deps/$(*F).pp -c $< + @-sed -e 's/^\([^:]*\)\.o[ ]*:/\1.lo \1.o :/' \ + < .deps/$(*F).pp > .deps/$(*F).P; \ + tr ' ' '\012' < .deps/$(*F).pp \ + | sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \ + >> .deps/$(*F).P; \ + rm -f .deps/$(*F).pp info-am: info: info-am dvi-am: @@ -244,23 +277,24 @@ distclean-generic: maintainer-clean-generic: mostlyclean-am: mostlyclean-binPROGRAMS mostlyclean-compile \ - mostlyclean-tags mostlyclean-generic + mostlyclean-tags mostlyclean-depend mostlyclean-generic mostlyclean: mostlyclean-am -clean-am: clean-binPROGRAMS clean-compile clean-tags clean-generic \ - mostlyclean-am +clean-am: clean-binPROGRAMS clean-compile clean-tags clean-depend \ + clean-generic mostlyclean-am clean: clean-am distclean-am: distclean-binPROGRAMS distclean-compile distclean-tags \ - distclean-generic clean-am + distclean-depend distclean-generic clean-am distclean: distclean-am maintainer-clean-am: maintainer-clean-binPROGRAMS \ maintainer-clean-compile maintainer-clean-tags \ - maintainer-clean-generic distclean-am + maintainer-clean-depend maintainer-clean-generic \ + distclean-am @echo "This command is intended for maintainers to use;" @echo "it deletes files that may require special tools to rebuild." @@ -270,12 +304,13 @@ maintainer-clean: maintainer-clean-am maintainer-clean-binPROGRAMS uninstall-binPROGRAMS install-binPROGRAMS \ mostlyclean-compile distclean-compile clean-compile \ maintainer-clean-compile tags mostlyclean-tags distclean-tags \ -clean-tags maintainer-clean-tags distdir info-am info dvi-am dvi check \ -check-am installcheck-am installcheck install-exec-am install-exec \ -install-data-am install-data install-am install uninstall-am uninstall \ -all-redirect all-am all installdirs mostlyclean-generic \ -distclean-generic clean-generic maintainer-clean-generic clean \ -mostlyclean distclean maintainer-clean +clean-tags maintainer-clean-tags distdir mostlyclean-depend \ +distclean-depend clean-depend maintainer-clean-depend info-am info \ +dvi-am dvi check check-am installcheck-am installcheck install-exec-am \ +install-exec install-data-am install-data install-am install \ +uninstall-am uninstall all-redirect all-am all installdirs \ +mostlyclean-generic distclean-generic clean-generic \ +maintainer-clean-generic clean mostlyclean distclean maintainer-clean # Tell versions [3.59,3.63) of GNU make to not export all variables. diff --git a/configure.in b/configure.in index 28d6879..5c7b506 100644 --- a/configure.in +++ b/configure.in @@ -1,10 +1,9 @@ dnl YAZ Toolkit dnl (c) Index Data 1994-2000 dnl See the file LICENSE for details. -dnl $Id: configure.in,v 1.17 2000-02-29 13:44:55 adam Exp $ +dnl $Id: configure.in,v 1.18 2000-02-29 15:52:33 adam Exp $ AC_INIT(include/yaz/yaz-version.h) AM_INIT_AUTOMAKE(yaz, 1.6) -dnl AM_CONFIG_HEADER(include/config.h) dnl dnl ------ Checking programs AC_PROG_CC diff --git a/include/yaz/Makefile.am b/include/yaz/Makefile.am index 5cab9a2..a42b1dc 100644 --- a/include/yaz/Makefile.am +++ b/include/yaz/Makefile.am @@ -1,21 +1,17 @@ -## $Id: Makefile.am,v 1.5 2000-02-29 14:13:55 adam Exp $ +## $Id: Makefile.am,v 1.6 2000-02-29 15:52:33 adam Exp $ pkginclude_HEADERS= backend.h ccl.h comstack.h \ d1_attset.h d1_map.h data1.h diagbib1.h \ - ill.h log.h logrpn.h marcdisp.h nmem.h odr.h oid.h options.h otherinfo.h \ - pquery.h prt-acc.h prt-add.h prt-arc.h prt-dat.h prt-dia.h \ - prt-esp.h prt-exd.h prt-exp.h prt-ext.h prt-grs.h prt-proto.h prt-rsc.h \ - prt-univ.h readconf.h statserv.h tcpip.h tpath.h wrbuf.h xmalloc.h \ - yaz-ccl.h yaz-util.h yaz-version.h yconfig.h \ - proto.h ill-core.h item-req.h z-accdes1.h z-accform1.h \ + log.h logrpn.h marcdisp.h nmem.h odr.h oid.h options.h otherinfo.h \ + pquery.h prt-ext.h readconf.h statserv.h tcpip.h tpath.h wrbuf.h xmalloc.h \ + yaz-ccl.h yaz-util.h yaz-version.h yconfig.h proto.h \ + \ + ill.h ill-core.h item-req.h z-accdes1.h z-accform1.h \ z-acckrb1.h z-core.h z-date.h z-diag1.h z-espec1.h z-estask.h z-exp.h \ z-grs.h z-opac.h z-proto.h z-rrf1.h z-rrf2.h z-sum.h z-sutrs.h z-uifr1.h \ z-univ.h zes-expi.h zes-exps.h zes-order.h zes-pquery.h zes-psched.h \ - zes-pset.h zes-update.h zes-update0.h + \ + zes-pset.h zes-update.h zes-update0.h \ + prt-acc.h prt-add.h prt-arc.h prt-dat.h prt-dia.h prt-esp.h \ + prt-exd.h prt-exp.h prt-grs.h prt-proto.h prt-rsc.h -EXTRA_HEADERS= \ - proto.h ill-core.h item-req.h z-accdes1.h z-accform1.h \ - z-acckrb1.h z-core.h z-date.h z-diag1.h z-espec1.h z-estask.h z-exp.h \ - z-grs.h z-opac.h z-proto.h z-rrf1.h z-rrf2.h z-sum.h z-sutrs.h z-uifr1.h \ - z-univ.h zes-expi.h zes-exps.h zes-order.h zes-pquery.h zes-psched.h \ - zes-pset.h zes-update.h zes-update0.h diff --git a/include/yaz/Makefile.in b/include/yaz/Makefile.in index d5bfef9..7020660 100644 --- a/include/yaz/Makefile.in +++ b/include/yaz/Makefile.in @@ -68,10 +68,7 @@ RANLIB = @RANLIB@ SUBDIRS_VAR = @SUBDIRS_VAR@ VERSION = @VERSION@ -pkginclude_HEADERS = backend.h ccl.h comstack.h d1_attset.h d1_map.h data1.h diagbib1.h ill.h log.h logrpn.h marcdisp.h nmem.h odr.h oid.h options.h otherinfo.h pquery.h prt-acc.h prt-add.h prt-arc.h prt-dat.h prt-dia.h prt-esp.h prt-exd.h prt-exp.h prt-ext.h prt-grs.h prt-proto.h prt-rsc.h prt-univ.h readconf.h statserv.h tcpip.h tpath.h wrbuf.h xmalloc.h yaz-ccl.h yaz-util.h yaz-version.h yconfig.h proto.h ill-core.h item-req.h z-accdes1.h z-accform1.h z-acckrb1.h z-core.h z-date.h z-diag1.h z-espec1.h z-estask.h z-exp.h z-grs.h z-opac.h z-proto.h z-rrf1.h z-rrf2.h z-sum.h z-sutrs.h z-uifr1.h z-univ.h zes-expi.h zes-exps.h zes-order.h zes-pquery.h zes-psched.h zes-pset.h zes-update.h zes-update0.h - - -EXTRA_HEADERS = proto.h ill-core.h item-req.h z-accdes1.h z-accform1.h z-acckrb1.h z-core.h z-date.h z-diag1.h z-espec1.h z-estask.h z-exp.h z-grs.h z-opac.h z-proto.h z-rrf1.h z-rrf2.h z-sum.h z-sutrs.h z-uifr1.h z-univ.h zes-expi.h zes-exps.h zes-order.h zes-pquery.h zes-psched.h zes-pset.h zes-update.h zes-update0.h +pkginclude_HEADERS = backend.h ccl.h comstack.h d1_attset.h d1_map.h data1.h diagbib1.h log.h logrpn.h marcdisp.h nmem.h odr.h oid.h options.h otherinfo.h pquery.h prt-ext.h readconf.h statserv.h tcpip.h tpath.h wrbuf.h xmalloc.h yaz-ccl.h yaz-util.h yaz-version.h yconfig.h proto.h ill.h ill-core.h item-req.h z-accdes1.h z-accform1.h z-acckrb1.h z-core.h z-date.h z-diag1.h z-espec1.h z-estask.h z-exp.h z-grs.h z-opac.h z-proto.h z-rrf1.h z-rrf2.h z-sum.h z-sutrs.h z-uifr1.h z-univ.h zes-expi.h zes-exps.h zes-order.h zes-pquery.h zes-psched.h zes-pset.h zes-update.h zes-update0.h prt-acc.h prt-add.h prt-arc.h prt-dat.h prt-dia.h prt-esp.h prt-exd.h prt-exp.h prt-grs.h prt-proto.h prt-rsc.h mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs CONFIG_CLEAN_FILES = diff --git a/include/yaz/ill-core.h b/include/yaz/ill-core.h new file mode 100644 index 0000000..e324f2e --- /dev/null +++ b/include/yaz/ill-core.h @@ -0,0 +1,1329 @@ +/* YC 0.2: Tue Feb 29 16:45:17 CET 2000 */ +/* Module-H ISO-10161-ILL-1 */ + +#ifndef ill_core_H +#define ill_core_H + +#include +#ifdef __cplusplus +extern "C" { +#endif + + + +typedef struct ILL_APDU ILL_APDU; +YAZ_EXPORT int ill_APDU (ODR o, ILL_APDU **p, int opt, const char *name); + +typedef struct ILL_Request ILL_Request; +YAZ_EXPORT int ill_Request (ODR o, ILL_Request **p, int opt, const char *name); + +typedef struct ILL_Forward_Notification ILL_Forward_Notification; +YAZ_EXPORT int ill_Forward_Notification (ODR o, ILL_Forward_Notification **p, int opt, const char *name); + +typedef struct ILL_Shipped ILL_Shipped; +YAZ_EXPORT int ill_Shipped (ODR o, ILL_Shipped **p, int opt, const char *name); + +typedef struct ILL_Answer ILL_Answer; +YAZ_EXPORT int ill_Answer (ODR o, ILL_Answer **p, int opt, const char *name); + +typedef struct ILL_Conditional_Reply ILL_Conditional_Reply; +YAZ_EXPORT int ill_Conditional_Reply (ODR o, ILL_Conditional_Reply **p, int opt, const char *name); + +typedef struct ILL_Cancel ILL_Cancel; +YAZ_EXPORT int ill_Cancel (ODR o, ILL_Cancel **p, int opt, const char *name); + +typedef struct ILL_Cancel_Reply ILL_Cancel_Reply; +YAZ_EXPORT int ill_Cancel_Reply (ODR o, ILL_Cancel_Reply **p, int opt, const char *name); + +typedef struct ILL_Received ILL_Received; +YAZ_EXPORT int ill_Received (ODR o, ILL_Received **p, int opt, const char *name); + +typedef struct ILL_Recall ILL_Recall; +YAZ_EXPORT int ill_Recall (ODR o, ILL_Recall **p, int opt, const char *name); + +typedef struct ILL_Returned ILL_Returned; +YAZ_EXPORT int ill_Returned (ODR o, ILL_Returned **p, int opt, const char *name); + +typedef struct ILL_Checked_In ILL_Checked_In; +YAZ_EXPORT int ill_Checked_In (ODR o, ILL_Checked_In **p, int opt, const char *name); + +typedef struct ILL_Overdue_Extension ILL_Overdue_Extension; +YAZ_EXPORT int ill_Overdue_Extension (ODR o, ILL_Overdue_Extension **p, int opt, const char *name); + +typedef struct ILL_Overdue ILL_Overdue; +YAZ_EXPORT int ill_Overdue (ODR o, ILL_Overdue **p, int opt, const char *name); + +typedef struct ILL_Renew ILL_Renew; +YAZ_EXPORT int ill_Renew (ODR o, ILL_Renew **p, int opt, const char *name); + +typedef struct ILL_Renew_Answer ILL_Renew_Answer; +YAZ_EXPORT int ill_Renew_Answer (ODR o, ILL_Renew_Answer **p, int opt, const char *name); + +typedef struct ILL_Lost ILL_Lost; +YAZ_EXPORT int ill_Lost (ODR o, ILL_Lost **p, int opt, const char *name); + +typedef struct ILL_Damaged ILL_Damaged; +YAZ_EXPORT int ill_Damaged (ODR o, ILL_Damaged **p, int opt, const char *name); + +typedef struct ILL_Message ILL_Message; +YAZ_EXPORT int ill_Message (ODR o, ILL_Message **p, int opt, const char *name); + +typedef struct ILL_Status_Query ILL_Status_Query; +YAZ_EXPORT int ill_Status_Query (ODR o, ILL_Status_Query **p, int opt, const char *name); + +typedef struct ILL_Status_Or_Error_Report ILL_Status_Or_Error_Report; +YAZ_EXPORT int ill_Status_Or_Error_Report (ODR o, ILL_Status_Or_Error_Report **p, int opt, const char *name); + +typedef struct ILL_Expired ILL_Expired; +YAZ_EXPORT int ill_Expired (ODR o, ILL_Expired **p, int opt, const char *name); + +typedef struct ILL_Already_Forwarded ILL_Already_Forwarded; +YAZ_EXPORT int ill_Already_Forwarded (ODR o, ILL_Already_Forwarded **p, int opt, const char *name); + +typedef struct ILL_Already_Tried_List_Type ILL_Already_Tried_List_Type; +YAZ_EXPORT int ill_Already_Tried_List_Type (ODR o, ILL_Already_Tried_List_Type **p, int opt, const char *name); + +typedef struct ILL_Amount ILL_Amount; +YAZ_EXPORT int ill_Amount (ODR o, ILL_Amount **p, int opt, const char *name); + +typedef char ILL_AmountString; +YAZ_EXPORT int ill_AmountString (ODR o, ILL_AmountString **p, int opt, const char *name); + +typedef struct ILL_Client_Id ILL_Client_Id; +YAZ_EXPORT int ill_Client_Id (ODR o, ILL_Client_Id **p, int opt, const char *name); + +typedef struct ILL_Conditional_Results ILL_Conditional_Results; +YAZ_EXPORT int ill_Conditional_Results (ODR o, ILL_Conditional_Results **p, int opt, const char *name); + +typedef struct ILL_Cost_Info_Type ILL_Cost_Info_Type; +YAZ_EXPORT int ill_Cost_Info_Type (ODR o, ILL_Cost_Info_Type **p, int opt, const char *name); + +typedef int ILL_Current_State; +YAZ_EXPORT int ill_Current_State (ODR o, ILL_Current_State **p, int opt, const char *name); + +typedef struct ILL_Damaged_DetailsSpecific_units ILL_Damaged_DetailsSpecific_units; +YAZ_EXPORT int ill_Damaged_DetailsSpecific_units (ODR o, ILL_Damaged_DetailsSpecific_units **p, int opt, const char *name); + +typedef struct ILL_Damaged_Details ILL_Damaged_Details; +YAZ_EXPORT int ill_Damaged_Details (ODR o, ILL_Damaged_Details **p, int opt, const char *name); + +typedef struct ILL_Date_Due ILL_Date_Due; +YAZ_EXPORT int ill_Date_Due (ODR o, ILL_Date_Due **p, int opt, const char *name); + +typedef struct ILL_Delivery_Address ILL_Delivery_Address; +YAZ_EXPORT int ill_Delivery_Address (ODR o, ILL_Delivery_Address **p, int opt, const char *name); + +typedef struct ILL_Delivery_ServiceElectronic_delivery ILL_Delivery_ServiceElectronic_delivery; +YAZ_EXPORT int ill_Delivery_ServiceElectronic_delivery (ODR o, ILL_Delivery_ServiceElectronic_delivery **p, int opt, const char *name); + +typedef struct ILL_Delivery_Service ILL_Delivery_Service; +YAZ_EXPORT int ill_Delivery_Service (ODR o, ILL_Delivery_Service **p, int opt, const char *name); + +typedef struct ILL_Electronic_Delivery_Service_0 ILL_Electronic_Delivery_Service_0; +YAZ_EXPORT int ill_Electronic_Delivery_Service_0 (ODR o, ILL_Electronic_Delivery_Service_0 **p, int opt, const char *name); + +typedef struct ILL_Electronic_Delivery_Service_1 ILL_Electronic_Delivery_Service_1; +YAZ_EXPORT int ill_Electronic_Delivery_Service_1 (ODR o, ILL_Electronic_Delivery_Service_1 **p, int opt, const char *name); + +typedef struct ILL_Electronic_Delivery_Service ILL_Electronic_Delivery_Service; +YAZ_EXPORT int ill_Electronic_Delivery_Service (ODR o, ILL_Electronic_Delivery_Service **p, int opt, const char *name); + +typedef struct ILL_Error_Report ILL_Error_Report; +YAZ_EXPORT int ill_Error_Report (ODR o, ILL_Error_Report **p, int opt, const char *name); + +typedef struct ILL_Estimate_Results ILL_Estimate_Results; +YAZ_EXPORT int ill_Estimate_Results (ODR o, ILL_Estimate_Results **p, int opt, const char *name); + +typedef struct ILL_Extension ILL_Extension; +YAZ_EXPORT int ill_Extension (ODR o, ILL_Extension **p, int opt, const char *name); + +typedef int ILL_General_Problem; +YAZ_EXPORT int ill_General_Problem (ODR o, ILL_General_Problem **p, int opt, const char *name); + +typedef struct ILL_History_Report ILL_History_Report; +YAZ_EXPORT int ill_History_Report (ODR o, ILL_History_Report **p, int opt, const char *name); + +typedef struct ILL_Hold_Placed_Results ILL_Hold_Placed_Results; +YAZ_EXPORT int ill_Hold_Placed_Results (ODR o, ILL_Hold_Placed_Results **p, int opt, const char *name); + +typedef int ILL_APDU_Type; +YAZ_EXPORT int ill_APDU_Type (ODR o, ILL_APDU_Type **p, int opt, const char *name); + +typedef int ILL_Service_Type; +YAZ_EXPORT int ill_Service_Type (ODR o, ILL_Service_Type **p, int opt, const char *name); + +typedef struct ILL_String ILL_String; +YAZ_EXPORT int ill_String (ODR o, ILL_String **p, int opt, const char *name); + +typedef ILL_String ILL_Account_Number; +YAZ_EXPORT int ill_Account_Number (ODR o, ILL_Account_Number **p, int opt, const char *name); + +typedef int ILL_Intermediary_Problem; +YAZ_EXPORT int ill_Intermediary_Problem (ODR o, ILL_Intermediary_Problem **p, int opt, const char *name); + +typedef char ILL_ISO_Date; +YAZ_EXPORT int ill_ISO_Date (ODR o, ILL_ISO_Date **p, int opt, const char *name); + +typedef char ILL_ISO_Time; +YAZ_EXPORT int ill_ISO_Time (ODR o, ILL_ISO_Time **p, int opt, const char *name); + +typedef struct ILL_Item_Id ILL_Item_Id; +YAZ_EXPORT int ill_Item_Id (ODR o, ILL_Item_Id **p, int opt, const char *name); + +typedef struct ILL_Location_Info ILL_Location_Info; +YAZ_EXPORT int ill_Location_Info (ODR o, ILL_Location_Info **p, int opt, const char *name); + +typedef struct ILL_Locations_Results ILL_Locations_Results; +YAZ_EXPORT int ill_Locations_Results (ODR o, ILL_Locations_Results **p, int opt, const char *name); + +typedef int ILL_Medium_Type; +YAZ_EXPORT int ill_Medium_Type (ODR o, ILL_Medium_Type **p, int opt, const char *name); + +typedef struct ILL_Name_Of_Person_Or_Institution ILL_Name_Of_Person_Or_Institution; +YAZ_EXPORT int ill_Name_Of_Person_Or_Institution (ODR o, ILL_Name_Of_Person_Or_Institution **p, int opt, const char *name); + +typedef struct ILL_Person_Or_Institution_Symbol ILL_Person_Or_Institution_Symbol; +YAZ_EXPORT int ill_Person_Or_Institution_Symbol (ODR o, ILL_Person_Or_Institution_Symbol **p, int opt, const char *name); + +typedef int ILL_Place_On_Hold_Type; +YAZ_EXPORT int ill_Place_On_Hold_Type (ODR o, ILL_Place_On_Hold_Type **p, int opt, const char *name); + +typedef struct ILL_Postal_Address ILL_Postal_Address; +YAZ_EXPORT int ill_Postal_Address (ODR o, ILL_Postal_Address **p, int opt, const char *name); + +typedef struct ILL_Provider_Error_Report ILL_Provider_Error_Report; +YAZ_EXPORT int ill_Provider_Error_Report (ODR o, ILL_Provider_Error_Report **p, int opt, const char *name); + +typedef int ILL_Reason_Locs_Provided; +YAZ_EXPORT int ill_Reason_Locs_Provided (ODR o, ILL_Reason_Locs_Provided **p, int opt, const char *name); + +typedef int ILL_Reason_No_Report; +YAZ_EXPORT int ill_Reason_No_Report (ODR o, ILL_Reason_No_Report **p, int opt, const char *name); + +typedef int ILL_Reason_Unfilled; +YAZ_EXPORT int ill_Reason_Unfilled (ODR o, ILL_Reason_Unfilled **p, int opt, const char *name); + +typedef int ILL_Report_Source; +YAZ_EXPORT int ill_Report_Source (ODR o, ILL_Report_Source **p, int opt, const char *name); + +typedef struct ILL_Requester_Optional_Messages_Type ILL_Requester_Optional_Messages_Type; +YAZ_EXPORT int ill_Requester_Optional_Messages_Type (ODR o, ILL_Requester_Optional_Messages_Type **p, int opt, const char *name); + +typedef struct ILL_Responder_Optional_Messages_Type ILL_Responder_Optional_Messages_Type; +YAZ_EXPORT int ill_Responder_Optional_Messages_Type (ODR o, ILL_Responder_Optional_Messages_Type **p, int opt, const char *name); + +typedef struct ILL_Retry_Results ILL_Retry_Results; +YAZ_EXPORT int ill_Retry_Results (ODR o, ILL_Retry_Results **p, int opt, const char *name); + +typedef struct ILL_Search_Type ILL_Search_Type; +YAZ_EXPORT int ill_Search_Type (ODR o, ILL_Search_Type **p, int opt, const char *name); + +typedef ILL_String ILL_Security_Problem; +YAZ_EXPORT int ill_Security_Problem (ODR o, ILL_Security_Problem **p, int opt, const char *name); + +typedef struct ILL_Send_To_List_Type_s ILL_Send_To_List_Type_s; +YAZ_EXPORT int ill_Send_To_List_Type_s (ODR o, ILL_Send_To_List_Type_s **p, int opt, const char *name); + +typedef struct ILL_Send_To_List_Type ILL_Send_To_List_Type; +YAZ_EXPORT int ill_Send_To_List_Type (ODR o, ILL_Send_To_List_Type **p, int opt, const char *name); + +typedef struct ILL_Service_Date_this ILL_Service_Date_this; +YAZ_EXPORT int ill_Service_Date_this (ODR o, ILL_Service_Date_this **p, int opt, const char *name); + +typedef struct ILL_Service_Date_original ILL_Service_Date_original; +YAZ_EXPORT int ill_Service_Date_original (ODR o, ILL_Service_Date_original **p, int opt, const char *name); + +typedef struct ILL_Service_Date_Time ILL_Service_Date_Time; +YAZ_EXPORT int ill_Service_Date_Time (ODR o, ILL_Service_Date_Time **p, int opt, const char *name); + +typedef ILL_Service_Type ILL_Shipped_Service_Type; +YAZ_EXPORT int ill_Shipped_Service_Type (ODR o, ILL_Shipped_Service_Type **p, int opt, const char *name); + +typedef struct ILL_State_Transition_Prohibited ILL_State_Transition_Prohibited; +YAZ_EXPORT int ill_State_Transition_Prohibited (ODR o, ILL_State_Transition_Prohibited **p, int opt, const char *name); + +typedef struct ILL_Status_Report ILL_Status_Report; +YAZ_EXPORT int ill_Status_Report (ODR o, ILL_Status_Report **p, int opt, const char *name); + +typedef struct ILL_Supplemental_Item_Description ILL_Supplemental_Item_Description; +YAZ_EXPORT int ill_Supplemental_Item_Description (ODR o, ILL_Supplemental_Item_Description **p, int opt, const char *name); + +typedef struct ILL_Supply_Details ILL_Supply_Details; +YAZ_EXPORT int ill_Supply_Details (ODR o, ILL_Supply_Details **p, int opt, const char *name); + +typedef struct ILL_Supply_Medium_Info_Type ILL_Supply_Medium_Info_Type; +YAZ_EXPORT int ill_Supply_Medium_Info_Type (ODR o, ILL_Supply_Medium_Info_Type **p, int opt, const char *name); + +typedef int ILL_Supply_Medium_Type; +YAZ_EXPORT int ill_Supply_Medium_Type (ODR o, ILL_Supply_Medium_Type **p, int opt, const char *name); + +typedef struct ILL_System_Address ILL_System_Address; +YAZ_EXPORT int ill_System_Address (ODR o, ILL_System_Address **p, int opt, const char *name); + +typedef struct ILL_System_Id ILL_System_Id; +YAZ_EXPORT int ill_System_Id (ODR o, ILL_System_Id **p, int opt, const char *name); + +typedef struct ILL_Third_Party_Info_Type ILL_Third_Party_Info_Type; +YAZ_EXPORT int ill_Third_Party_Info_Type (ODR o, ILL_Third_Party_Info_Type **p, int opt, const char *name); + +typedef struct ILL_Transaction_Id ILL_Transaction_Id; +YAZ_EXPORT int ill_Transaction_Id (ODR o, ILL_Transaction_Id **p, int opt, const char *name); + +typedef int ILL_Transaction_Id_Problem; +YAZ_EXPORT int ill_Transaction_Id_Problem (ODR o, ILL_Transaction_Id_Problem **p, int opt, const char *name); + +typedef int ILL_Transaction_Results; +YAZ_EXPORT int ill_Transaction_Results (ODR o, ILL_Transaction_Results **p, int opt, const char *name); + +typedef int ILL_Transaction_Type; +YAZ_EXPORT int ill_Transaction_Type (ODR o, ILL_Transaction_Type **p, int opt, const char *name); + +typedef ILL_String ILL_Transportation_Mode; +YAZ_EXPORT int ill_Transportation_Mode (ODR o, ILL_Transportation_Mode **p, int opt, const char *name); + +typedef int ILL_Unable_To_Perform; +YAZ_EXPORT int ill_Unable_To_Perform (ODR o, ILL_Unable_To_Perform **p, int opt, const char *name); + +typedef struct ILL_Unfilled_Results ILL_Unfilled_Results; +YAZ_EXPORT int ill_Unfilled_Results (ODR o, ILL_Unfilled_Results **p, int opt, const char *name); + +typedef struct ILL_Units_Per_Medium_Type ILL_Units_Per_Medium_Type; +YAZ_EXPORT int ill_Units_Per_Medium_Type (ODR o, ILL_Units_Per_Medium_Type **p, int opt, const char *name); + +typedef struct ILL_User_Error_Report ILL_User_Error_Report; +YAZ_EXPORT int ill_User_Error_Report (ODR o, ILL_User_Error_Report **p, int opt, const char *name); + +typedef struct ILL_Will_Supply_Results ILL_Will_Supply_Results; +YAZ_EXPORT int ill_Will_Supply_Results (ODR o, ILL_Will_Supply_Results **p, int opt, const char *name); + +typedef char ILL_EDIFACTString; +YAZ_EXPORT int ill_EDIFACTString (ODR o, ILL_EDIFACTString **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct ILL_APDU { + int which; + union { + ILL_Request *ILL_Request; + ILL_Forward_Notification *Forward_Notification; + ILL_Shipped *Shipped; + ILL_Answer *ILL_Answer; + ILL_Conditional_Reply *Conditional_Reply; + ILL_Cancel *Cancel; + ILL_Cancel_Reply *Cancel_Reply; + ILL_Received *Received; + ILL_Recall *Recall; + ILL_Returned *Returned; + ILL_Checked_In *Checked_In; + ILL_Overdue *Overdue; + ILL_Renew *Renew; + ILL_Renew_Answer *Renew_Answer; + ILL_Lost *Lost; + ILL_Damaged *Damaged; + ILL_Message *Message; + ILL_Status_Query *Status_Query; + ILL_Status_Or_Error_Report *Status_Or_Error_Report; + ILL_Expired *Expired; +#define ILL_APDU_ILL_Request 1 +#define ILL_APDU_Forward_Notification 2 +#define ILL_APDU_Shipped 3 +#define ILL_APDU_ILL_Answer 4 +#define ILL_APDU_Conditional_Reply 5 +#define ILL_APDU_Cancel 6 +#define ILL_APDU_Cancel_Reply 7 +#define ILL_APDU_Received 8 +#define ILL_APDU_Recall 9 +#define ILL_APDU_Returned 10 +#define ILL_APDU_Checked_In 11 +#define ILL_APDU_Overdue 12 +#define ILL_APDU_Renew 13 +#define ILL_APDU_Renew_Answer 14 +#define ILL_APDU_Lost 15 +#define ILL_APDU_Damaged 16 +#define ILL_APDU_Message 17 +#define ILL_APDU_Status_Query 18 +#define ILL_APDU_Status_Or_Error_Report 19 +#define ILL_APDU_Expired 20 + } u; +}; + +struct ILL_Request { +#define ILL_Request_version_1 1 +#define ILL_Request_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_Transaction_Type *transaction_type; + ILL_Delivery_Address *delivery_address; /* OPT */ + ILL_Delivery_Service *delivery_service; /* OPT */ + ILL_Delivery_Address *billing_address; /* OPT */ + int num_iLL_service_type; + ILL_Service_Type **iLL_service_type; + Odr_external *responder_specific_service; /* OPT */ + ILL_Requester_Optional_Messages_Type *requester_optional_messages; + ILL_Search_Type *search_type; /* OPT */ + int num_supply_medium_info_type; + ILL_Supply_Medium_Info_Type **supply_medium_info_type; /* OPT */ + ILL_Place_On_Hold_Type *place_on_hold; + ILL_Client_Id *client_id; /* OPT */ + ILL_Item_Id *item_id; + ILL_Supplemental_Item_Description *supplemental_item_description; /* OPT */ + ILL_Cost_Info_Type *cost_info_type; /* OPT */ + ILL_String *copyright_compliance; /* OPT */ + ILL_Third_Party_Info_Type *third_party_info_type; /* OPT */ + bool_t *retry_flag; + bool_t *forward_flag; + ILL_String *requester_note; /* OPT */ + ILL_String *forward_note; /* OPT */ + int num_iLL_request_extensions; + ILL_Extension **iLL_request_extensions; /* OPT */ +}; + +struct ILL_Forward_Notification { +#define ILL_Forward_Notification_version_1 1 +#define ILL_Forward_Notification_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; + ILL_System_Address *responder_address; /* OPT */ + ILL_System_Id *intermediary_id; + ILL_String *notification_note; /* OPT */ + int num_forward_notification_extensions; + ILL_Extension **forward_notification_extensions; /* OPT */ +}; + +struct ILL_Shipped { +#define ILL_Shipped_version_1 1 +#define ILL_Shipped_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_System_Address *responder_address; /* OPT */ + ILL_System_Id *intermediary_id; /* OPT */ + ILL_System_Id *supplier_id; /* OPT */ + ILL_Client_Id *client_id; /* OPT */ + ILL_Transaction_Type *transaction_type; + ILL_Supplemental_Item_Description *supplemental_item_description; /* OPT */ + ILL_Shipped_Service_Type *shipped_service_type; + ILL_Responder_Optional_Messages_Type *responder_optional_messages; /* OPT */ + ILL_Supply_Details *supply_details; + ILL_Postal_Address *return_to_address; /* OPT */ + ILL_String *responder_note; /* OPT */ + int num_shipped_extensions; + ILL_Extension **shipped_extensions; /* OPT */ +}; + +struct ILL_Answer { +#define ILL_Answer_version_1 1 +#define ILL_Answer_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_Transaction_Results *transaction_results; + int which; + union { + ILL_Conditional_Results *conditional_results; + ILL_Retry_Results *retry_results; + ILL_Unfilled_Results *unfilled_results; + ILL_Locations_Results *locations_results; + ILL_Will_Supply_Results *will_supply_results; + ILL_Hold_Placed_Results *hold_placed_results; + ILL_Estimate_Results *estimate_results; +#define ILL_Answer_conditional_results 1 +#define ILL_Answer_retry_results 2 +#define ILL_Answer_unfilled_results 3 +#define ILL_Answer_locations_results 4 +#define ILL_Answer_will_supply_results 5 +#define ILL_Answer_hold_placed_results 6 +#define ILL_Answer_estimate_results 7 + } u; /* OPT */ + Odr_external *responder_specific_results; /* OPT */ + ILL_Supplemental_Item_Description *supplemental_item_description; /* OPT */ + ILL_Send_To_List_Type *send_to_list; /* OPT */ + ILL_Already_Tried_List_Type *already_tried_list; /* OPT */ + ILL_Responder_Optional_Messages_Type *responder_optional_messages; /* OPT */ + ILL_String *responder_note; /* OPT */ + int num_ill_answer_extensions; + ILL_Extension **ill_answer_extensions; /* OPT */ +}; + +struct ILL_Conditional_Reply { +#define ILL_Conditional_Reply_version_1 1 +#define ILL_Conditional_Reply_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + bool_t *answer; + ILL_String *requester_note; /* OPT */ + int num_conditional_reply_extensions; + ILL_Extension **conditional_reply_extensions; /* OPT */ +}; + +struct ILL_Cancel { +#define ILL_Cancel_version_1 1 +#define ILL_Cancel_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_String *requester_note; /* OPT */ + int num_cancel_extensions; + ILL_Extension **cancel_extensions; /* OPT */ +}; + +struct ILL_Cancel_Reply { +#define ILL_Cancel_Reply_version_1 1 +#define ILL_Cancel_Reply_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + bool_t *answer; + ILL_String *responder_note; /* OPT */ + int num_cancel_reply_extensions; + ILL_Extension **cancel_reply_extensions; /* OPT */ +}; + +struct ILL_Received { +#define ILL_Received_version_1 1 +#define ILL_Received_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_System_Id *supplier_id; /* OPT */ + ILL_Supplemental_Item_Description *supplemental_item_description; /* OPT */ + ILL_ISO_Date *date_received; + ILL_Shipped_Service_Type *shipped_service_type; + ILL_String *requester_note; /* OPT */ + int num_received_extensions; + ILL_Extension **received_extensions; /* OPT */ +}; + +struct ILL_Recall { +#define ILL_Recall_version_1 1 +#define ILL_Recall_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_String *responder_note; /* OPT */ + int num_recall_extensions; + ILL_Extension **recall_extensions; /* OPT */ +}; + +struct ILL_Returned { +#define ILL_Returned_version_1 1 +#define ILL_Returned_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_Supplemental_Item_Description *supplemental_item_description; /* OPT */ + ILL_ISO_Date *date_returned; + ILL_Transportation_Mode *returned_via; /* OPT */ + ILL_Amount *insured_for; /* OPT */ + ILL_String *requester_note; /* OPT */ + int num_returned_extensions; + ILL_Extension **returned_extensions; /* OPT */ +}; + +struct ILL_Checked_In { +#define ILL_Checked_In_version_1 1 +#define ILL_Checked_In_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_ISO_Date *date_checked_in; + ILL_String *responder_note; /* OPT */ + int num_checked_in_extensions; + ILL_Extension **checked_in_extensions; /* OPT */ +}; + +struct ILL_Overdue_Extension { + int num; + ILL_Extension **elements; +}; + +struct ILL_Overdue { +#define ILL_Overdue_version_1 1 +#define ILL_Overdue_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_Date_Due *date_due; + ILL_String *responder_note; /* OPT */ + ILL_Overdue_Extension *overdue_extensions; /* OPT */ +}; + +struct ILL_Renew { +#define ILL_Renew_version_1 1 +#define ILL_Renew_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_ISO_Date *desired_due_date; /* OPT */ + ILL_String *requester_note; /* OPT */ + int num_renew_extensions; + ILL_Extension **renew_extensions; /* OPT */ +}; + +struct ILL_Renew_Answer { +#define ILL_Renew_Answer_version_1 1 +#define ILL_Renew_Answer_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + bool_t *answer; + ILL_Date_Due *date_due; /* OPT */ + ILL_String *responder_note; /* OPT */ + int num_renew_answer_extensions; + ILL_Extension **renew_answer_extensions; /* OPT */ +}; + +struct ILL_Lost { +#define ILL_Lost_version_1 1 +#define ILL_Lost_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_String *note; /* OPT */ + int num_lost_extensions; + ILL_Extension **lost_extensions; /* OPT */ +}; + +struct ILL_Damaged { +#define ILL_Damaged_version_1 1 +#define ILL_Damaged_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_Damaged_Details *damaged_details; /* OPT */ + ILL_String *note; /* OPT */ + int num_damaged_extensions; + ILL_Extension **damaged_extensions; /* OPT */ +}; + +struct ILL_Message { +#define ILL_Message_version_1 1 +#define ILL_Message_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_String *note; + int num_message_extensions; + ILL_Extension **message_extensions; /* OPT */ +}; + +struct ILL_Status_Query { +#define ILL_Status_Query_version_1 1 +#define ILL_Status_Query_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_String *note; /* OPT */ + int num_status_query_extensions; + ILL_Extension **status_query_extensions; /* OPT */ +}; + +struct ILL_Status_Or_Error_Report { +#define ILL_Status_Or_Error_Report_version_1 1 +#define ILL_Status_Or_Error_Report_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + ILL_Reason_No_Report *reason_no_report; /* OPT */ + ILL_Status_Report *status_report; /* OPT */ + ILL_Error_Report *error_report; /* OPT */ + ILL_String *note; /* OPT */ + int num_status_or_error_report_extensions; + ILL_Extension **status_or_error_report_extensions; /* OPT */ +}; + +struct ILL_Expired { +#define ILL_Expired_version_1 1 +#define ILL_Expired_version_2 2 + int *protocol_version_num; + ILL_Transaction_Id *transaction_id; + ILL_Service_Date_Time *service_date_time; + ILL_System_Id *requester_id; /* OPT */ + ILL_System_Id *responder_id; /* OPT */ + int num_expired_extensions; + ILL_Extension **expired_extensions; /* OPT */ +}; + + + +struct ILL_Already_Forwarded { + ILL_System_Id *responder_id; + ILL_System_Address *responder_address; /* OPT */ +}; + +struct ILL_Already_Tried_List_Type { + int num; + ILL_System_Id **elements; +}; + +struct ILL_Amount { + char *currency_code; /* OPT */ + ILL_AmountString *monetary_value; +}; + + + +struct ILL_Client_Id { + ILL_String *client_name; /* OPT */ + ILL_String *client_status; /* OPT */ + ILL_String *client_identifier; /* OPT */ +}; + +struct ILL_Conditional_Results { +#define ILL_Conditional_Results_cost_exceeds_limit 13 +#define ILL_Conditional_Results_charges 14 +#define ILL_Conditional_Results_prepayment_required 15 +#define ILL_Conditional_Results_lacks_copyright_compliance 16 +#define ILL_Conditional_Results_library_use_only 22 +#define ILL_Conditional_Results_no_reproduction 23 +#define ILL_Conditional_Results_client_signature_required 24 +#define ILL_Conditional_Results_special_collections_supervision_required 25 +#define ILL_Conditional_Results_other 27 +#define ILL_Conditional_Results_responder_specific 28 +#define ILL_Conditional_Results_proposed_delivery_service 30 + int *conditions; + ILL_ISO_Date *date_for_reply; /* OPT */ + int num_locations; + ILL_Location_Info **locations; /* OPT */ + ILL_Delivery_Service *proposed_delivery_service; /* OPT */ +}; + +struct ILL_Cost_Info_Type { + ILL_Account_Number *account_number; /* OPT */ + ILL_Amount *maximum_cost; /* OPT */ + bool_t *reciprocal_agreement; + bool_t *will_pay_fee; + bool_t *payment_provided; +}; + +#define ILL_Current_State_nOT_SUPPLIED 1 +#define ILL_Current_State_pENDING 2 +#define ILL_Current_State_iN_PROCESS 3 +#define ILL_Current_State_fORWARD 4 +#define ILL_Current_State_cONDITIONAL 5 +#define ILL_Current_State_cANCEL_PENDING 6 +#define ILL_Current_State_cANCELLED 7 +#define ILL_Current_State_sHIPPED 8 +#define ILL_Current_State_rECEIVED 9 +#define ILL_Current_State_rENEW_PENDING 10 +#define ILL_Current_State_nOT_RECEIVED_OVERDUE 11 +#define ILL_Current_State_rENEW_OVERDUE 12 +#define ILL_Current_State_oVERDUE 13 +#define ILL_Current_State_rETURNED 14 +#define ILL_Current_State_cHECKED_IN 15 +#define ILL_Current_State_rECALL 16 +#define ILL_Current_State_lOST 17 +#define ILL_Current_State_uNKNOWN 18 + +struct ILL_Damaged_DetailsSpecific_units { + int num; + int **elements; +}; + +struct ILL_Damaged_Details { + Odr_oid *document_type_id; /* OPT */ + int which; + union { + Odr_null *complete_document; + ILL_Damaged_DetailsSpecific_units *specific_units; +#define ILL_Damaged_Details_complete_document 1 +#define ILL_Damaged_Details_specific_units 2 + } u; +}; + +struct ILL_Date_Due { + ILL_ISO_Date *date_due_field; + bool_t *renewable; +}; + +struct ILL_Delivery_Address { + ILL_Postal_Address *postal_address; /* OPT */ + ILL_System_Address *electronic_address; /* OPT */ +}; + +struct ILL_Delivery_ServiceElectronic_delivery { + int num; + ILL_Electronic_Delivery_Service **elements; +}; + +struct ILL_Delivery_Service { + int which; + union { + ILL_Transportation_Mode *physical_delivery; + ILL_Delivery_ServiceElectronic_delivery *electronic_delivery; +#define ILL_Delivery_Service_physical_delivery 1 +#define ILL_Delivery_Service_electronic_delivery 2 + } u; +}; + +struct ILL_Electronic_Delivery_Service_0 { + Odr_oid *e_delivery_mode; + Odr_any *e_delivery_parameters; +}; + +struct ILL_Electronic_Delivery_Service_1 { + Odr_oid *document_type_id; + Odr_any *document_type_parameters; +}; + +struct ILL_Electronic_Delivery_Service { + ILL_Electronic_Delivery_Service_0 *e_delivery_service; /* OPT */ + ILL_Electronic_Delivery_Service_1 *document_type; /* OPT */ + ILL_String *e_delivery_description; /* OPT */ + int which; + union { + ILL_System_Address *e_delivery_address; + ILL_System_Id *e_delivery_id; +#define ILL_Electronic_Delivery_Service_e_delivery_address 1 +#define ILL_Electronic_Delivery_Service_e_delivery_id 2 + } u; + ILL_String *name_or_code; /* OPT */ + ILL_ISO_Time *delivery_time; /* OPT */ +}; + +struct ILL_Error_Report { + ILL_String *correlation_information; + ILL_Report_Source *report_source; + ILL_User_Error_Report *user_error_report; /* OPT */ + ILL_Provider_Error_Report *provider_error_report; /* OPT */ +}; + +struct ILL_Estimate_Results { + ILL_String *cost_estimate; + int num_locations; + ILL_Location_Info **locations; /* OPT */ +}; + +struct ILL_Extension { + int *identifier; + bool_t *critical; + Odr_any *item; +}; + +#define ILL_General_Problem_unrecognized_APDU 1 +#define ILL_General_Problem_mistyped_APDU 2 +#define ILL_General_Problem_badly_structured_APDU 3 +#define ILL_General_Problem_protocol_version_not_supported 4 +#define ILL_General_Problem_other 5 + +struct ILL_History_Report { + ILL_ISO_Date *date_requested; /* OPT */ + ILL_String *author; /* OPT */ + ILL_String *title; /* OPT */ + ILL_String *author_of_article; /* OPT */ + ILL_String *title_of_article; /* OPT */ + ILL_ISO_Date *date_of_last_transition; +#define ILL_History_Report_iLL_REQUEST 1 +#define ILL_History_Report_fORWARD 21 +#define ILL_History_Report_fORWARD_NOTIFICATION 2 +#define ILL_History_Report_sHIPPED 3 +#define ILL_History_Report_iLL_ANSWER 4 +#define ILL_History_Report_cONDITIONAL_REPLY 5 +#define ILL_History_Report_cANCEL 6 +#define ILL_History_Report_cANCEL_REPLY 7 +#define ILL_History_Report_rECEIVED 8 +#define ILL_History_Report_rECALL 9 +#define ILL_History_Report_rETURNED 10 +#define ILL_History_Report_cHECKED_IN 11 +#define ILL_History_Report_rENEW_ANSWER 14 +#define ILL_History_Report_lOST 15 +#define ILL_History_Report_dAMAGED 16 +#define ILL_History_Report_mESSAGE 17 +#define ILL_History_Report_sTATUS_QUERY 18 +#define ILL_History_Report_sTATUS_OR_ERROR_REPORT 19 +#define ILL_History_Report_eXPIRED 20 + int *most_recent_service; + ILL_ISO_Date *date_of_most_recent_service; + ILL_System_Id *initiator_of_most_recent_service; + ILL_Shipped_Service_Type *shipped_service_type; /* OPT */ + ILL_Transaction_Results *transaction_results; /* OPT */ + ILL_String *most_recent_service_note; /* OPT */ +}; + +struct ILL_Hold_Placed_Results { + ILL_ISO_Date *estimated_date_available; + ILL_Medium_Type *hold_placed_medium_type; /* OPT */ + int num_locations; + ILL_Location_Info **locations; /* OPT */ +}; + +#define ILL_APDU_Type_iLL_REQUEST 1 +#define ILL_APDU_Type_fORWARD_NOTIFICATION 2 +#define ILL_APDU_Type_sHIPPED 3 +#define ILL_APDU_Type_iLL_ANSWER 4 +#define ILL_APDU_Type_cONDITIONAL_REPLY 5 +#define ILL_APDU_Type_cANCEL 6 +#define ILL_APDU_Type_cANCEL_REPLY 7 +#define ILL_APDU_Type_rECEIVED 8 +#define ILL_APDU_Type_rECALL 9 +#define ILL_APDU_Type_rETURNED 10 +#define ILL_APDU_Type_cHECKED_IN 11 +#define ILL_APDU_Type_oVERDUE 12 +#define ILL_APDU_Type_rENEW 13 +#define ILL_APDU_Type_rENEW_ANSWER 14 +#define ILL_APDU_Type_lOST 15 +#define ILL_APDU_Type_dAMAGED 16 +#define ILL_APDU_Type_mESSAGE 17 +#define ILL_APDU_Type_sTATUS_QUERY 18 +#define ILL_APDU_Type_sTATUS_OR_ERROR_REPORT 19 +#define ILL_APDU_Type_eXPIRED 20 + +#define ILL_Service_Type_loan 1 +#define ILL_Service_Type_copy_non_returnable 2 +#define ILL_Service_Type_locations 3 +#define ILL_Service_Type_estimate 4 +#define ILL_Service_Type_responder_specific 5 + +struct ILL_String { + int which; + union { + char *GeneralString; + ILL_EDIFACTString *EDIFACTString; +#define ILL_String_GeneralString 1 +#define ILL_String_EDIFACTString 2 + } u; +}; + +#define ILL_Intermediary_Problem_cannot_send_onward 1 + + + + + +struct ILL_Item_Id { +#define ILL_Item_Id_monograph 1 +#define ILL_Item_Id_serial 2 +#define ILL_Item_Id_other 3 + int *item_type; /* OPT */ + ILL_Medium_Type *held_medium_type; /* OPT */ + ILL_String *call_number; /* OPT */ + ILL_String *author; /* OPT */ + ILL_String *title; /* OPT */ + ILL_String *sub_title; /* OPT */ + ILL_String *sponsoring_body; /* OPT */ + ILL_String *place_of_publication; /* OPT */ + ILL_String *publisher; /* OPT */ + ILL_String *series_title_number; /* OPT */ + ILL_String *volume_issue; /* OPT */ + ILL_String *edition; /* OPT */ + ILL_String *publication_date; /* OPT */ + ILL_String *publication_date_of_component; /* OPT */ + ILL_String *author_of_article; /* OPT */ + ILL_String *title_of_article; /* OPT */ + ILL_String *pagination; /* OPT */ + Odr_external *national_bibliography_no; /* OPT */ + ILL_String *iSBN; /* OPT */ + ILL_String *iSSN; /* OPT */ + Odr_external *system_no; /* OPT */ + ILL_String *additional_no_letters; /* OPT */ + ILL_String *verification_reference_source; /* OPT */ +}; + +struct ILL_Location_Info { + ILL_System_Id *location_id; + ILL_System_Address *location_address; /* OPT */ + ILL_String *location_note; /* OPT */ +}; + +struct ILL_Locations_Results { + ILL_Reason_Locs_Provided *reason_locs_provided; /* OPT */ + int num_locations; + ILL_Location_Info **locations; +}; + +#define ILL_Medium_Type_printed 1 +#define ILL_Medium_Type_microform 3 +#define ILL_Medium_Type_film_or_video_recording 4 +#define ILL_Medium_Type_audio_recording 5 +#define ILL_Medium_Type_machine_readable 6 +#define ILL_Medium_Type_other 7 + +struct ILL_Name_Of_Person_Or_Institution { + int which; + union { + ILL_String *name_of_person; + ILL_String *name_of_institution; +#define ILL_Name_Of_Person_Or_Institution_name_of_person 1 +#define ILL_Name_Of_Person_Or_Institution_name_of_institution 2 + } u; +}; + +struct ILL_Person_Or_Institution_Symbol { + int which; + union { + ILL_String *person_symbol; + ILL_String *institution_symbol; +#define ILL_Person_Or_Institution_Symbol_person_symbol 1 +#define ILL_Person_Or_Institution_Symbol_institution_symbol 2 + } u; +}; + +#define ILL_Place_On_Hold_Type_yes 1 +#define ILL_Place_On_Hold_Type_no 2 +#define ILL_Place_On_Hold_Type_according_to_responder_policy 3 + +struct ILL_Postal_Address { + ILL_Name_Of_Person_Or_Institution *name_of_person_or_institution; /* OPT */ + ILL_String *extended_postal_delivery_address; /* OPT */ + ILL_String *street_and_number; /* OPT */ + ILL_String *post_office_box; /* OPT */ + ILL_String *city; /* OPT */ + ILL_String *region; /* OPT */ + ILL_String *country; /* OPT */ + ILL_String *postal_code; /* OPT */ +}; + +struct ILL_Provider_Error_Report { + int which; + union { + ILL_General_Problem *general_problem; + ILL_Transaction_Id_Problem *transaction_id_problem; + ILL_State_Transition_Prohibited *state_transition_prohibited; +#define ILL_Provider_Error_Report_general_problem 1 +#define ILL_Provider_Error_Report_transaction_id_problem 2 +#define ILL_Provider_Error_Report_state_transition_prohibited 3 + } u; +}; + +#define ILL_Reason_Locs_Provided_in_use_on_loan 1 +#define ILL_Reason_Locs_Provided_in_process 2 +#define ILL_Reason_Locs_Provided_lost 3 +#define ILL_Reason_Locs_Provided_non_circulating 4 +#define ILL_Reason_Locs_Provided_not_owned 5 +#define ILL_Reason_Locs_Provided_on_order 6 +#define ILL_Reason_Locs_Provided_volume_issue_not_yet_available 7 +#define ILL_Reason_Locs_Provided_at_bindery 8 +#define ILL_Reason_Locs_Provided_lacking 9 +#define ILL_Reason_Locs_Provided_not_on_shelf 10 +#define ILL_Reason_Locs_Provided_on_reserve 11 +#define ILL_Reason_Locs_Provided_poor_condition 12 +#define ILL_Reason_Locs_Provided_cost_exceeds_limit 13 +#define ILL_Reason_Locs_Provided_on_hold 19 +#define ILL_Reason_Locs_Provided_other 27 +#define ILL_Reason_Locs_Provided_responder_specific 28 + +#define ILL_Reason_No_Report_temporary 1 +#define ILL_Reason_No_Report_permanent 2 + +#define ILL_Reason_Unfilled_in_use_on_loan 1 +#define ILL_Reason_Unfilled_in_process 2 +#define ILL_Reason_Unfilled_lost 3 +#define ILL_Reason_Unfilled_non_circulating 4 +#define ILL_Reason_Unfilled_not_owned 5 +#define ILL_Reason_Unfilled_on_order 6 +#define ILL_Reason_Unfilled_volume_issue_not_yet_available 7 +#define ILL_Reason_Unfilled_at_bindery 8 +#define ILL_Reason_Unfilled_lacking 9 +#define ILL_Reason_Unfilled_not_on_shelf 10 +#define ILL_Reason_Unfilled_on_reserve 11 +#define ILL_Reason_Unfilled_poor_condition 12 +#define ILL_Reason_Unfilled_cost_exceeds_limit 13 +#define ILL_Reason_Unfilled_charges 14 +#define ILL_Reason_Unfilled_prepayment_required 15 +#define ILL_Reason_Unfilled_lacks_copyright_compliance 16 +#define ILL_Reason_Unfilled_not_found_as_cited 17 +#define ILL_Reason_Unfilled_locations_not_found 18 +#define ILL_Reason_Unfilled_on_hold 19 +#define ILL_Reason_Unfilled_policy_problem 20 +#define ILL_Reason_Unfilled_mandatory_messaging_not_supported 21 +#define ILL_Reason_Unfilled_expiry_not_supported 22 +#define ILL_Reason_Unfilled_requested_delivery_services_not_supported 23 +#define ILL_Reason_Unfilled_preferred_delivery_time_not_possible 24 +#define ILL_Reason_Unfilled_other 27 +#define ILL_Reason_Unfilled_responder_specific 28 + +#define ILL_Report_Source_user 1 +#define ILL_Report_Source_provider 2 + +struct ILL_Requester_Optional_Messages_Type { + bool_t *can_send_RECEIVED; + bool_t *can_send_RETURNED; +#define ILL_Requester_Optional_Messages_Type_requires 1 +#define ILL_Requester_Optional_Messages_Type_desires 2 +#define ILL_Requester_Optional_Messages_Type_neither 3 + int *requester_SHIPPED; +#define ILL_Requester_Optional_Messages_Type_requires 1 +#define ILL_Requester_Optional_Messages_Type_desires 2 +#define ILL_Requester_Optional_Messages_Type_neither 3 + int *requester_CHECKED_IN; +}; + +struct ILL_Responder_Optional_Messages_Type { + bool_t *can_send_SHIPPED; + bool_t *can_send_CHECKED_IN; +#define ILL_Responder_Optional_Messages_Type_requires 1 +#define ILL_Responder_Optional_Messages_Type_desires 2 +#define ILL_Responder_Optional_Messages_Type_neither 3 + int *responder_RECEIVED; +#define ILL_Responder_Optional_Messages_Type_requires 1 +#define ILL_Responder_Optional_Messages_Type_desires 2 +#define ILL_Responder_Optional_Messages_Type_neither 3 + int *responder_RETURNED; +}; + +struct ILL_Retry_Results { +#define ILL_Retry_Results_in_use_on_loan 1 +#define ILL_Retry_Results_in_process 2 +#define ILL_Retry_Results_on_order 6 +#define ILL_Retry_Results_volume_issue_not_yet_available 7 +#define ILL_Retry_Results_at_bindery 8 +#define ILL_Retry_Results_cost_exceeds_limit 13 +#define ILL_Retry_Results_charges 14 +#define ILL_Retry_Results_prepayment_required 15 +#define ILL_Retry_Results_lacks_copyright_compliance 16 +#define ILL_Retry_Results_not_found_as_cited 17 +#define ILL_Retry_Results_on_hold 19 +#define ILL_Retry_Results_other 27 +#define ILL_Retry_Results_responder_specific 28 + int *reason_not_available; /* OPT */ + ILL_ISO_Date *retry_date; /* OPT */ + int num_locations; + ILL_Location_Info **locations; /* OPT */ +}; + +struct ILL_Search_Type { + ILL_String *level_of_service; /* OPT */ + ILL_ISO_Date *need_before_date; /* OPT */ +#define ILL_Search_Type_need_Before_Date 1 +#define ILL_Search_Type_other_Date 2 +#define ILL_Search_Type_no_Expiry 3 + int *expiry_flag; + ILL_ISO_Date *expiry_date; /* OPT */ +}; + + + +struct ILL_Send_To_List_Type_s { + ILL_System_Id *system_id; + ILL_Account_Number *account_number; /* OPT */ + ILL_System_Address *system_address; /* OPT */ +}; + +struct ILL_Send_To_List_Type { + int num; + ILL_Send_To_List_Type_s **elements; +}; + +struct ILL_Service_Date_this { + ILL_ISO_Date *date; + ILL_ISO_Time *time; /* OPT */ +}; + +struct ILL_Service_Date_original { + ILL_ISO_Date *date; + ILL_ISO_Time *time; /* OPT */ +}; + +struct ILL_Service_Date_Time { + ILL_Service_Date_this *date_time_of_this_service; + ILL_Service_Date_original *date_time_of_original_service; /* OPT */ +}; + + + +struct ILL_State_Transition_Prohibited { + ILL_APDU_Type *aPDU_type; + ILL_Current_State *current_state; +}; + +struct ILL_Status_Report { + ILL_History_Report *user_status_report; + ILL_Current_State *provider_status_report; +}; + +struct ILL_Supplemental_Item_Description { + int num; + Odr_external **elements; +}; + +struct ILL_Supply_Details { + ILL_ISO_Date *date_shipped; /* OPT */ + ILL_Date_Due *date_due; /* OPT */ + int *chargeable_units; /* OPT */ + ILL_Amount *cost; /* OPT */ +#define ILL_Supply_Details_library_use_only 22 +#define ILL_Supply_Details_no_reproduction 23 +#define ILL_Supply_Details_client_signature_required 24 +#define ILL_Supply_Details_special_collections_supervision_required 25 +#define ILL_Supply_Details_other 27 + int *shipped_conditions; /* OPT */ + int which; + union { + ILL_Transportation_Mode *physical_delivery; + ILL_Electronic_Delivery_Service *electronic_delivery; +#define ILL_Supply_Details_physical_delivery 1 +#define ILL_Supply_Details_electronic_delivery 2 + } u; /* OPT */ + ILL_Amount *insured_for; /* OPT */ + ILL_Amount *return_insurance_require; /* OPT */ + int num_no_of_units_per_medium; + ILL_Units_Per_Medium_Type **no_of_units_per_medium; /* OPT */ +}; + +struct ILL_Supply_Medium_Info_Type { + ILL_Supply_Medium_Type *supply_medium_type; + ILL_String *medium_characteristics; /* OPT */ +}; + +#define ILL_Supply_Medium_Type_printed 1 +#define ILL_Supply_Medium_Type_photocopy 2 +#define ILL_Supply_Medium_Type_microform 3 +#define ILL_Supply_Medium_Type_film_or_video_recording 4 +#define ILL_Supply_Medium_Type_audio_recording 5 +#define ILL_Supply_Medium_Type_machine_readable 6 +#define ILL_Supply_Medium_Type_other 7 + +struct ILL_System_Address { + ILL_String *telecom_service_identifier; /* OPT */ + ILL_String *telecom_service_address; /* OPT */ +}; + +struct ILL_System_Id { + ILL_Person_Or_Institution_Symbol *person_or_institution_symbol; /* OPT */ + ILL_Name_Of_Person_Or_Institution *name_of_person_or_institution; /* OPT */ +}; + +struct ILL_Third_Party_Info_Type { + bool_t *permission_to_forward; + bool_t *permission_to_chain; + bool_t *permission_to_partition; + bool_t *permission_to_change_send_to_list; + ILL_System_Address *initial_requester_address; /* OPT */ +#define ILL_Third_Party_Info_Type_ordered 1 +#define ILL_Third_Party_Info_Type_unordered 2 + int *preference; + ILL_Send_To_List_Type *send_to_list; /* OPT */ + ILL_Already_Tried_List_Type *already_tried_list; /* OPT */ +}; + +struct ILL_Transaction_Id { + ILL_System_Id *initial_requester_id; /* OPT */ + ILL_String *transaction_group_qualifier; + ILL_String *transaction_qualifier; + ILL_String *sub_transaction_qualifier; /* OPT */ +}; + +#define ILL_Transaction_Id_Problem_duplicate_transaction_id 1 +#define ILL_Transaction_Id_Problem_invalid_transaction_id 2 +#define ILL_Transaction_Id_Problem_unknown_transaction_id 3 + +#define ILL_Transaction_Results_conditional 1 +#define ILL_Transaction_Results_retry 2 +#define ILL_Transaction_Results_unfilled 3 +#define ILL_Transaction_Results_locations_provided 4 +#define ILL_Transaction_Results_will_supply 5 +#define ILL_Transaction_Results_hold_placed 6 +#define ILL_Transaction_Results_estimate 7 + +#define ILL_Transaction_Type_simple 1 +#define ILL_Transaction_Type_chained 2 +#define ILL_Transaction_Type_partitioned 3 + + + +#define ILL_Unable_To_Perform_not_available 1 +#define ILL_Unable_To_Perform_resource_limitation 2 +#define ILL_Unable_To_Perform_other 3 + +struct ILL_Unfilled_Results { + ILL_Reason_Unfilled *reason_unfilled; + int num_locations; + ILL_Location_Info **locations; /* OPT */ +}; + +struct ILL_Units_Per_Medium_Type { + ILL_Supply_Medium_Type *medium; + int *no_of_units; +}; + +struct ILL_User_Error_Report { + int which; + union { + ILL_Already_Forwarded *already_forwarded; + ILL_Intermediary_Problem *intermediary_problem; + ILL_Security_Problem *security_problem; + ILL_Unable_To_Perform *unable_to_perform; +#define ILL_User_Error_Report_already_forwarded 1 +#define ILL_User_Error_Report_intermediary_problem 2 +#define ILL_User_Error_Report_security_problem 3 +#define ILL_User_Error_Report_unable_to_perform 4 + } u; +}; + +struct ILL_Will_Supply_Results { +#define ILL_Will_Supply_Results_in_use_on_loan 1 +#define ILL_Will_Supply_Results_in_process 2 +#define ILL_Will_Supply_Results_on_order 6 +#define ILL_Will_Supply_Results_at_bindery 8 +#define ILL_Will_Supply_Results_on_hold 19 +#define ILL_Will_Supply_Results_being_processed_for_supply 26 +#define ILL_Will_Supply_Results_other 27 +#define ILL_Will_Supply_Results_responder_specific 28 +#define ILL_Will_Supply_Results_electronic_delivery 30 + int *reason_will_supply; + ILL_ISO_Date *supply_date; /* OPT */ + ILL_Postal_Address *return_to_address; /* OPT */ + int num_locations; + ILL_Location_Info **locations; /* OPT */ + ILL_Electronic_Delivery_Service *electronic_delivery_service; /* OPT */ +}; + + + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/yaz/z-accdes1.h b/include/yaz/z-accdes1.h new file mode 100644 index 0000000..f207a64 --- /dev/null +++ b/include/yaz/z-accdes1.h @@ -0,0 +1,42 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H AccessControlFormat-des-1 */ + +#ifndef z_accdes1_H +#define z_accdes1_H + +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_DES_RN_Object Z_DES_RN_Object; +YAZ_EXPORT int z_DES_RN_Object (ODR o, Z_DES_RN_Object **p, int opt, const char *name); + +typedef struct Z_DRNType Z_DRNType; +YAZ_EXPORT int z_DRNType (ODR o, Z_DRNType **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_DES_RN_Object { + int which; + union { + Z_DRNType *challenge; + Z_DRNType *response; +#define Z_DES_RN_Object_challenge 1 +#define Z_DES_RN_Object_response 2 + } u; +}; + +struct Z_DRNType { + Odr_oct *userId; /* OPT */ + Odr_oct *salt; /* OPT */ + Odr_oct *randomNumber; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-accform1.h b/include/yaz/z-accform1.h new file mode 100644 index 0000000..390e0fd --- /dev/null +++ b/include/yaz/z-accform1.h @@ -0,0 +1,134 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H AccessControlFormat-prompt-1 */ + +#ifndef z_accform1_H +#define z_accform1_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_PromptObject1 Z_PromptObject1; +YAZ_EXPORT int z_PromptObject1 (ODR o, Z_PromptObject1 **p, int opt, const char *name); + +typedef struct Z_ChallengeUnit1 Z_ChallengeUnit1; +YAZ_EXPORT int z_ChallengeUnit1 (ODR o, Z_ChallengeUnit1 **p, int opt, const char *name); + +typedef struct Z_Challenge1 Z_Challenge1; +YAZ_EXPORT int z_Challenge1 (ODR o, Z_Challenge1 **p, int opt, const char *name); + +typedef struct Z_ResponseUnit1 Z_ResponseUnit1; +YAZ_EXPORT int z_ResponseUnit1 (ODR o, Z_ResponseUnit1 **p, int opt, const char *name); + +typedef struct Z_Response1 Z_Response1; +YAZ_EXPORT int z_Response1 (ODR o, Z_Response1 **p, int opt, const char *name); + +typedef struct Z_PromptIdEnumeratedPrompt Z_PromptIdEnumeratedPrompt; +YAZ_EXPORT int z_PromptIdEnumeratedPrompt (ODR o, Z_PromptIdEnumeratedPrompt **p, int opt, const char *name); + +typedef struct Z_PromptId Z_PromptId; +YAZ_EXPORT int z_PromptId (ODR o, Z_PromptId **p, int opt, const char *name); + +typedef struct Z_Encryption Z_Encryption; +YAZ_EXPORT int z_Encryption (ODR o, Z_Encryption **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_PromptObject1 { + int which; + union { + Z_Challenge1 *challenge; + Z_Response1 *response; +#define Z_PromptObject1_challenge 1 +#define Z_PromptObject1_response 2 + } u; +}; + +struct Z_ChallengeUnit1 { + Z_PromptId *promptId; + Z_InternationalString *defaultResponse; /* OPT */ + int which; + union { + Z_InternationalString *character; + Z_Encryption *encrypted; +#define Z_ChallengeUnit1_character 1 +#define Z_ChallengeUnit1_encrypted 2 + } u; /* OPT */ + Z_InternationalString *regExpr; /* OPT */ + Odr_null *responseRequired; /* OPT */ + int num_allowedValues; + Z_InternationalString **allowedValues; /* OPT */ + Odr_null *shouldSave; /* OPT */ +#define Z_ChallengeUnit1_integer 1 +#define Z_ChallengeUnit1_date 2 +#define Z_ChallengeUnit1_float 3 +#define Z_ChallengeUnit1_alphaNumeric 4 +#define Z_ChallengeUnit1_url_urn 5 +#define Z_ChallengeUnit1_boolean 6 + int *dataType; /* OPT */ + Z_External *diagnostic; /* OPT */ +}; + +struct Z_Challenge1 { + int num; + Z_ChallengeUnit1 **elements; +}; + +struct Z_ResponseUnit1 { + Z_PromptId *promptId; + int which; + union { + Z_InternationalString *string; + bool_t *accept; + Odr_null *acknowledge; + Z_DiagRec *diagnostic; + Z_Encryption *encrypted; +#define Z_ResponseUnit1_string 1 +#define Z_ResponseUnit1_accept 2 +#define Z_ResponseUnit1_acknowledge 3 +#define Z_ResponseUnit1_diagnostic 4 +#define Z_ResponseUnit1_encrypted 5 + } u; +}; + +struct Z_Response1 { + int num; + Z_ResponseUnit1 **elements; +}; + +struct Z_PromptIdEnumeratedPrompt { +#define Z_PromptIdEnumeratedPrompt_groupId 0 +#define Z_PromptIdEnumeratedPrompt_userId 1 +#define Z_PromptIdEnumeratedPrompt_password 2 +#define Z_PromptIdEnumeratedPrompt_newPassword 3 +#define Z_PromptIdEnumeratedPrompt_copyright 4 +#define Z_PromptIdEnumeratedPrompt_sessionId 5 + int *type; + Z_InternationalString *suggestedString; /* OPT */ +}; + +struct Z_PromptId { + int which; + union { + Z_PromptIdEnumeratedPrompt *enumeratedPrompt; + Z_InternationalString *nonEnumeratedPrompt; +#define Z_PromptId_enumeratedPrompt 1 +#define Z_PromptId_nonEnumeratedPrompt 2 + } u; +}; + +struct Z_Encryption { + Odr_oct *cryptType; /* OPT */ + Odr_oct *credential; /* OPT */ + Odr_oct *data; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-acckrb1.h b/include/yaz/z-acckrb1.h new file mode 100644 index 0000000..218a526 --- /dev/null +++ b/include/yaz/z-acckrb1.h @@ -0,0 +1,51 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H AccessControlFormat-krb-1 */ + +#ifndef z_acckrb1_H +#define z_acckrb1_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_KRBObject Z_KRBObject; +YAZ_EXPORT int z_KRBObject (ODR o, Z_KRBObject **p, int opt, const char *name); + +typedef struct Z_KRBRequest Z_KRBRequest; +YAZ_EXPORT int z_KRBRequest (ODR o, Z_KRBRequest **p, int opt, const char *name); + +typedef struct Z_KRBResponse Z_KRBResponse; +YAZ_EXPORT int z_KRBResponse (ODR o, Z_KRBResponse **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_KRBObject { + int which; + union { + Z_KRBRequest *challenge; + Z_KRBResponse *response; +#define Z_KRBObject_challenge 1 +#define Z_KRBObject_response 2 + } u; +}; + +struct Z_KRBRequest { + Z_InternationalString *service; + Z_InternationalString *instance; /* OPT */ + Z_InternationalString *realm; /* OPT */ +}; + +struct Z_KRBResponse { + Z_InternationalString *userid; /* OPT */ + Odr_oct *ticket; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-core.h b/include/yaz/z-core.h new file mode 100644 index 0000000..7b5d250 --- /dev/null +++ b/include/yaz/z-core.h @@ -0,0 +1,1220 @@ +/* YC 0.2: Tue Feb 29 16:45:06 CET 2000 */ +/* Module-H Z39-50-APDU-1995 */ + +#ifndef z_core_H +#define z_core_H + +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_External Z_External; +YAZ_EXPORT int z_External(ODR o, Z_External **p, int opt, const char *name); + + +typedef struct Z_APDU Z_APDU; +YAZ_EXPORT int z_APDU (ODR o, Z_APDU **p, int opt, const char *name); + +typedef struct Z_InitRequest Z_InitRequest; +YAZ_EXPORT int z_InitRequest (ODR o, Z_InitRequest **p, int opt, const char *name); + +typedef struct Z_IdPass Z_IdPass; +YAZ_EXPORT int z_IdPass (ODR o, Z_IdPass **p, int opt, const char *name); + +typedef struct Z_IdAuthentication Z_IdAuthentication; +YAZ_EXPORT int z_IdAuthentication (ODR o, Z_IdAuthentication **p, int opt, const char *name); + +typedef struct Z_InitResponse Z_InitResponse; +YAZ_EXPORT int z_InitResponse (ODR o, Z_InitResponse **p, int opt, const char *name); + +typedef Odr_bitmask Z_ProtocolVersion; +YAZ_EXPORT int z_ProtocolVersion (ODR o, Z_ProtocolVersion **p, int opt, const char *name); + +typedef Odr_bitmask Z_Options; +YAZ_EXPORT int z_Options (ODR o, Z_Options **p, int opt, const char *name); + +typedef struct Z_SearchRequest Z_SearchRequest; +YAZ_EXPORT int z_SearchRequest (ODR o, Z_SearchRequest **p, int opt, const char *name); + +typedef struct Z_Query Z_Query; +YAZ_EXPORT int z_Query (ODR o, Z_Query **p, int opt, const char *name); + +typedef struct Z_RPNQuery Z_RPNQuery; +YAZ_EXPORT int z_RPNQuery (ODR o, Z_RPNQuery **p, int opt, const char *name); + +typedef struct Z_Complex Z_Complex; +YAZ_EXPORT int z_Complex (ODR o, Z_Complex **p, int opt, const char *name); + +typedef struct Z_RPNStructure Z_RPNStructure; +YAZ_EXPORT int z_RPNStructure (ODR o, Z_RPNStructure **p, int opt, const char *name); + +typedef struct Z_Operand Z_Operand; +YAZ_EXPORT int z_Operand (ODR o, Z_Operand **p, int opt, const char *name); + +typedef struct Z_AttributesPlusTerm Z_AttributesPlusTerm; +YAZ_EXPORT int z_AttributesPlusTerm (ODR o, Z_AttributesPlusTerm **p, int opt, const char *name); + +typedef struct Z_ResultSetPlusAttributes Z_ResultSetPlusAttributes; +YAZ_EXPORT int z_ResultSetPlusAttributes (ODR o, Z_ResultSetPlusAttributes **p, int opt, const char *name); + +typedef struct Z_AttributeList Z_AttributeList; +YAZ_EXPORT int z_AttributeList (ODR o, Z_AttributeList **p, int opt, const char *name); + +typedef struct Z_Term Z_Term; +YAZ_EXPORT int z_Term (ODR o, Z_Term **p, int opt, const char *name); + +typedef struct Z_Operator Z_Operator; +YAZ_EXPORT int z_Operator (ODR o, Z_Operator **p, int opt, const char *name); + +typedef struct Z_ComplexAttribute Z_ComplexAttribute; +YAZ_EXPORT int z_ComplexAttribute (ODR o, Z_ComplexAttribute **p, int opt, const char *name); + +typedef struct Z_AttributeElement Z_AttributeElement; +YAZ_EXPORT int z_AttributeElement (ODR o, Z_AttributeElement **p, int opt, const char *name); + +typedef struct Z_ProximityOperator Z_ProximityOperator; +YAZ_EXPORT int z_ProximityOperator (ODR o, Z_ProximityOperator **p, int opt, const char *name); + +typedef int Z_ProxUnit; +YAZ_EXPORT int z_ProxUnit (ODR o, Z_ProxUnit **p, int opt, const char *name); + +typedef struct Z_SearchResponse Z_SearchResponse; +YAZ_EXPORT int z_SearchResponse (ODR o, Z_SearchResponse **p, int opt, const char *name); + +typedef struct Z_RecordComposition Z_RecordComposition; +YAZ_EXPORT int z_RecordComposition (ODR o, Z_RecordComposition **p, int opt, const char *name); + +typedef struct Z_PresentRequest Z_PresentRequest; +YAZ_EXPORT int z_PresentRequest (ODR o, Z_PresentRequest **p, int opt, const char *name); + +typedef struct Z_Segment Z_Segment; +YAZ_EXPORT int z_Segment (ODR o, Z_Segment **p, int opt, const char *name); + +typedef struct Z_PresentResponse Z_PresentResponse; +YAZ_EXPORT int z_PresentResponse (ODR o, Z_PresentResponse **p, int opt, const char *name); + +typedef struct Z_NamePlusRecordList Z_NamePlusRecordList; +YAZ_EXPORT int z_NamePlusRecordList (ODR o, Z_NamePlusRecordList **p, int opt, const char *name); + +typedef struct Z_DiagRecs Z_DiagRecs; +YAZ_EXPORT int z_DiagRecs (ODR o, Z_DiagRecs **p, int opt, const char *name); + +typedef struct Z_Records Z_Records; +YAZ_EXPORT int z_Records (ODR o, Z_Records **p, int opt, const char *name); + +typedef struct Z_NamePlusRecord Z_NamePlusRecord; +YAZ_EXPORT int z_NamePlusRecord (ODR o, Z_NamePlusRecord **p, int opt, const char *name); + +typedef struct Z_FragmentSyntax Z_FragmentSyntax; +YAZ_EXPORT int z_FragmentSyntax (ODR o, Z_FragmentSyntax **p, int opt, const char *name); + +typedef struct Z_DiagRec Z_DiagRec; +YAZ_EXPORT int z_DiagRec (ODR o, Z_DiagRec **p, int opt, const char *name); + +typedef struct Z_DefaultDiagFormat Z_DefaultDiagFormat; +YAZ_EXPORT int z_DefaultDiagFormat (ODR o, Z_DefaultDiagFormat **p, int opt, const char *name); + +typedef struct Z_Range Z_Range; +YAZ_EXPORT int z_Range (ODR o, Z_Range **p, int opt, const char *name); + +typedef struct Z_DatabaseSpecificUnit Z_DatabaseSpecificUnit; +YAZ_EXPORT int z_DatabaseSpecificUnit (ODR o, Z_DatabaseSpecificUnit **p, int opt, const char *name); + +typedef struct Z_DatabaseSpecific Z_DatabaseSpecific; +YAZ_EXPORT int z_DatabaseSpecific (ODR o, Z_DatabaseSpecific **p, int opt, const char *name); + +typedef struct Z_ElementSetNames Z_ElementSetNames; +YAZ_EXPORT int z_ElementSetNames (ODR o, Z_ElementSetNames **p, int opt, const char *name); + +typedef int Z_PresentStatus; +YAZ_EXPORT int z_PresentStatus (ODR o, Z_PresentStatus **p, int opt, const char *name); + +typedef struct Z_DbSpecific Z_DbSpecific; +YAZ_EXPORT int z_DbSpecific (ODR o, Z_DbSpecific **p, int opt, const char *name); + +typedef struct Z_CompSpec Z_CompSpec; +YAZ_EXPORT int z_CompSpec (ODR o, Z_CompSpec **p, int opt, const char *name); + +typedef struct Z_ElementSpec Z_ElementSpec; +YAZ_EXPORT int z_ElementSpec (ODR o, Z_ElementSpec **p, int opt, const char *name); + +typedef struct Z_Specification Z_Specification; +YAZ_EXPORT int z_Specification (ODR o, Z_Specification **p, int opt, const char *name); + +typedef struct Z_DeleteResultSetRequest Z_DeleteResultSetRequest; +YAZ_EXPORT int z_DeleteResultSetRequest (ODR o, Z_DeleteResultSetRequest **p, int opt, const char *name); + +typedef struct Z_DeleteResultSetResponse Z_DeleteResultSetResponse; +YAZ_EXPORT int z_DeleteResultSetResponse (ODR o, Z_DeleteResultSetResponse **p, int opt, const char *name); + +typedef struct Z_ListStatus Z_ListStatus; +YAZ_EXPORT int z_ListStatus (ODR o, Z_ListStatus **p, int opt, const char *name); + +typedef struct Z_ListStatuses Z_ListStatuses; +YAZ_EXPORT int z_ListStatuses (ODR o, Z_ListStatuses **p, int opt, const char *name); + +typedef int Z_DeleteStatus; +YAZ_EXPORT int z_DeleteStatus (ODR o, Z_DeleteStatus **p, int opt, const char *name); + +typedef struct Z_AccessControlRequest Z_AccessControlRequest; +YAZ_EXPORT int z_AccessControlRequest (ODR o, Z_AccessControlRequest **p, int opt, const char *name); + +typedef struct Z_AccessControlResponse Z_AccessControlResponse; +YAZ_EXPORT int z_AccessControlResponse (ODR o, Z_AccessControlResponse **p, int opt, const char *name); + +typedef struct Z_ResourceControlRequest Z_ResourceControlRequest; +YAZ_EXPORT int z_ResourceControlRequest (ODR o, Z_ResourceControlRequest **p, int opt, const char *name); + +typedef struct Z_ResourceControlResponse Z_ResourceControlResponse; +YAZ_EXPORT int z_ResourceControlResponse (ODR o, Z_ResourceControlResponse **p, int opt, const char *name); + +typedef struct Z_TriggerResourceControlRequest Z_TriggerResourceControlRequest; +YAZ_EXPORT int z_TriggerResourceControlRequest (ODR o, Z_TriggerResourceControlRequest **p, int opt, const char *name); + +typedef struct Z_ResourceReportRequest Z_ResourceReportRequest; +YAZ_EXPORT int z_ResourceReportRequest (ODR o, Z_ResourceReportRequest **p, int opt, const char *name); + +typedef struct Z_ResourceReportResponse Z_ResourceReportResponse; +YAZ_EXPORT int z_ResourceReportResponse (ODR o, Z_ResourceReportResponse **p, int opt, const char *name); + +typedef Z_External Z_ResourceReport; +YAZ_EXPORT int z_ResourceReport (ODR o, Z_ResourceReport **p, int opt, const char *name); + +typedef Odr_oid Z_ResourceReportId; +YAZ_EXPORT int z_ResourceReportId (ODR o, Z_ResourceReportId **p, int opt, const char *name); + +typedef struct Z_ScanRequest Z_ScanRequest; +YAZ_EXPORT int z_ScanRequest (ODR o, Z_ScanRequest **p, int opt, const char *name); + +typedef struct Z_ScanResponse Z_ScanResponse; +YAZ_EXPORT int z_ScanResponse (ODR o, Z_ScanResponse **p, int opt, const char *name); + +typedef struct Z_ListEntries Z_ListEntries; +YAZ_EXPORT int z_ListEntries (ODR o, Z_ListEntries **p, int opt, const char *name); + +typedef struct Z_Entry Z_Entry; +YAZ_EXPORT int z_Entry (ODR o, Z_Entry **p, int opt, const char *name); + +typedef struct Z_TermInfo Z_TermInfo; +YAZ_EXPORT int z_TermInfo (ODR o, Z_TermInfo **p, int opt, const char *name); + +typedef struct Z_byDatabaseList_s Z_byDatabaseList_s; +YAZ_EXPORT int z_byDatabaseList_s (ODR o, Z_byDatabaseList_s **p, int opt, const char *name); + +typedef struct Z_byDatabaseList Z_byDatabaseList; +YAZ_EXPORT int z_byDatabaseList (ODR o, Z_byDatabaseList **p, int opt, const char *name); + +typedef struct Z_OccurrenceByAttributesElem Z_OccurrenceByAttributesElem; +YAZ_EXPORT int z_OccurrenceByAttributesElem (ODR o, Z_OccurrenceByAttributesElem **p, int opt, const char *name); + +typedef struct Z_OccurrenceByAttributes Z_OccurrenceByAttributes; +YAZ_EXPORT int z_OccurrenceByAttributes (ODR o, Z_OccurrenceByAttributes **p, int opt, const char *name); + +typedef struct Z_SortKeySpecList Z_SortKeySpecList; +YAZ_EXPORT int z_SortKeySpecList (ODR o, Z_SortKeySpecList **p, int opt, const char *name); + +typedef struct Z_SortRequest Z_SortRequest; +YAZ_EXPORT int z_SortRequest (ODR o, Z_SortRequest **p, int opt, const char *name); + +typedef struct Z_SortResponse Z_SortResponse; +YAZ_EXPORT int z_SortResponse (ODR o, Z_SortResponse **p, int opt, const char *name); + +typedef struct Z_SortKeySpec Z_SortKeySpec; +YAZ_EXPORT int z_SortKeySpec (ODR o, Z_SortKeySpec **p, int opt, const char *name); + +typedef struct Z_SortDbSpecificList_s Z_SortDbSpecificList_s; +YAZ_EXPORT int z_SortDbSpecificList_s (ODR o, Z_SortDbSpecificList_s **p, int opt, const char *name); + +typedef struct Z_SortDbSpecificList Z_SortDbSpecificList; +YAZ_EXPORT int z_SortDbSpecificList (ODR o, Z_SortDbSpecificList **p, int opt, const char *name); + +typedef struct Z_SortElement Z_SortElement; +YAZ_EXPORT int z_SortElement (ODR o, Z_SortElement **p, int opt, const char *name); + +typedef struct Z_SortAttributes Z_SortAttributes; +YAZ_EXPORT int z_SortAttributes (ODR o, Z_SortAttributes **p, int opt, const char *name); + +typedef struct Z_SortKey Z_SortKey; +YAZ_EXPORT int z_SortKey (ODR o, Z_SortKey **p, int opt, const char *name); + +typedef struct Z_ExtendedServicesRequest Z_ExtendedServicesRequest; +YAZ_EXPORT int z_ExtendedServicesRequest (ODR o, Z_ExtendedServicesRequest **p, int opt, const char *name); + +typedef struct Z_ExtendedServicesResponse Z_ExtendedServicesResponse; +YAZ_EXPORT int z_ExtendedServicesResponse (ODR o, Z_ExtendedServicesResponse **p, int opt, const char *name); + +typedef struct Z_Permissions_s Z_Permissions_s; +YAZ_EXPORT int z_Permissions_s (ODR o, Z_Permissions_s **p, int opt, const char *name); + +typedef struct Z_Permissions Z_Permissions; +YAZ_EXPORT int z_Permissions (ODR o, Z_Permissions **p, int opt, const char *name); + +typedef struct Z_Close Z_Close; +YAZ_EXPORT int z_Close (ODR o, Z_Close **p, int opt, const char *name); + +typedef int Z_CloseReason; +YAZ_EXPORT int z_CloseReason (ODR o, Z_CloseReason **p, int opt, const char *name); + +typedef Odr_oct Z_ReferenceId; +YAZ_EXPORT int z_ReferenceId (ODR o, Z_ReferenceId **p, int opt, const char *name); + +typedef Odr_oid Z_AttributeSetId; +YAZ_EXPORT int z_AttributeSetId (ODR o, Z_AttributeSetId **p, int opt, const char *name); + +typedef struct Z_OtherInformationUnit Z_OtherInformationUnit; +YAZ_EXPORT int z_OtherInformationUnit (ODR o, Z_OtherInformationUnit **p, int opt, const char *name); + +typedef struct Z_OtherInformation Z_OtherInformation; +YAZ_EXPORT int z_OtherInformation (ODR o, Z_OtherInformation **p, int opt, const char *name); + +typedef struct Z_InfoCategory Z_InfoCategory; +YAZ_EXPORT int z_InfoCategory (ODR o, Z_InfoCategory **p, int opt, const char *name); + +typedef struct Z_IntUnit Z_IntUnit; +YAZ_EXPORT int z_IntUnit (ODR o, Z_IntUnit **p, int opt, const char *name); + +typedef struct Z_Unit Z_Unit; +YAZ_EXPORT int z_Unit (ODR o, Z_Unit **p, int opt, const char *name); + +typedef char Z_InternationalString; +YAZ_EXPORT int z_InternationalString (ODR o, Z_InternationalString **p, int opt, const char *name); + +typedef Z_InternationalString Z_ResultSetId; +YAZ_EXPORT int z_ResultSetId (ODR o, Z_ResultSetId **p, int opt, const char *name); + +typedef Z_InternationalString Z_ElementSetName; +YAZ_EXPORT int z_ElementSetName (ODR o, Z_ElementSetName **p, int opt, const char *name); + +typedef Z_InternationalString Z_DatabaseName; +YAZ_EXPORT int z_DatabaseName (ODR o, Z_DatabaseName **p, int opt, const char *name); + +typedef struct Z_StringOrNumeric Z_StringOrNumeric; +YAZ_EXPORT int z_StringOrNumeric (ODR o, Z_StringOrNumeric **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_APDU { + int which; + union { + Z_InitRequest *initRequest; + Z_InitResponse *initResponse; + Z_SearchRequest *searchRequest; + Z_SearchResponse *searchResponse; + Z_PresentRequest *presentRequest; + Z_PresentResponse *presentResponse; + Z_DeleteResultSetRequest *deleteResultSetRequest; + Z_DeleteResultSetResponse *deleteResultSetResponse; + Z_AccessControlRequest *accessControlRequest; + Z_AccessControlResponse *accessControlResponse; + Z_ResourceControlRequest *resourceControlRequest; + Z_ResourceControlResponse *resourceControlResponse; + Z_TriggerResourceControlRequest *triggerResourceControlRequest; + Z_ResourceReportRequest *resourceReportRequest; + Z_ResourceReportResponse *resourceReportResponse; + Z_ScanRequest *scanRequest; + Z_ScanResponse *scanResponse; + Z_SortRequest *sortRequest; + Z_SortResponse *sortResponse; + Z_Segment *segmentRequest; + Z_ExtendedServicesRequest *extendedServicesRequest; + Z_ExtendedServicesResponse *extendedServicesResponse; + Z_Close *close; +#define Z_APDU_initRequest 1 +#define Z_APDU_initResponse 2 +#define Z_APDU_searchRequest 3 +#define Z_APDU_searchResponse 4 +#define Z_APDU_presentRequest 5 +#define Z_APDU_presentResponse 6 +#define Z_APDU_deleteResultSetRequest 7 +#define Z_APDU_deleteResultSetResponse 8 +#define Z_APDU_accessControlRequest 9 +#define Z_APDU_accessControlResponse 10 +#define Z_APDU_resourceControlRequest 11 +#define Z_APDU_resourceControlResponse 12 +#define Z_APDU_triggerResourceControlRequest 13 +#define Z_APDU_resourceReportRequest 14 +#define Z_APDU_resourceReportResponse 15 +#define Z_APDU_scanRequest 16 +#define Z_APDU_scanResponse 17 +#define Z_APDU_sortRequest 18 +#define Z_APDU_sortResponse 19 +#define Z_APDU_segmentRequest 20 +#define Z_APDU_extendedServicesRequest 21 +#define Z_APDU_extendedServicesResponse 22 +#define Z_APDU_close 23 + } u; +}; + +struct Z_InitRequest { + Z_ReferenceId *referenceId; /* OPT */ + Z_ProtocolVersion *protocolVersion; + Z_Options *options; + int *preferredMessageSize; + int *maximumRecordSize; + Z_IdAuthentication *idAuthentication; /* OPT */ + Z_InternationalString *implementationId; /* OPT */ + Z_InternationalString *implementationName; /* OPT */ + Z_InternationalString *implementationVersion; /* OPT */ + Z_External *userInformationField; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_IdPass { + Z_InternationalString *groupId; /* OPT */ + Z_InternationalString *userId; /* OPT */ + Z_InternationalString *password; /* OPT */ +}; + +struct Z_IdAuthentication { + int which; + union { + char *open; + Z_IdPass *idPass; + Odr_null *anonymous; + Z_External *other; +#define Z_IdAuthentication_open 1 +#define Z_IdAuthentication_idPass 2 +#define Z_IdAuthentication_anonymous 3 +#define Z_IdAuthentication_other 4 + } u; +}; + +struct Z_InitResponse { + Z_ReferenceId *referenceId; /* OPT */ + Z_ProtocolVersion *protocolVersion; + Z_Options *options; + int *preferredMessageSize; + int *maximumRecordSize; + bool_t *result; + Z_InternationalString *implementationId; /* OPT */ + Z_InternationalString *implementationName; /* OPT */ + Z_InternationalString *implementationVersion; /* OPT */ + Z_External *userInformationField; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +#define Z_ProtocolVersion_1 0 +#define Z_ProtocolVersion_2 1 +#define Z_ProtocolVersion_3 2 + +#define Z_Options_search 0 +#define Z_Options_present 1 +#define Z_Options_delSet 2 +#define Z_Options_resourceReport 3 +#define Z_Options_triggerResourceCtrl 4 +#define Z_Options_resourceCtrl 5 +#define Z_Options_accessCtrl 6 +#define Z_Options_scan 7 +#define Z_Options_sort 8 +#define Z_Options_extendedServices 10 +#define Z_Options_level_1Segmentation 11 +#define Z_Options_level_2Segmentation 12 +#define Z_Options_concurrentOperations 13 +#define Z_Options_namedResultSets 14 + +struct Z_SearchRequest { + Z_ReferenceId *referenceId; /* OPT */ + int *smallSetUpperBound; + int *largeSetLowerBound; + int *mediumSetPresentNumber; + bool_t *replaceIndicator; + Z_InternationalString *resultSetName; + int num_databaseNames; + Z_DatabaseName **databaseNames; + Z_ElementSetNames *smallSetElementSetNames; /* OPT */ + Z_ElementSetNames *mediumSetElementSetNames; /* OPT */ + Odr_oid *preferredRecordSyntax; /* OPT */ + Z_Query *query; + Z_OtherInformation *additionalSearchInfo; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_Query { + int which; + union { + void *type_0; + Z_RPNQuery *type_1; + Odr_oct *type_2; + Odr_oct *type_100; + Z_RPNQuery *type_101; + Odr_oct *type_102; +#define Z_Query_type_0 1 +#define Z_Query_type_1 2 +#define Z_Query_type_2 3 +#define Z_Query_type_100 4 +#define Z_Query_type_101 5 +#define Z_Query_type_102 6 + } u; +}; + +struct Z_RPNQuery { + Z_AttributeSetId *attributeSetId; + Z_RPNStructure *RPNStructure; +}; + +struct Z_Complex { + Z_RPNStructure *s1; + Z_RPNStructure *s2; + Z_Operator *roperator; +}; + +struct Z_RPNStructure { + int which; + union { + Z_Operand *simple; + Z_Complex *complex; +#define Z_RPNStructure_simple 1 +#define Z_RPNStructure_complex 2 + } u; +}; + +struct Z_Operand { + int which; + union { + Z_AttributesPlusTerm *attributesPlusTerm; + Z_ResultSetId *resultSetId; + Z_ResultSetPlusAttributes *resultAttr; +#define Z_Operand_APT 1 +#define Z_Operand_resultSetId 2 +#define Z_Operand_resultAttr 3 + } u; +}; + +struct Z_AttributesPlusTerm { + Z_AttributeList *attributes; + Z_Term *term; +}; + +struct Z_ResultSetPlusAttributes { + Z_ResultSetId *resultSet; + Z_AttributeList *attributes; +}; + +struct Z_AttributeList { + int num_attributes; + Z_AttributeElement **attributes; +}; + +struct Z_Term { + int which; + union { + Odr_oct *general; + int *numeric; + Z_InternationalString *characterString; + Odr_oid *oid; + char *dateTime; + Z_External *external; + Z_IntUnit *integerAndUnit; + Odr_null *null; +#define Z_Term_general 1 +#define Z_Term_numeric 2 +#define Z_Term_characterString 3 +#define Z_Term_oid 4 +#define Z_Term_dateTime 5 +#define Z_Term_external 6 +#define Z_Term_integerAndUnit 7 +#define Z_Term_null 8 + } u; +}; + +struct Z_Operator { + int which; + union { + Odr_null *and; + Odr_null *or; + Odr_null *and_not; + Z_ProximityOperator *prox; +#define Z_Operator_and 1 +#define Z_Operator_or 2 +#define Z_Operator_and_not 3 +#define Z_Operator_prox 4 + } u; +}; + +struct Z_ComplexAttribute { + int num_list; + Z_StringOrNumeric **list; + int num_semanticAction; + int **semanticAction; /* OPT */ +}; + +struct Z_AttributeElement { + Z_AttributeSetId *attributeSet; /* OPT */ + int *attributeType; + int which; + union { + int *numeric; + Z_ComplexAttribute *complex; +#define Z_AttributeValue_numeric 1 +#define Z_AttributeValue_complex 2 + } value; +}; + +struct Z_ProximityOperator { + bool_t *exclusion; /* OPT */ + int *distance; + bool_t *ordered; +#define Z_ProximityOperator_Prox_lessThan 1 +#define Z_ProximityOperator_Prox_lessThanOrEqual 2 +#define Z_ProximityOperator_Prox_equal 3 +#define Z_ProximityOperator_Prox_greaterThanOrEqual 4 +#define Z_ProximityOperator_Prox_greaterThan 5 +#define Z_ProximityOperator_Prox_notEqual 6 + int *relationType; + int which; + union { + Z_ProxUnit *known; + int *zprivate; +#define Z_ProximityOperator_known 1 +#define Z_ProximityOperator_private 2 + } u; +}; + +#define Z_ProxUnit_character 1 +#define Z_ProxUnit_word 2 +#define Z_ProxUnit_sentence 3 +#define Z_ProxUnit_paragraph 4 +#define Z_ProxUnit_section 5 +#define Z_ProxUnit_chapter 6 +#define Z_ProxUnit_document 7 +#define Z_ProxUnit_element 8 +#define Z_ProxUnit_subelement 9 +#define Z_ProxUnit_elementType 10 +#define Z_ProxUnit_byte 11 + +struct Z_SearchResponse { + Z_ReferenceId *referenceId; /* OPT */ + int *resultCount; + int *numberOfRecordsReturned; + int *nextResultSetPosition; + bool_t *searchStatus; +#define Z_SearchResponse_subset 1 +#define Z_SearchResponse_interim 2 +#define Z_SearchResponse_none 3 + int *resultSetStatus; /* OPT */ + Z_PresentStatus *presentStatus; /* OPT */ + Z_Records *records; /* OPT */ + Z_OtherInformation *additionalSearchInfo; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_RecordComposition { + int which; + union { + Z_ElementSetNames *simple; + Z_CompSpec *complex; +#define Z_RecordComp_simple 1 +#define Z_RecordComp_complex 2 + } u; +}; + +struct Z_PresentRequest { + Z_ReferenceId *referenceId; /* OPT */ + Z_ResultSetId *resultSetId; + int *resultSetStartPoint; + int *numberOfRecordsRequested; + int num_ranges; + Z_Range **additionalRanges; /* OPT */ + Z_RecordComposition *recordComposition; /* OPT */ + Odr_oid *preferredRecordSyntax; /* OPT */ + int *maxSegmentCount; /* OPT */ + int *maxRecordSize; /* OPT */ + int *maxSegmentSize; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_Segment { + Z_ReferenceId *referenceId; /* OPT */ + int *numberOfRecordsReturned; + int num_segmentRecords; + Z_NamePlusRecord **segmentRecords; + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_PresentResponse { + Z_ReferenceId *referenceId; /* OPT */ + int *numberOfRecordsReturned; + int *nextResultSetPosition; + Z_PresentStatus *presentStatus; + Z_Records *records; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_NamePlusRecordList { + int num_records; + Z_NamePlusRecord **records; +}; + +struct Z_DiagRecs { + int num_diagRecs; + Z_DiagRec **diagRecs; +}; + +struct Z_Records { + int which; + union { + Z_NamePlusRecordList *databaseOrSurDiagnostics; + Z_DefaultDiagFormat *nonSurrogateDiagnostic; + Z_DiagRecs *multipleNonSurDiagnostics; +#define Z_Records_DBOSD 1 +#define Z_Records_NSD 2 +#define Z_Records_multipleNSD 3 + } u; +}; + +struct Z_NamePlusRecord { + Z_DatabaseName *databaseName; /* OPT */ + int which; + union { + Z_External *databaseRecord; + Z_DiagRec *surrogateDiagnostic; + Z_FragmentSyntax *startingFragment; + Z_FragmentSyntax *intermediateFragment; + Z_FragmentSyntax *finalFragment; +#define Z_NamePlusRecord_databaseRecord 1 +#define Z_NamePlusRecord_surrogateDiagnostic 2 +#define Z_NamePlusRecord_startingFragment 3 +#define Z_NamePlusRecord_intermediateFragment 4 +#define Z_NamePlusRecord_finalFragment 5 + } u; +}; + +struct Z_FragmentSyntax { + int which; + union { + Z_External *externallyTagged; + Odr_oct *notExternallyTagged; +#define Z_FragmentSyntax_externallyTagged 1 +#define Z_FragmentSyntax_notExternallyTagged 2 + } u; +}; + +struct Z_DiagRec { + int which; + union { + Z_DefaultDiagFormat *defaultFormat; + Z_External *externallyDefined; +#define Z_DiagRec_defaultFormat 1 +#define Z_DiagRec_externallyDefined 2 + } u; +}; + +struct Z_DefaultDiagFormat { + Odr_oid *diagnosticSetId; + int *condition; + int which; + union { + char *v2Addinfo; + Z_InternationalString *v3Addinfo; +#define Z_DefaultDiagFormat_v2Addinfo 1 +#define Z_DefaultDiagFormat_v3Addinfo 2 + } u; +}; + +struct Z_Range { + int *startingPosition; + int *numberOfRecords; +}; + +struct Z_DatabaseSpecificUnit { + Z_DatabaseName *dbName; + Z_ElementSetName *esn; +}; + +struct Z_DatabaseSpecific { + int num; + Z_DatabaseSpecificUnit **elements; +}; + +struct Z_ElementSetNames { + int which; + union { + Z_InternationalString *generic; + Z_DatabaseSpecific *databaseSpecific; +#define Z_ElementSetNames_generic 1 +#define Z_ElementSetNames_databaseSpecific 2 + } u; +}; + +#define Z_PresentStatus_success 0 +#define Z_PresentStatus_partial_1 1 +#define Z_PresentStatus_partial_2 2 +#define Z_PresentStatus_partial_3 3 +#define Z_PresentStatus_partial_4 4 +#define Z_PresentStatus_failure 5 + +struct Z_DbSpecific { + Z_DatabaseName *db; + Z_Specification *spec; +}; + +struct Z_CompSpec { + bool_t *selectAlternativeSyntax; + Z_Specification *generic; /* OPT */ + int num_dbSpecific; + Z_DbSpecific **dbSpecific; /* OPT */ + int num_recordSyntax; + Odr_oid **recordSyntax; /* OPT */ +}; + +struct Z_ElementSpec { + int which; + union { + Z_InternationalString *elementSetName; + Z_External *externalSpec; +#define Z_ElementSpec_elementSetName 1 +#define Z_ElementSpec_externalSpec 2 + } u; +}; + +struct Z_Specification { + Odr_oid *schema; /* OPT */ + Z_ElementSpec *elementSpec; /* OPT */ +}; + +struct Z_DeleteResultSetRequest { + Z_ReferenceId *referenceId; /* OPT */ +#define Z_DeleteResultSetRequest_list 0 +#define Z_DeleteResultSetRequest_all 1 + int *deleteFunction; + int num_resultSetList; + Z_ResultSetId **resultSetList; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_DeleteResultSetResponse { + Z_ReferenceId *referenceId; /* OPT */ + Z_DeleteStatus *deleteOperationStatus; + Z_ListStatuses *deleteListStatuses; /* OPT */ + int *numberNotDeleted; /* OPT */ + Z_ListStatuses *bulkStatuses; /* OPT */ + Z_InternationalString *deleteMessage; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_ListStatus { + Z_ResultSetId *id; + Z_DeleteStatus *status; +}; + +struct Z_ListStatuses { + int num; + Z_ListStatus **elements; +}; + +#define Z_DeleteStatus_success 0 +#define Z_DeleteStatus_resultSetDidNotExist 1 +#define Z_DeleteStatus_previouslyDeletedByTarget 2 +#define Z_DeleteStatus_systemProblemAtTarget 3 +#define Z_DeleteStatus_accessNotAllowed 4 +#define Z_DeleteStatus_resourceControlAtOrigin 5 +#define Z_DeleteStatus_resourceControlAtTarget 6 +#define Z_DeleteStatus_bulkDeleteNotSupported 7 +#define Z_DeleteStatus_notAllRsltSetsDeletedOnBulkDlte 8 +#define Z_DeleteStatus_notAllRequestedResultSetsDeleted 9 +#define Z_DeleteStatus_resultSetInUse 10 + +struct Z_AccessControlRequest { + Z_ReferenceId *referenceId; /* OPT */ + int which; + union { + Odr_oct *simpleForm; + Z_External *externallyDefined; +#define Z_AccessControlRequest_simpleForm 1 +#define Z_AccessControlRequest_externallyDefined 2 + } u; + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_AccessControlResponse { + Z_ReferenceId *referenceId; /* OPT */ + int which; + union { + Odr_oct *simpleForm; + Z_External *externallyDefined; +#define Z_AccessControlResponse_simpleForm 1 +#define Z_AccessControlResponse_externallyDefined 2 + } u; /* OPT */ + Z_DiagRec *diagnostic; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_ResourceControlRequest { + Z_ReferenceId *referenceId; /* OPT */ + bool_t *suspendedFlag; /* OPT */ + Z_ResourceReport *resourceReport; /* OPT */ +#define Z_ResourceControlRequest_subset 1 +#define Z_ResourceControlRequest_interim 2 +#define Z_ResourceControlRequest_none 3 + int *partialResultsAvailable; /* OPT */ + bool_t *responseRequired; + bool_t *triggeredRequestFlag; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_ResourceControlResponse { + Z_ReferenceId *referenceId; /* OPT */ + bool_t *continueFlag; + bool_t *resultSetWanted; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_TriggerResourceControlRequest { + Z_ReferenceId *referenceId; /* OPT */ +#define Z_TriggerResourceControlRequest_resourceReport 1 +#define Z_TriggerResourceControlRequest_resourceControl 2 +#define Z_TriggerResourceControlRequest_cancel 3 + int *requestedAction; + Z_ResourceReportId *prefResourceReportFormat; /* OPT */ + bool_t *resultSetWanted; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_ResourceReportRequest { + Z_ReferenceId *referenceId; /* OPT */ + Z_ReferenceId *opId; /* OPT */ + Z_ResourceReportId *prefResourceReportFormat; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_ResourceReportResponse { + Z_ReferenceId *referenceId; /* OPT */ +#define Z_ResourceReportResponse_success 0 +#define Z_ResourceReportResponse_partial 1 +#define Z_ResourceReportResponse_failure_1 2 +#define Z_ResourceReportResponse_failure_2 3 +#define Z_ResourceReportResponse_failure_3 4 +#define Z_ResourceReportResponse_failure_4 5 +#define Z_ResourceReportResponse_failure_5 6 +#define Z_ResourceReportResponse_failure_6 7 + int *resourceReportStatus; + Z_ResourceReport *resourceReport; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + + + + + +struct Z_ScanRequest { + Z_ReferenceId *referenceId; /* OPT */ + int num_databaseNames; + Z_DatabaseName **databaseNames; + Z_AttributeSetId *attributeSet; /* OPT */ + Z_AttributesPlusTerm *termListAndStartPoint; + int *stepSize; /* OPT */ + int *numberOfTermsRequested; + int *preferredPositionInResponse; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_ScanResponse { + Z_ReferenceId *referenceId; /* OPT */ + int *stepSize; /* OPT */ +#define Z_Scan_success 0 +#define Z_Scan_partial_1 1 +#define Z_Scan_partial_2 2 +#define Z_Scan_partial_3 3 +#define Z_Scan_partial_4 4 +#define Z_Scan_partial_5 5 +#define Z_Scan_failure 6 + int *scanStatus; + int *numberOfEntriesReturned; + int *positionOfTerm; /* OPT */ + Z_ListEntries *entries; /* OPT */ + Z_AttributeSetId *attributeSet; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_ListEntries { + int num_entries; + Z_Entry **entries; /* OPT */ + int num_nonsurrogateDiagnostics; + Z_DiagRec **nonsurrogateDiagnostics; /* OPT */ +}; + +struct Z_Entry { + int which; + union { + Z_TermInfo *termInfo; + Z_DiagRec *surrogateDiagnostic; +#define Z_Entry_termInfo 1 +#define Z_Entry_surrogateDiagnostic 2 + } u; +}; + +struct Z_TermInfo { + Z_Term *term; + Z_InternationalString *displayTerm; /* OPT */ + Z_AttributeList *suggestedAttributes; /* OPT */ + int num_alternativeTerm; + Z_AttributesPlusTerm **alternativeTerm; /* OPT */ + int *globalOccurrences; /* OPT */ + Z_OccurrenceByAttributes *byAttributes; /* OPT */ + Z_OtherInformation *otherTermInfo; /* OPT */ +}; + +struct Z_byDatabaseList_s { + Z_DatabaseName *db; + int *num; /* OPT */ + Z_OtherInformation *otherDbInfo; /* OPT */ +}; + +struct Z_byDatabaseList { + int num; + Z_byDatabaseList_s **elements; +}; + +struct Z_OccurrenceByAttributesElem { + Z_AttributeList *attributes; + int which; + union { + int *global; + Z_byDatabaseList *byDatabase; +#define Z_OccurrenceByAttributesElem_global 1 +#define Z_OccurrenceByAttributesElem_byDatabase 2 + } u; /* OPT */ + Z_OtherInformation *otherOccurInfo; /* OPT */ +}; + +struct Z_OccurrenceByAttributes { + int num; + Z_OccurrenceByAttributesElem **elements; +}; + +struct Z_SortKeySpecList { + int num_specs; + Z_SortKeySpec **specs; +}; + +struct Z_SortRequest { + Z_ReferenceId *referenceId; /* OPT */ + int num_inputResultSetNames; + Z_InternationalString **inputResultSetNames; + Z_InternationalString *sortedResultSetName; + Z_SortKeySpecList *sortSequence; + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_SortResponse { + Z_ReferenceId *referenceId; /* OPT */ +#define Z_SortResponse_success 0 +#define Z_SortResponse_partial_1 1 +#define Z_SortResponse_failure 2 + int *sortStatus; +#define Z_SortResponse_empty 1 +#define Z_SortResponse_interim 2 +#define Z_SortResponse_unchanged 3 +#define Z_SortResponse_none 4 + int *resultSetStatus; /* OPT */ + int num_diagnostics; + Z_DiagRec **diagnostics; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_SortKeySpec { + Z_SortElement *sortElement; +#define Z_SortKeySpec_ascending 0 +#define Z_SortKeySpec_descending 1 +#define Z_SortKeySpec_ascendingByFrequency 3 +#define Z_SortKeySpec_descendingByfrequency 4 + int *sortRelation; +#define Z_SortKeySpec_caseSensitive 0 +#define Z_SortKeySpec_caseInsensitive 1 + int *caseSensitivity; + int which; + union { + Odr_null *abort; + Odr_null *null; + Odr_oct *missingValueData; +#define Z_SortKeySpec_abort 1 +#define Z_SortKeySpec_null 2 +#define Z_SortKeySpec_missingValueData 3 + } u; /* OPT */ +}; + +struct Z_SortDbSpecificList_s { + Z_DatabaseName *databaseName; + Z_SortKey *dbSort; +}; + +struct Z_SortDbSpecificList { + int num; + Z_SortDbSpecificList_s **elements; +}; + +struct Z_SortElement { + int which; + union { + Z_SortKey *generic; + Z_SortDbSpecificList *databaseSpecific; +#define Z_SortElement_generic 1 +#define Z_SortElement_databaseSpecific 2 + } u; +}; + +struct Z_SortAttributes { + Z_AttributeSetId *id; + Z_AttributeList *list; +}; + +struct Z_SortKey { + int which; + union { + Z_InternationalString *sortField; + Z_Specification *elementSpec; + Z_SortAttributes *sortAttributes; +#define Z_SortKey_sortField 1 +#define Z_SortKey_elementSpec 2 +#define Z_SortKey_sortAttributes 3 + } u; +}; + +struct Z_ExtendedServicesRequest { + Z_ReferenceId *referenceId; /* OPT */ +#define Z_ExtendedServicesRequest_create 1 +#define Z_ExtendedServicesRequest_delete 2 +#define Z_ExtendedServicesRequest_modify 3 + int *function; + Odr_oid *packageType; + Z_InternationalString *packageName; /* OPT */ + Z_InternationalString *userId; /* OPT */ + Z_IntUnit *retentionTime; /* OPT */ + Z_Permissions *permissions; /* OPT */ + Z_InternationalString *description; /* OPT */ + Z_External *taskSpecificParameters; /* OPT */ +#define Z_ExtendedServicesRequest_wait 1 +#define Z_ExtendedServicesRequest_waitIfPossible 2 +#define Z_ExtendedServicesRequest_dontWait 3 +#define Z_ExtendedServicesRequest_dontReturnPackage 4 + int *waitAction; + Z_ElementSetName *elements; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_ExtendedServicesResponse { + Z_ReferenceId *referenceId; /* OPT */ +#define Z_ExtendedServicesResponse_done 1 +#define Z_ExtendedServicesResponse_accepted 2 +#define Z_ExtendedServicesResponse_failure 3 + int *operationStatus; + int num_diagnostics; + Z_DiagRec **diagnostics; /* OPT */ + Z_External *taskPackage; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_Permissions_s { + Z_InternationalString *userId; +#define Z_Permissions_s_delete 1 +#define Z_Permissions_s_modifyContents 2 +#define Z_Permissions_s_modifyPermissions 3 +#define Z_Permissions_s_present 4 +#define Z_Permissions_s_invoke 5 + int num_allowableFunctions; + int **allowableFunctions; +}; + +struct Z_Permissions { + int num; + Z_Permissions_s **elements; +}; + +struct Z_Close { + Z_ReferenceId *referenceId; /* OPT */ + Z_CloseReason *closeReason; + Z_InternationalString *diagnosticInformation; /* OPT */ + Z_ResourceReportId *resourceReportFormat; /* OPT */ + Z_ResourceReport *resourceReport; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +#define Z_Close_finished 0 +#define Z_Close_shutdown 1 +#define Z_Close_systemProblem 2 +#define Z_Close_costLimit 3 +#define Z_Close_resources 4 +#define Z_Close_securityViolation 5 +#define Z_Close_protocolError 6 +#define Z_Close_lackOfActivity 7 +#define Z_Close_peerAbort 8 +#define Z_Close_unspecified 9 + + + + + + + + + + + +struct Z_OtherInformationUnit { + Z_InfoCategory *category; /* OPT */ + int which; + union { + Z_InternationalString *characterInfo; + Odr_oct *binaryInfo; + Z_External *externallyDefinedInfo; + Odr_oid *oid; +#define Z_OtherInfo_characterInfo 1 +#define Z_OtherInfo_binaryInfo 2 +#define Z_OtherInfo_externallyDefinedInfo 3 +#define Z_OtherInfo_oid 4 + } information; +}; + +struct Z_OtherInformation { + int num_elements; + Z_OtherInformationUnit **list; +}; + +struct Z_InfoCategory { + Odr_oid *categoryTypeId; /* OPT */ + int *categoryValue; +}; + +struct Z_IntUnit { + int *value; + Z_Unit *unitUsed; +}; + +struct Z_Unit { + Z_InternationalString *unitSystem; /* OPT */ + Z_StringOrNumeric *unitType; /* OPT */ + Z_StringOrNumeric *unit; /* OPT */ + int *scaleFactor; /* OPT */ +}; + + + +struct Z_StringOrNumeric { + int which; + union { + Z_InternationalString *string; + int *numeric; +#define Z_StringOrNumeric_string 1 +#define Z_StringOrNumeric_numeric 2 + } u; +}; + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +int z_ANY_type_0 (ODR o, void **p, int opt); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/yaz/z-date.h b/include/yaz/z-date.h new file mode 100644 index 0000000..efa27a0 --- /dev/null +++ b/include/yaz/z-date.h @@ -0,0 +1,134 @@ +/* YC 0.2: Tue Feb 29 16:45:14 CET 2000 */ +/* Module-H UserInfoFormat-dateTime */ + +#ifndef z_date_H +#define z_date_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_DateTime Z_DateTime; +YAZ_EXPORT int z_DateTime (ODR o, Z_DateTime **p, int opt, const char *name); + +typedef struct Z_DateMonthAndDay Z_DateMonthAndDay; +YAZ_EXPORT int z_DateMonthAndDay (ODR o, Z_DateMonthAndDay **p, int opt, const char *name); + +typedef struct Z_DateQuarter Z_DateQuarter; +YAZ_EXPORT int z_DateQuarter (ODR o, Z_DateQuarter **p, int opt, const char *name); + +typedef struct Z_DateSeason Z_DateSeason; +YAZ_EXPORT int z_DateSeason (ODR o, Z_DateSeason **p, int opt, const char *name); + +typedef struct Z_Era Z_Era; +YAZ_EXPORT int z_Era (ODR o, Z_Era **p, int opt, const char *name); + +typedef struct Z_DateFlags Z_DateFlags; +YAZ_EXPORT int z_DateFlags (ODR o, Z_DateFlags **p, int opt, const char *name); + +typedef struct Z_Date Z_Date; +YAZ_EXPORT int z_Date (ODR o, Z_Date **p, int opt, const char *name); + +typedef struct Z_Time Z_Time; +YAZ_EXPORT int z_Time (ODR o, Z_Time **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_DateTime { + Z_Date *date; /* OPT */ + Z_Time *time; /* OPT */ +}; + +struct Z_DateMonthAndDay { + int *month; + int *day; /* OPT */ +}; + +struct Z_DateQuarter { + int which; + union { + Odr_null *first; + Odr_null *second; + Odr_null *third; + Odr_null *fourth; +#define Z_DateQuarter_first 1 +#define Z_DateQuarter_second 2 +#define Z_DateQuarter_third 3 +#define Z_DateQuarter_fourth 4 + } u; +}; + +struct Z_DateSeason { + int which; + union { + Odr_null *winter; + Odr_null *spring; + Odr_null *summer; + Odr_null *autumn; +#define Z_DateSeason_winter 1 +#define Z_DateSeason_spring 2 +#define Z_DateSeason_summer 3 +#define Z_DateSeason_autumn 4 + } u; +}; + +struct Z_Era { + int which; + union { + Odr_null *decade; + Odr_null *century; + Odr_null *millennium; +#define Z_Era_decade 1 +#define Z_Era_century 2 +#define Z_Era_millennium 3 + } u; +}; + +struct Z_DateFlags { + Odr_null *circa; /* OPT */ + Z_Era *era; /* OPT */ +}; + +struct Z_Date { + int *year; + int which; + union { + Z_DateMonthAndDay *monthAndDay; + int *julianDay; + int *weekNumber; + Z_DateQuarter *quarter; + Z_DateSeason *season; +#define Z_Date_monthAndDay 1 +#define Z_Date_julianDay 2 +#define Z_Date_weekNumber 3 +#define Z_Date_quarter 4 +#define Z_Date_season 5 + } u; /* OPT */ + Z_DateFlags *flags; /* OPT */ +}; + +struct Z_Time { + int *hour; + int *minute; /* OPT */ + int *second; /* OPT */ + Z_IntUnit *partOfSecond; /* OPT */ + int which; + union { + Odr_null *local; + Odr_null *utc; + int *utcOffset; +#define Z_Time_local 1 +#define Z_Time_utc 2 +#define Z_Time_utcOffset 3 + } u; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-diag1.h b/include/yaz/z-diag1.h new file mode 100644 index 0000000..7051fcd --- /dev/null +++ b/include/yaz/z-diag1.h @@ -0,0 +1,354 @@ +/* YC 0.2: Tue Feb 29 16:45:06 CET 2000 */ +/* Module-H DiagnosticFormatDiag1 */ + +#ifndef z_diag1_H +#define z_diag1_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_DiagnosticFormat_s Z_DiagnosticFormat_s; +YAZ_EXPORT int z_DiagnosticFormat_s (ODR o, Z_DiagnosticFormat_s **p, int opt, const char *name); + +typedef struct Z_DiagnosticFormat Z_DiagnosticFormat; +YAZ_EXPORT int z_DiagnosticFormat (ODR o, Z_DiagnosticFormat **p, int opt, const char *name); + +typedef struct Z_TooMany Z_TooMany; +YAZ_EXPORT int z_TooMany (ODR o, Z_TooMany **p, int opt, const char *name); + +typedef struct Z_BadSpec Z_BadSpec; +YAZ_EXPORT int z_BadSpec (ODR o, Z_BadSpec **p, int opt, const char *name); + +typedef struct Z_DbUnavail_0 Z_DbUnavail_0; +YAZ_EXPORT int z_DbUnavail_0 (ODR o, Z_DbUnavail_0 **p, int opt, const char *name); + +typedef struct Z_DbUnavail Z_DbUnavail; +YAZ_EXPORT int z_DbUnavail (ODR o, Z_DbUnavail **p, int opt, const char *name); + +typedef struct Z_Attribute Z_Attribute; +YAZ_EXPORT int z_Attribute (ODR o, Z_Attribute **p, int opt, const char *name); + +typedef struct Z_AttCombo Z_AttCombo; +YAZ_EXPORT int z_AttCombo (ODR o, Z_AttCombo **p, int opt, const char *name); + +typedef struct Z_DiagTerm Z_DiagTerm; +YAZ_EXPORT int z_DiagTerm (ODR o, Z_DiagTerm **p, int opt, const char *name); + +typedef struct Z_Proximity Z_Proximity; +YAZ_EXPORT int z_Proximity (ODR o, Z_Proximity **p, int opt, const char *name); + +typedef struct Z_AttrListList Z_AttrListList; +YAZ_EXPORT int z_AttrListList (ODR o, Z_AttrListList **p, int opt, const char *name); + +typedef struct Z_Scan Z_Scan; +YAZ_EXPORT int z_Scan (ODR o, Z_Scan **p, int opt, const char *name); + +typedef struct Z_StringList Z_StringList; +YAZ_EXPORT int z_StringList (ODR o, Z_StringList **p, int opt, const char *name); + +typedef struct Z_Sort Z_Sort; +YAZ_EXPORT int z_Sort (ODR o, Z_Sort **p, int opt, const char *name); + +typedef struct Z_Segmentation Z_Segmentation; +YAZ_EXPORT int z_Segmentation (ODR o, Z_Segmentation **p, int opt, const char *name); + +typedef struct Z_ExtServices Z_ExtServices; +YAZ_EXPORT int z_ExtServices (ODR o, Z_ExtServices **p, int opt, const char *name); + +typedef struct Z_OidList Z_OidList; +YAZ_EXPORT int z_OidList (ODR o, Z_OidList **p, int opt, const char *name); + +typedef struct Z_AltOidList Z_AltOidList; +YAZ_EXPORT int z_AltOidList (ODR o, Z_AltOidList **p, int opt, const char *name); + +typedef struct Z_AccessCtrl Z_AccessCtrl; +YAZ_EXPORT int z_AccessCtrl (ODR o, Z_AccessCtrl **p, int opt, const char *name); + +typedef struct Z_RecordSyntax Z_RecordSyntax; +YAZ_EXPORT int z_RecordSyntax (ODR o, Z_RecordSyntax **p, int opt, const char *name); + +typedef struct Z_DiagFormat Z_DiagFormat; +YAZ_EXPORT int z_DiagFormat (ODR o, Z_DiagFormat **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_DiagnosticFormat_s { + int which; + union { + Z_DefaultDiagFormat *defaultDiagRec; + Z_DiagFormat *explicitDiagnostic; +#define Z_DiagnosticFormat_s_defaultDiagRec 1 +#define Z_DiagnosticFormat_s_explicitDiagnostic 2 + } u; /* OPT */ + Z_InternationalString *message; /* OPT */ +}; + +struct Z_DiagnosticFormat { + int num; + Z_DiagnosticFormat_s **elements; +}; + +struct Z_TooMany { +#define Z_TooMany_argumentWords 1 +#define Z_TooMany_truncatedWords 2 +#define Z_TooMany_booleanOperators 3 +#define Z_TooMany_incompleteSubfields 4 +#define Z_TooMany_characters 5 +#define Z_TooMany_recordsRetrieved 6 +#define Z_TooMany_dataBasesSpecified 7 +#define Z_TooMany_resultSetsCreated 8 +#define Z_TooMany_indexTermsProcessed 9 + int *tooManyWhat; + int *max; /* OPT */ +}; + +struct Z_BadSpec { + Z_Specification *spec; + Z_DatabaseName *db; /* OPT */ + int num_goodOnes; + Z_Specification **goodOnes; /* OPT */ +}; + +struct Z_DbUnavail_0 { +#define Z_DbUnavail_0_doesNotExist 0 +#define Z_DbUnavail_0_existsButUnavail 1 +#define Z_DbUnavail_0_locked 2 +#define Z_DbUnavail_0_accessDenied 3 + int *reasonCode; /* OPT */ + Z_InternationalString *message; /* OPT */ +}; + +struct Z_DbUnavail { + Z_DatabaseName *db; + Z_DbUnavail_0 *why; +}; + +struct Z_Attribute { + Odr_oid *id; + int *type; /* OPT */ + int *value; /* OPT */ + Z_Term *term; /* OPT */ +}; + +struct Z_AttCombo { + Z_AttributeList *unsupportedCombination; + int num_recommendedAlternatives; + Z_AttributeList **recommendedAlternatives; /* OPT */ +}; + +struct Z_DiagTerm { +#define Z_DiagTerm_codedValue 1 +#define Z_DiagTerm_unparsable 2 +#define Z_DiagTerm_tooShort 3 +#define Z_DiagTerm_type 4 + int *problem; /* OPT */ + Z_Term *term; +}; + +struct Z_Proximity { + int which; + union { + Odr_null *resultSets; + Z_InternationalString *badSet; + int *relation; + int *unit; + int *distance; + Z_AttributeList *attributes; + Odr_null *ordered; + Odr_null *exclusion; +#define Z_Proximity_resultSets 1 +#define Z_Proximity_badSet 2 +#define Z_Proximity_relation 3 +#define Z_Proximity_unit 4 +#define Z_Proximity_distance 5 +#define Z_Proximity_attributes 6 +#define Z_Proximity_ordered 7 +#define Z_Proximity_exclusion 8 + } u; +}; + +struct Z_AttrListList { + int num; + Z_AttributeList **elements; +}; + +struct Z_Scan { + int which; + union { + Odr_null *nonZeroStepSize; + Odr_null *specifiedStepSize; + Odr_null *termList1; + Z_AttrListList *termList2; +#define Z_Scan_mustBeOne 1 +#define Z_Scan_mustBePositive 2 +#define Z_Scan_mustBeNonNegative 3 +#define Z_Scan_other 4 + int *posInResponse; + Odr_null *resources; + Odr_null *endOfList; +#define Z_Scan_nonZeroStepSize 1 +#define Z_Scan_specifiedStepSize 2 +#define Z_Scan_termList1 3 +#define Z_Scan_termList2 4 +#define Z_Scan_posInResponse 5 +#define Z_Scan_resources 6 +#define Z_Scan_endOfList 7 + } u; +}; + +struct Z_StringList { + int num; + Z_InternationalString **elements; +}; + +struct Z_Sort { + int which; + union { + Odr_null *sequence; + Odr_null *noRsName; + int *tooMany; + Odr_null *incompatible; + Odr_null *generic; + Odr_null *dbSpecific; + Z_SortElement *sortElement; +#define Z_Sort_tooMany 1 +#define Z_Sort_duplicate 2 + int *key; + Odr_null *action; +#define Z_Sort_relation 1 +#define Z_Sort_case 2 +#define Z_Sort_action 3 +#define Z_Sort_sort 4 + int *illegal; + Z_StringList *inputTooLarge; + Odr_null *aggregateTooLarge; +#define Z_SortD_sequence 1 +#define Z_SortD_noRsName 2 +#define Z_SortD_tooMany 3 +#define Z_SortD_incompatible 4 +#define Z_SortD_generic 5 +#define Z_SortD_dbSpecific 6 +#define Z_SortD_sortElement 7 +#define Z_SortD_key 8 +#define Z_SortD_action 9 +#define Z_SortD_illegal 10 +#define Z_SortD_inputTooLarge 11 +#define Z_SortD_aggregateTooLarge 12 + } u; +}; + +struct Z_Segmentation { + int which; + union { + Odr_null *segmentCount; + int *segmentSize; +#define Z_Segmentation_segmentCount 1 +#define Z_Segmentation_segmentSize 2 + } u; +}; + +struct Z_ExtServices { + int which; + union { +#define Z_ExtServices_nameInUse 1 +#define Z_ExtServices_noSuchName 2 +#define Z_ExtServices_quota 3 +#define Z_ExtServices_type 4 + int *req; +#define Z_ExtServices_id 1 +#define Z_ExtServices_modifyDelete 2 + int *permission; +#define Z_ExtServices_failed 1 +#define Z_ExtServices_service 2 +#define Z_ExtServices_parameters 3 + int *immediate; +#define Z_ExtServices_req 1 +#define Z_ExtServices_permission 2 +#define Z_ExtServices_immediate 3 + } u; +}; + +struct Z_OidList { + int num; + Odr_oid **elements; +}; + +struct Z_AltOidList { + int num; + Odr_oid **elements; +}; + +struct Z_AccessCtrl { + int which; + union { + Odr_null *noUser; + Odr_null *refused; + Odr_null *simple; + Z_OidList *oid; + Z_AltOidList *alternative; + Odr_null *pwdInv; + Odr_null *pwdExp; +#define Z_AccessCtrl_noUser 1 +#define Z_AccessCtrl_refused 2 +#define Z_AccessCtrl_simple 3 +#define Z_AccessCtrl_oid 4 +#define Z_AccessCtrl_alternative 5 +#define Z_AccessCtrl_pwdInv 6 +#define Z_AccessCtrl_pwdExp 7 + } u; +}; + +struct Z_RecordSyntax { + Odr_oid *unsupportedSyntax; + int num_suggestedAlternatives; + Odr_oid **suggestedAlternatives; /* OPT */ +}; + +struct Z_DiagFormat { + int which; + union { + Z_TooMany *tooMany; + Z_BadSpec *badSpec; + Z_DbUnavail *dbUnavail; +#define Z_DiagFormat_and 0 +#define Z_DiagFormat_or 1 +#define Z_DiagFormat_and_not 2 +#define Z_DiagFormat_prox 3 + int *unSupOp; + Z_Attribute *attribute; + Z_AttCombo *attCombo; + Z_DiagTerm *term; + Z_Proximity *proximity; + Z_Scan *scan; + Z_Sort *sort; + Z_Segmentation *segmentation; + Z_ExtServices *extServices; + Z_AccessCtrl *accessCtrl; + Z_RecordSyntax *recordSyntax; +#define Z_DiagFormat_tooMany 1 +#define Z_DiagFormat_badSpec 2 +#define Z_DiagFormat_dbUnavail 3 +#define Z_DiagFormat_unSupOp 4 +#define Z_DiagFormat_attribute 5 +#define Z_DiagFormat_attCombo 6 +#define Z_DiagFormat_term 7 +#define Z_DiagFormat_proximity 8 +#define Z_DiagFormat_scan 9 +#define Z_DiagFormat_sort 10 +#define Z_DiagFormat_segmentation 11 +#define Z_DiagFormat_extServices 12 +#define Z_DiagFormat_accessCtrl 13 +#define Z_DiagFormat_recordSyntax 14 + } u; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-espec1.h b/include/yaz/z-espec1.h new file mode 100644 index 0000000..a470b00 --- /dev/null +++ b/include/yaz/z-espec1.h @@ -0,0 +1,142 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ElementSpecificationFormat-eSpec-1 */ + +#ifndef z_espec1_H +#define z_espec1_H + +#include +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_Espec1 Z_Espec1; +YAZ_EXPORT int z_Espec1 (ODR o, Z_Espec1 **p, int opt, const char *name); + +typedef struct Z_ElementRequestCompositeElementPrimitives Z_ElementRequestCompositeElementPrimitives; +YAZ_EXPORT int z_ElementRequestCompositeElementPrimitives (ODR o, Z_ElementRequestCompositeElementPrimitives **p, int opt, const char *name); + +typedef struct Z_ElementRequestCompositeElementSpecs Z_ElementRequestCompositeElementSpecs; +YAZ_EXPORT int z_ElementRequestCompositeElementSpecs (ODR o, Z_ElementRequestCompositeElementSpecs **p, int opt, const char *name); + +typedef struct Z_ElementRequestCompositeElement Z_ElementRequestCompositeElement; +YAZ_EXPORT int z_ElementRequestCompositeElement (ODR o, Z_ElementRequestCompositeElement **p, int opt, const char *name); + +typedef struct Z_ElementRequest Z_ElementRequest; +YAZ_EXPORT int z_ElementRequest (ODR o, Z_ElementRequest **p, int opt, const char *name); + +typedef struct Z_SimpleElement Z_SimpleElement; +YAZ_EXPORT int z_SimpleElement (ODR o, Z_SimpleElement **p, int opt, const char *name); + +typedef struct Z_SpecificTag Z_SpecificTag; +YAZ_EXPORT int z_SpecificTag (ODR o, Z_SpecificTag **p, int opt, const char *name); + +typedef struct Z_ETagUnit Z_ETagUnit; +YAZ_EXPORT int z_ETagUnit (ODR o, Z_ETagUnit **p, int opt, const char *name); + +typedef struct Z_ETagPath Z_ETagPath; +YAZ_EXPORT int z_ETagPath (ODR o, Z_ETagPath **p, int opt, const char *name); + +typedef struct Z_OccurValues Z_OccurValues; +YAZ_EXPORT int z_OccurValues (ODR o, Z_OccurValues **p, int opt, const char *name); + +typedef struct Z_Occurrences Z_Occurrences; +YAZ_EXPORT int z_Occurrences (ODR o, Z_Occurrences **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_Espec1 { + int num_elementSetNames; + Z_InternationalString **elementSetNames; /* OPT */ + Odr_oid *defaultVariantSetId; /* OPT */ + Z_Variant *defaultVariantRequest; /* OPT */ + int *defaultTagType; /* OPT */ + int num_elements; + Z_ElementRequest **elements; /* OPT */ +}; + +struct Z_ElementRequestCompositeElementPrimitives { + int num; + Z_InternationalString **elements; +}; + +struct Z_ElementRequestCompositeElementSpecs { + int num; + Z_SimpleElement **elements; +}; + +struct Z_ElementRequestCompositeElement { + int which; + union { + Z_ElementRequestCompositeElementPrimitives *primitives; + Z_ElementRequestCompositeElementSpecs *specs; +#define Z_ElementRequestCompositeElement_primitives 1 +#define Z_ElementRequestCompositeElement_specs 2 + } u; + Z_ETagPath *deliveryTag; + Z_Variant *variantRequest; /* OPT */ +}; + +struct Z_ElementRequest { + int which; + union { + Z_SimpleElement *simpleElement; + Z_ElementRequestCompositeElement *compositeElement; +#define Z_ERequest_simpleElement 1 +#define Z_ERequest_compositeElement 2 + } u; +}; + +struct Z_SimpleElement { + Z_ETagPath *path; + Z_Variant *variantRequest; /* OPT */ +}; + +struct Z_SpecificTag { + int *tagType; /* OPT */ + Z_StringOrNumeric *tagValue; + Z_Occurrences *occurrences; /* OPT */ +}; + +struct Z_ETagUnit { + int which; + union { + Z_SpecificTag *specificTag; + Z_Occurrences *wildThing; + Odr_null *wildPath; +#define Z_ETagUnit_specificTag 1 +#define Z_ETagUnit_wildThing 2 +#define Z_ETagUnit_wildPath 3 + } u; +}; + +struct Z_ETagPath { + int num_tags; + Z_ETagUnit **tags; +}; + +struct Z_OccurValues { + int *start; + int *howMany; /* OPT */ +}; + +struct Z_Occurrences { + int which; + union { + Odr_null *all; + Odr_null *last; + Z_OccurValues *values; +#define Z_Occurrences_all 1 +#define Z_Occurrences_last 2 +#define Z_Occurrences_values 3 + } u; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-estask.h b/include/yaz/z-estask.h new file mode 100644 index 0000000..d1937ef --- /dev/null +++ b/include/yaz/z-estask.h @@ -0,0 +1,43 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H RecordSyntax-ESTaskPackage */ + +#ifndef z_estask_H +#define z_estask_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_TaskPackage Z_TaskPackage; +YAZ_EXPORT int z_TaskPackage (ODR o, Z_TaskPackage **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_TaskPackage { + Odr_oid *packageType; + Z_InternationalString *packageName; /* OPT */ + Z_InternationalString *userId; /* OPT */ + Z_IntUnit *retentionTime; /* OPT */ + Z_Permissions *permissions; /* OPT */ + Z_InternationalString *description; /* OPT */ + Odr_oct *targetReference; /* OPT */ + char *creationDateTime; /* OPT */ +#define Z_TaskPackage_pending 0 +#define Z_TaskPackage_active 1 +#define Z_TaskPackage_complete 2 +#define Z_TaskPackage_aborted 3 + int *taskStatus; + int num_packageDiagnostics; + Z_DiagRec **packageDiagnostics; /* OPT */ + Z_External *taskSpecificParameters; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-exp.h b/include/yaz/z-exp.h new file mode 100644 index 0000000..11dcb0a --- /dev/null +++ b/include/yaz/z-exp.h @@ -0,0 +1,1012 @@ +/* YC 0.2: Tue Feb 29 16:45:06 CET 2000 */ +/* Module-H RecordSyntax-explain */ + +#ifndef z_exp_H +#define z_exp_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_ExplainRecord Z_ExplainRecord; +YAZ_EXPORT int z_ExplainRecord (ODR o, Z_ExplainRecord **p, int opt, const char *name); + +typedef struct Z_TargetInfo Z_TargetInfo; +YAZ_EXPORT int z_TargetInfo (ODR o, Z_TargetInfo **p, int opt, const char *name); + +typedef struct Z_DatabaseInfo Z_DatabaseInfo; +YAZ_EXPORT int z_DatabaseInfo (ODR o, Z_DatabaseInfo **p, int opt, const char *name); + +typedef struct Z_TagTypeMapping Z_TagTypeMapping; +YAZ_EXPORT int z_TagTypeMapping (ODR o, Z_TagTypeMapping **p, int opt, const char *name); + +typedef struct Z_SchemaInfo Z_SchemaInfo; +YAZ_EXPORT int z_SchemaInfo (ODR o, Z_SchemaInfo **p, int opt, const char *name); + +typedef struct Z_ElementInfo Z_ElementInfo; +YAZ_EXPORT int z_ElementInfo (ODR o, Z_ElementInfo **p, int opt, const char *name); + +typedef struct Z_PathUnit Z_PathUnit; +YAZ_EXPORT int z_PathUnit (ODR o, Z_PathUnit **p, int opt, const char *name); + +typedef struct Z_Path Z_Path; +YAZ_EXPORT int z_Path (ODR o, Z_Path **p, int opt, const char *name); + +typedef struct Z_ElementInfoList Z_ElementInfoList; +YAZ_EXPORT int z_ElementInfoList (ODR o, Z_ElementInfoList **p, int opt, const char *name); + +typedef struct Z_ElementDataType Z_ElementDataType; +YAZ_EXPORT int z_ElementDataType (ODR o, Z_ElementDataType **p, int opt, const char *name); + +typedef int Z_PrimitiveDataType; +YAZ_EXPORT int z_PrimitiveDataType (ODR o, Z_PrimitiveDataType **p, int opt, const char *name); + +typedef struct Z_TagSetElements Z_TagSetElements; +YAZ_EXPORT int z_TagSetElements (ODR o, Z_TagSetElements **p, int opt, const char *name); + +typedef struct Z_TagSetInfo Z_TagSetInfo; +YAZ_EXPORT int z_TagSetInfo (ODR o, Z_TagSetInfo **p, int opt, const char *name); + +typedef struct Z_RecordSyntaxInfo Z_RecordSyntaxInfo; +YAZ_EXPORT int z_RecordSyntaxInfo (ODR o, Z_RecordSyntaxInfo **p, int opt, const char *name); + +typedef struct Z_AttributeSetInfo Z_AttributeSetInfo; +YAZ_EXPORT int z_AttributeSetInfo (ODR o, Z_AttributeSetInfo **p, int opt, const char *name); + +typedef struct Z_AttributeType Z_AttributeType; +YAZ_EXPORT int z_AttributeType (ODR o, Z_AttributeType **p, int opt, const char *name); + +typedef struct Z_AttributeDescription Z_AttributeDescription; +YAZ_EXPORT int z_AttributeDescription (ODR o, Z_AttributeDescription **p, int opt, const char *name); + +typedef struct Z_TermListElement Z_TermListElement; +YAZ_EXPORT int z_TermListElement (ODR o, Z_TermListElement **p, int opt, const char *name); + +typedef struct Z_TermListInfo Z_TermListInfo; +YAZ_EXPORT int z_TermListInfo (ODR o, Z_TermListInfo **p, int opt, const char *name); + +typedef struct Z_ExtendedServicesInfo Z_ExtendedServicesInfo; +YAZ_EXPORT int z_ExtendedServicesInfo (ODR o, Z_ExtendedServicesInfo **p, int opt, const char *name); + +typedef struct Z_AttributeDetails Z_AttributeDetails; +YAZ_EXPORT int z_AttributeDetails (ODR o, Z_AttributeDetails **p, int opt, const char *name); + +typedef struct Z_AttributeSetDetails Z_AttributeSetDetails; +YAZ_EXPORT int z_AttributeSetDetails (ODR o, Z_AttributeSetDetails **p, int opt, const char *name); + +typedef struct Z_AttributeTypeDetails Z_AttributeTypeDetails; +YAZ_EXPORT int z_AttributeTypeDetails (ODR o, Z_AttributeTypeDetails **p, int opt, const char *name); + +typedef struct Z_OmittedAttributeInterpretation Z_OmittedAttributeInterpretation; +YAZ_EXPORT int z_OmittedAttributeInterpretation (ODR o, Z_OmittedAttributeInterpretation **p, int opt, const char *name); + +typedef struct Z_AttributeValue Z_AttributeValue; +YAZ_EXPORT int z_AttributeValue (ODR o, Z_AttributeValue **p, int opt, const char *name); + +typedef struct Z_EScanInfo Z_EScanInfo; +YAZ_EXPORT int z_EScanInfo (ODR o, Z_EScanInfo **p, int opt, const char *name); + +typedef struct Z_TermListDetails Z_TermListDetails; +YAZ_EXPORT int z_TermListDetails (ODR o, Z_TermListDetails **p, int opt, const char *name); + +typedef struct Z_ElementSetDetails Z_ElementSetDetails; +YAZ_EXPORT int z_ElementSetDetails (ODR o, Z_ElementSetDetails **p, int opt, const char *name); + +typedef struct Z_RetrievalRecordDetails Z_RetrievalRecordDetails; +YAZ_EXPORT int z_RetrievalRecordDetails (ODR o, Z_RetrievalRecordDetails **p, int opt, const char *name); + +typedef struct Z_PerElementDetails Z_PerElementDetails; +YAZ_EXPORT int z_PerElementDetails (ODR o, Z_PerElementDetails **p, int opt, const char *name); + +typedef struct Z_RecordTag Z_RecordTag; +YAZ_EXPORT int z_RecordTag (ODR o, Z_RecordTag **p, int opt, const char *name); + +typedef struct Z_SortDetails Z_SortDetails; +YAZ_EXPORT int z_SortDetails (ODR o, Z_SortDetails **p, int opt, const char *name); + +typedef struct Z_SortKeyDetails Z_SortKeyDetails; +YAZ_EXPORT int z_SortKeyDetails (ODR o, Z_SortKeyDetails **p, int opt, const char *name); + +typedef struct Z_ProcessingInformation Z_ProcessingInformation; +YAZ_EXPORT int z_ProcessingInformation (ODR o, Z_ProcessingInformation **p, int opt, const char *name); + +typedef struct Z_VariantSetInfo Z_VariantSetInfo; +YAZ_EXPORT int z_VariantSetInfo (ODR o, Z_VariantSetInfo **p, int opt, const char *name); + +typedef struct Z_VariantClass Z_VariantClass; +YAZ_EXPORT int z_VariantClass (ODR o, Z_VariantClass **p, int opt, const char *name); + +typedef struct Z_VariantType Z_VariantType; +YAZ_EXPORT int z_VariantType (ODR o, Z_VariantType **p, int opt, const char *name); + +typedef struct Z_VariantValue Z_VariantValue; +YAZ_EXPORT int z_VariantValue (ODR o, Z_VariantValue **p, int opt, const char *name); + +typedef struct Z_ValueSetEnumerated Z_ValueSetEnumerated; +YAZ_EXPORT int z_ValueSetEnumerated (ODR o, Z_ValueSetEnumerated **p, int opt, const char *name); + +typedef struct Z_ValueSet Z_ValueSet; +YAZ_EXPORT int z_ValueSet (ODR o, Z_ValueSet **p, int opt, const char *name); + +typedef struct Z_ValueRange Z_ValueRange; +YAZ_EXPORT int z_ValueRange (ODR o, Z_ValueRange **p, int opt, const char *name); + +typedef struct Z_ValueDescription Z_ValueDescription; +YAZ_EXPORT int z_ValueDescription (ODR o, Z_ValueDescription **p, int opt, const char *name); + +typedef struct Z_UnitInfo Z_UnitInfo; +YAZ_EXPORT int z_UnitInfo (ODR o, Z_UnitInfo **p, int opt, const char *name); + +typedef struct Z_UnitType Z_UnitType; +YAZ_EXPORT int z_UnitType (ODR o, Z_UnitType **p, int opt, const char *name); + +typedef struct Z_Units Z_Units; +YAZ_EXPORT int z_Units (ODR o, Z_Units **p, int opt, const char *name); + +typedef struct Z_CategoryList Z_CategoryList; +YAZ_EXPORT int z_CategoryList (ODR o, Z_CategoryList **p, int opt, const char *name); + +typedef struct Z_CategoryInfo Z_CategoryInfo; +YAZ_EXPORT int z_CategoryInfo (ODR o, Z_CategoryInfo **p, int opt, const char *name); + +typedef struct Z_CommonInfo Z_CommonInfo; +YAZ_EXPORT int z_CommonInfo (ODR o, Z_CommonInfo **p, int opt, const char *name); + +typedef struct Z_HumanStringUnit Z_HumanStringUnit; +YAZ_EXPORT int z_HumanStringUnit (ODR o, Z_HumanStringUnit **p, int opt, const char *name); + +typedef struct Z_HumanString Z_HumanString; +YAZ_EXPORT int z_HumanString (ODR o, Z_HumanString **p, int opt, const char *name); + +typedef struct Z_IconObjectUnit Z_IconObjectUnit; +YAZ_EXPORT int z_IconObjectUnit (ODR o, Z_IconObjectUnit **p, int opt, const char *name); + +typedef struct Z_IconObject Z_IconObject; +YAZ_EXPORT int z_IconObject (ODR o, Z_IconObject **p, int opt, const char *name); + +typedef Z_InternationalString Z_LanguageCode; +YAZ_EXPORT int z_LanguageCode (ODR o, Z_LanguageCode **p, int opt, const char *name); + +typedef struct Z_ContactInfo Z_ContactInfo; +YAZ_EXPORT int z_ContactInfo (ODR o, Z_ContactInfo **p, int opt, const char *name); + +typedef struct Z_NetworkAddressIA Z_NetworkAddressIA; +YAZ_EXPORT int z_NetworkAddressIA (ODR o, Z_NetworkAddressIA **p, int opt, const char *name); + +typedef struct Z_NetworkAddressOPA Z_NetworkAddressOPA; +YAZ_EXPORT int z_NetworkAddressOPA (ODR o, Z_NetworkAddressOPA **p, int opt, const char *name); + +typedef struct Z_NetworkAddressOther Z_NetworkAddressOther; +YAZ_EXPORT int z_NetworkAddressOther (ODR o, Z_NetworkAddressOther **p, int opt, const char *name); + +typedef struct Z_NetworkAddress Z_NetworkAddress; +YAZ_EXPORT int z_NetworkAddress (ODR o, Z_NetworkAddress **p, int opt, const char *name); + +typedef struct Z_AccessInfo Z_AccessInfo; +YAZ_EXPORT int z_AccessInfo (ODR o, Z_AccessInfo **p, int opt, const char *name); + +typedef struct Z_QueryTypeDetails Z_QueryTypeDetails; +YAZ_EXPORT int z_QueryTypeDetails (ODR o, Z_QueryTypeDetails **p, int opt, const char *name); + +typedef struct Z_PrivateCapOperator Z_PrivateCapOperator; +YAZ_EXPORT int z_PrivateCapOperator (ODR o, Z_PrivateCapOperator **p, int opt, const char *name); + +typedef struct Z_PrivateCapabilities Z_PrivateCapabilities; +YAZ_EXPORT int z_PrivateCapabilities (ODR o, Z_PrivateCapabilities **p, int opt, const char *name); + +typedef struct Z_RpnCapabilities Z_RpnCapabilities; +YAZ_EXPORT int z_RpnCapabilities (ODR o, Z_RpnCapabilities **p, int opt, const char *name); + +typedef struct Z_Iso8777Capabilities Z_Iso8777Capabilities; +YAZ_EXPORT int z_Iso8777Capabilities (ODR o, Z_Iso8777Capabilities **p, int opt, const char *name); + +typedef struct Z_ProxSupportPrivate Z_ProxSupportPrivate; +YAZ_EXPORT int z_ProxSupportPrivate (ODR o, Z_ProxSupportPrivate **p, int opt, const char *name); + +typedef struct Z_ProxSupportUnit Z_ProxSupportUnit; +YAZ_EXPORT int z_ProxSupportUnit (ODR o, Z_ProxSupportUnit **p, int opt, const char *name); + +typedef struct Z_ProximitySupport Z_ProximitySupport; +YAZ_EXPORT int z_ProximitySupport (ODR o, Z_ProximitySupport **p, int opt, const char *name); + +typedef struct Z_SearchKey Z_SearchKey; +YAZ_EXPORT int z_SearchKey (ODR o, Z_SearchKey **p, int opt, const char *name); + +typedef struct Z_AccessRestrictionsUnit Z_AccessRestrictionsUnit; +YAZ_EXPORT int z_AccessRestrictionsUnit (ODR o, Z_AccessRestrictionsUnit **p, int opt, const char *name); + +typedef struct Z_AccessRestrictions Z_AccessRestrictions; +YAZ_EXPORT int z_AccessRestrictions (ODR o, Z_AccessRestrictions **p, int opt, const char *name); + +typedef struct Z_CostsOtherCharge Z_CostsOtherCharge; +YAZ_EXPORT int z_CostsOtherCharge (ODR o, Z_CostsOtherCharge **p, int opt, const char *name); + +typedef struct Z_Costs Z_Costs; +YAZ_EXPORT int z_Costs (ODR o, Z_Costs **p, int opt, const char *name); + +typedef struct Z_Charge Z_Charge; +YAZ_EXPORT int z_Charge (ODR o, Z_Charge **p, int opt, const char *name); + +typedef struct Z_DatabaseList Z_DatabaseList; +YAZ_EXPORT int z_DatabaseList (ODR o, Z_DatabaseList **p, int opt, const char *name); + +typedef struct Z_AttributeCombinations Z_AttributeCombinations; +YAZ_EXPORT int z_AttributeCombinations (ODR o, Z_AttributeCombinations **p, int opt, const char *name); + +typedef struct Z_AttributeCombination Z_AttributeCombination; +YAZ_EXPORT int z_AttributeCombination (ODR o, Z_AttributeCombination **p, int opt, const char *name); + +typedef struct Z_AttributeValueList Z_AttributeValueList; +YAZ_EXPORT int z_AttributeValueList (ODR o, Z_AttributeValueList **p, int opt, const char *name); + +typedef struct Z_AttributeOccurrence Z_AttributeOccurrence; +YAZ_EXPORT int z_AttributeOccurrence (ODR o, Z_AttributeOccurrence **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_ExplainRecord { + int which; + union { + Z_TargetInfo *targetInfo; + Z_DatabaseInfo *databaseInfo; + Z_SchemaInfo *schemaInfo; + Z_TagSetInfo *tagSetInfo; + Z_RecordSyntaxInfo *recordSyntaxInfo; + Z_AttributeSetInfo *attributeSetInfo; + Z_TermListInfo *termListInfo; + Z_ExtendedServicesInfo *extendedServicesInfo; + Z_AttributeDetails *attributeDetails; + Z_TermListDetails *termListDetails; + Z_ElementSetDetails *elementSetDetails; + Z_RetrievalRecordDetails *retrievalRecordDetails; + Z_SortDetails *sortDetails; + Z_ProcessingInformation *processing; + Z_VariantSetInfo *variants; + Z_UnitInfo *units; + Z_CategoryList *categoryList; +#define Z_Explain_targetInfo 1 +#define Z_Explain_databaseInfo 2 +#define Z_Explain_schemaInfo 3 +#define Z_Explain_tagSetInfo 4 +#define Z_Explain_recordSyntaxInfo 5 +#define Z_Explain_attributeSetInfo 6 +#define Z_Explain_termListInfo 7 +#define Z_Explain_extendedServicesInfo 8 +#define Z_Explain_attributeDetails 9 +#define Z_Explain_termListDetails 10 +#define Z_Explain_elementSetDetails 11 +#define Z_Explain_retrievalRecordDetails 12 +#define Z_Explain_sortDetails 13 +#define Z_Explain_processing 14 +#define Z_Explain_variants 15 +#define Z_Explain_units 16 +#define Z_Explain_categoryList 17 + } u; +}; + +struct Z_TargetInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Z_InternationalString *name; + Z_HumanString *recentNews; /* OPT */ + Z_IconObject *icon; /* OPT */ + bool_t *namedResultSets; + bool_t *multipleDBsearch; + int *maxResultSets; /* OPT */ + int *maxResultSize; /* OPT */ + int *maxTerms; /* OPT */ + Z_IntUnit *timeoutInterval; /* OPT */ + Z_HumanString *welcomeMessage; /* OPT */ + Z_ContactInfo *contactInfo; /* OPT */ + Z_HumanString *description; /* OPT */ + int num_nicknames; + Z_InternationalString **nicknames; /* OPT */ + Z_HumanString *usageRest; /* OPT */ + Z_HumanString *paymentAddr; /* OPT */ + Z_HumanString *hours; /* OPT */ + int num_dbCombinations; + Z_DatabaseList **dbCombinations; /* OPT */ + int num_addresses; + Z_NetworkAddress **addresses; /* OPT */ + int num_languages; + Z_InternationalString **languages; /* OPT */ + Z_AccessInfo *commonAccessInfo; /* OPT */ +}; + +struct Z_DatabaseInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Z_DatabaseName *name; + Odr_null *explainDatabase; /* OPT */ + int num_nicknames; + Z_DatabaseName **nicknames; /* OPT */ + Z_IconObject *icon; /* OPT */ + bool_t *userFee; + bool_t *available; + Z_HumanString *titleString; /* OPT */ + int num_keywords; + Z_HumanString **keywords; /* OPT */ + Z_HumanString *description; /* OPT */ + Z_DatabaseList *associatedDbs; /* OPT */ + Z_DatabaseList *subDbs; /* OPT */ + Z_HumanString *disclaimers; /* OPT */ + Z_HumanString *news; /* OPT */ + int which; + union { + int *actualNumber; + int *approxNumber; +#define Z_DatabaseInfo_actualNumber 1 +#define Z_DatabaseInfo_approxNumber 2 + } u; /* OPT */ + Z_HumanString *defaultOrder; /* OPT */ + int *avRecordSize; /* OPT */ + int *maxRecordSize; /* OPT */ + Z_HumanString *hours; /* OPT */ + Z_HumanString *bestTime; /* OPT */ + char *lastUpdate; /* OPT */ + Z_IntUnit *updateInterval; /* OPT */ + Z_HumanString *coverage; /* OPT */ + bool_t *proprietary; /* OPT */ + Z_HumanString *copyrightText; /* OPT */ + Z_HumanString *copyrightNotice; /* OPT */ + Z_ContactInfo *producerContactInfo; /* OPT */ + Z_ContactInfo *supplierContactInfo; /* OPT */ + Z_ContactInfo *submissionContactInfo; /* OPT */ + Z_AccessInfo *accessInfo; /* OPT */ +}; + +struct Z_TagTypeMapping { + int *tagType; + Odr_oid *tagSet; /* OPT */ + Odr_null *defaultTagType; /* OPT */ +}; + +struct Z_SchemaInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Odr_oid *schema; + Z_InternationalString *name; + Z_HumanString *description; /* OPT */ + int num_tagTypeMapping; + Z_TagTypeMapping **tagTypeMapping; /* OPT */ + int num_recordStructure; + Z_ElementInfo **recordStructure; /* OPT */ +}; + +struct Z_ElementInfo { + Z_InternationalString *elementName; + Z_Path *elementTagPath; + Z_ElementDataType *dataType; /* OPT */ + bool_t *required; + bool_t *repeatable; + Z_HumanString *description; /* OPT */ +}; + +struct Z_PathUnit { + int *tagType; + Z_StringOrNumeric *tagValue; +}; + +struct Z_Path { + int num; + Z_PathUnit **elements; +}; + +struct Z_ElementInfoList { + int num; + Z_ElementInfo **elements; +}; + +struct Z_ElementDataType { + int which; + union { + Z_PrimitiveDataType *primitive; + Z_ElementInfoList *structured; +#define Z_ElementDataType_primitive 1 +#define Z_ElementDataType_structured 2 + } u; +}; + +#define Z_PrimitiveDataType_octetString 0 +#define Z_PrimitiveDataType_numeric 1 +#define Z_PrimitiveDataType_date 2 +#define Z_PrimitiveDataType_external 3 +#define Z_PrimitiveDataType_string 4 +#define Z_PrimitiveDataType_trueOrFalse 5 +#define Z_PrimitiveDataType_oid 6 +#define Z_PrimitiveDataType_intUnit 7 +#define Z_PrimitiveDataType_empty 8 +#define Z_PrimitiveDataType_noneOfTheAbove 100 + +struct Z_TagSetElements { + Z_InternationalString *elementname; + int num_nicknames; + Z_InternationalString **nicknames; /* OPT */ + Z_StringOrNumeric *elementTag; + Z_HumanString *description; /* OPT */ + Z_PrimitiveDataType *dataType; /* OPT */ + Z_OtherInformation *otherTagInfo; /* OPT */ +}; + +struct Z_TagSetInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Odr_oid *tagSet; + Z_InternationalString *name; + Z_HumanString *description; /* OPT */ + int num_elements; + Z_TagSetElements **elements; /* OPT */ +}; + +struct Z_RecordSyntaxInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Odr_oid *recordSyntax; + Z_InternationalString *name; + int num_transferSyntaxes; + Odr_oid **transferSyntaxes; /* OPT */ + Z_HumanString *description; /* OPT */ + Z_InternationalString *asn1Module; /* OPT */ + int num_abstractStructure; + Z_ElementInfo **abstractStructure; /* OPT */ +}; + +struct Z_AttributeSetInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Z_AttributeSetId *attributeSet; + Z_InternationalString *name; + int num_attributes; + Z_AttributeType **attributes; /* OPT */ + Z_HumanString *description; /* OPT */ +}; + +struct Z_AttributeType { + Z_InternationalString *name; /* OPT */ + Z_HumanString *description; /* OPT */ + int *attributeType; + int num_attributeValues; + Z_AttributeDescription **attributeValues; +}; + +struct Z_AttributeDescription { + Z_InternationalString *name; /* OPT */ + Z_HumanString *description; /* OPT */ + Z_StringOrNumeric *attributeValue; + int num_equivalentAttributes; + Z_StringOrNumeric **equivalentAttributes; /* OPT */ +}; + +struct Z_TermListElement { + Z_InternationalString *name; + Z_HumanString *title; /* OPT */ +#define Z_TermListElement_optimized 0 +#define Z_TermListElement_normal 1 +#define Z_TermListElement_expensive 2 +#define Z_TermListElement_filter 3 + int *searchCost; /* OPT */ + bool_t *scanable; + int num_broader; + Z_InternationalString **broader; /* OPT */ + int num_narrower; + Z_InternationalString **narrower; /* OPT */ +}; + +struct Z_TermListInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Z_DatabaseName *databaseName; + int num_termLists; + Z_TermListElement **termLists; +}; + +struct Z_ExtendedServicesInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Odr_oid *type; + Z_InternationalString *name; /* OPT */ + bool_t *privateType; + bool_t *restrictionsApply; + bool_t *feeApply; + bool_t *available; + bool_t *retentionSupported; +#define Z_ExtendedServicesInfo_waitSupported 1 +#define Z_ExtendedServicesInfo_waitAlways 2 +#define Z_ExtendedServicesInfo_waitNotSupported 3 +#define Z_ExtendedServicesInfo_depends 4 +#define Z_ExtendedServicesInfo_notSaying 5 + int *waitAction; + Z_HumanString *description; /* OPT */ + Z_External *specificExplain; /* OPT */ + Z_InternationalString *esASN; /* OPT */ +}; + +struct Z_AttributeDetails { + Z_CommonInfo *commonInfo; /* OPT */ + Z_DatabaseName *databaseName; + int num_attributesBySet; + Z_AttributeSetDetails **attributesBySet; /* OPT */ + Z_AttributeCombinations *attributeCombinations; /* OPT */ +}; + +struct Z_AttributeSetDetails { + Z_AttributeSetId *attributeSet; + int num_attributesByType; + Z_AttributeTypeDetails **attributesByType; +}; + +struct Z_AttributeTypeDetails { + int *attributeType; + Z_OmittedAttributeInterpretation *defaultIfOmitted; /* OPT */ + int num_attributeValues; + Z_AttributeValue **attributeValues; /* OPT */ +}; + +struct Z_OmittedAttributeInterpretation { + Z_StringOrNumeric *defaultValue; /* OPT */ + Z_HumanString *defaultDescription; /* OPT */ +}; + +struct Z_AttributeValue { + Z_StringOrNumeric *value; + Z_HumanString *description; /* OPT */ + int num_subAttributes; + Z_StringOrNumeric **subAttributes; /* OPT */ + int num_superAttributes; + Z_StringOrNumeric **superAttributes; /* OPT */ + Odr_null *partialSupport; /* OPT */ +}; + +struct Z_EScanInfo { + int *maxStepSize; /* OPT */ + Z_HumanString *collatingSequence; /* OPT */ + bool_t *increasing; /* OPT */ +}; + +struct Z_TermListDetails { + Z_CommonInfo *commonInfo; /* OPT */ + Z_InternationalString *termListName; + Z_HumanString *description; /* OPT */ + Z_AttributeCombinations *attributes; /* OPT */ + Z_EScanInfo *scanInfo; /* OPT */ + int *estNumberTerms; /* OPT */ + int num_sampleTerms; + Z_Term **sampleTerms; /* OPT */ +}; + +struct Z_ElementSetDetails { + Z_CommonInfo *commonInfo; /* OPT */ + Z_DatabaseName *databaseName; + Z_ElementSetName *elementSetName; + Odr_oid *recordSyntax; + Odr_oid *schema; + Z_HumanString *description; /* OPT */ + int num_detailsPerElement; + Z_PerElementDetails **detailsPerElement; /* OPT */ +}; + +struct Z_RetrievalRecordDetails { + Z_CommonInfo *commonInfo; /* OPT */ + Z_DatabaseName *databaseName; + Odr_oid *schema; + Odr_oid *recordSyntax; + Z_HumanString *description; /* OPT */ + int num_detailsPerElement; + Z_PerElementDetails **detailsPerElement; /* OPT */ +}; + +struct Z_PerElementDetails { + Z_InternationalString *name; /* OPT */ + Z_RecordTag *recordTag; /* OPT */ + int num_schemaTags; + Z_Path **schemaTags; /* OPT */ + int *maxSize; /* OPT */ + int *minSize; /* OPT */ + int *avgSize; /* OPT */ + int *fixedSize; /* OPT */ + bool_t *repeatable; + bool_t *required; + Z_HumanString *description; /* OPT */ + Z_HumanString *contents; /* OPT */ + Z_HumanString *billingInfo; /* OPT */ + Z_HumanString *restrictions; /* OPT */ + int num_alternateNames; + Z_InternationalString **alternateNames; /* OPT */ + int num_genericNames; + Z_InternationalString **genericNames; /* OPT */ + Z_AttributeCombinations *searchAccess; /* OPT */ +}; + +struct Z_RecordTag { + Z_StringOrNumeric *qualifier; /* OPT */ + Z_StringOrNumeric *tagValue; +}; + +struct Z_SortDetails { + Z_CommonInfo *commonInfo; /* OPT */ + Z_DatabaseName *databaseName; + int num_sortKeys; + Z_SortKeyDetails **sortKeys; /* OPT */ +}; + +struct Z_SortKeyDetails { + Z_HumanString *description; /* OPT */ + int num_elementSpecifications; + Z_Specification **elementSpecifications; /* OPT */ + Z_AttributeCombinations *attributeSpecifications; /* OPT */ + int which; + union { + Odr_null *character; + Odr_null *numeric; + Z_HumanString *structured; +#define Z_SortKeyDetails_character 1 +#define Z_SortKeyDetails_numeric 2 +#define Z_SortKeyDetails_structured 3 + } u; /* OPT */ +#define Z_SortKeyDetails_always 0 +#define Z_SortKeyDetails_never 1 +#define Z_SortKeyDetails_default_yes 2 +#define Z_SortKeyDetails_default_no 3 + int *caseSensitivity; /* OPT */ +}; + +struct Z_ProcessingInformation { + Z_CommonInfo *commonInfo; /* OPT */ + Z_DatabaseName *databaseName; +#define Z_ProcessingInformation_access 0 +#define Z_ProcessingInformation_search 1 +#define Z_ProcessingInformation_retrieval 2 +#define Z_ProcessingInformation_record_presentation 3 +#define Z_ProcessingInformation_record_handling 4 + int *processingContext; + Z_InternationalString *name; + Odr_oid *oid; + Z_HumanString *description; /* OPT */ + Z_External *instructions; /* OPT */ +}; + +struct Z_VariantSetInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Odr_oid *variantSet; + Z_InternationalString *name; + int num_variants; + Z_VariantClass **variants; /* OPT */ +}; + +struct Z_VariantClass { + Z_InternationalString *name; /* OPT */ + Z_HumanString *description; /* OPT */ + int *variantClass; + int num_variantTypes; + Z_VariantType **variantTypes; +}; + +struct Z_VariantType { + Z_InternationalString *name; /* OPT */ + Z_HumanString *description; /* OPT */ + int *variantType; + Z_VariantValue *variantValue; /* OPT */ +}; + +struct Z_VariantValue { + Z_PrimitiveDataType *dataType; + Z_ValueSet *values; /* OPT */ +}; + +struct Z_ValueSetEnumerated { + int num; + Z_ValueDescription **elements; +}; + +struct Z_ValueSet { + int which; + union { + Z_ValueRange *range; + Z_ValueSetEnumerated *enumerated; +#define Z_ValueSet_range 1 +#define Z_ValueSet_enumerated 2 + } u; +}; + +struct Z_ValueRange { + Z_ValueDescription *lower; /* OPT */ + Z_ValueDescription *upper; /* OPT */ +}; + +struct Z_ValueDescription { + int which; + union { + int *integer; + Z_InternationalString *string; + Odr_oct *octets; + Odr_oid *oid; + Z_Unit *unit; + Z_IntUnit *valueAndUnit; +#define Z_ValueDescription_integer 1 +#define Z_ValueDescription_string 2 +#define Z_ValueDescription_octets 3 +#define Z_ValueDescription_oid 4 +#define Z_ValueDescription_unit 5 +#define Z_ValueDescription_valueAndUnit 6 + } u; +}; + +struct Z_UnitInfo { + Z_CommonInfo *commonInfo; /* OPT */ + Z_InternationalString *unitSystem; + Z_HumanString *description; /* OPT */ + int num_units; + Z_UnitType **units; /* OPT */ +}; + +struct Z_UnitType { + Z_InternationalString *name; /* OPT */ + Z_HumanString *description; /* OPT */ + Z_StringOrNumeric *unitType; + int num_units; + Z_Units **units; +}; + +struct Z_Units { + Z_InternationalString *name; /* OPT */ + Z_HumanString *description; /* OPT */ + Z_StringOrNumeric *unit; +}; + +struct Z_CategoryList { + Z_CommonInfo *commonInfo; /* OPT */ + int num_categories; + Z_CategoryInfo **categories; +}; + +struct Z_CategoryInfo { + Z_InternationalString *category; + Z_InternationalString *originalCategory; /* OPT */ + Z_HumanString *description; /* OPT */ + Z_InternationalString *asn1Module; /* OPT */ +}; + +struct Z_CommonInfo { + char *dateAdded; /* OPT */ + char *dateChanged; /* OPT */ + char *expiry; /* OPT */ + Z_LanguageCode *humanStringLanguage; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_HumanStringUnit { + Z_LanguageCode *language; /* OPT */ + Z_InternationalString *text; +}; + +struct Z_HumanString { + int num_strings; + Z_HumanStringUnit **strings; +}; + +struct Z_IconObjectUnit { + int which; + union { + Z_InternationalString *ianaType; + Z_InternationalString *z3950type; + Z_InternationalString *otherType; +#define Z_IconObjectUnit_ianaType 1 +#define Z_IconObjectUnit_z3950type 2 +#define Z_IconObjectUnit_otherType 3 + } u; + Odr_oct *content; +}; + +struct Z_IconObject { + int num; + Z_IconObjectUnit **elements; +}; + + + +struct Z_ContactInfo { + Z_InternationalString *name; /* OPT */ + Z_HumanString *description; /* OPT */ + Z_HumanString *address; /* OPT */ + Z_InternationalString *email; /* OPT */ + Z_InternationalString *phone; /* OPT */ +}; + +struct Z_NetworkAddressIA { + Z_InternationalString *hostAddress; + int *port; +}; + +struct Z_NetworkAddressOPA { + Z_InternationalString *pSel; + Z_InternationalString *sSel; /* OPT */ + Z_InternationalString *tSel; /* OPT */ + Z_InternationalString *nSap; +}; + +struct Z_NetworkAddressOther { + Z_InternationalString *type; + Z_InternationalString *address; +}; + +struct Z_NetworkAddress { + int which; + union { + Z_NetworkAddressIA *internetAddress; + Z_NetworkAddressOPA *osiPresentationAddress; + Z_NetworkAddressOther *other; +#define Z_NetworkAddress_iA 1 +#define Z_NetworkAddress_oPA 2 +#define Z_NetworkAddress_other 3 + } u; +}; + +struct Z_AccessInfo { + int num_queryTypesSupported; + Z_QueryTypeDetails **queryTypesSupported; /* OPT */ + int num_diagnosticsSets; + Odr_oid **diagnosticsSets; /* OPT */ + int num_attributeSetIds; + Z_AttributeSetId **attributeSetIds; /* OPT */ + int num_schemas; + Odr_oid **schemas; /* OPT */ + int num_recordSyntaxes; + Odr_oid **recordSyntaxes; /* OPT */ + int num_resourceChallenges; + Odr_oid **resourceChallenges; /* OPT */ + Z_AccessRestrictions *restrictedAccess; /* OPT */ + Z_Costs *costInfo; /* OPT */ + int num_variantSets; + Odr_oid **variantSets; /* OPT */ + int num_elementSetNames; + Z_ElementSetName **elementSetNames; /* OPT */ + int num_unitSystems; + Z_InternationalString **unitSystems; +}; + +struct Z_QueryTypeDetails { + int which; + union { + Z_PrivateCapabilities *zprivate; + Z_RpnCapabilities *rpn; + Z_Iso8777Capabilities *iso8777; + Z_HumanString *z39_58; + Z_RpnCapabilities *erpn; + Z_HumanString *rankedList; +#define Z_QueryTypeDetails_private 1 +#define Z_QueryTypeDetails_rpn 2 +#define Z_QueryTypeDetails_iso8777 3 +#define Z_QueryTypeDetails_z39_58 4 +#define Z_QueryTypeDetails_erpn 5 +#define Z_QueryTypeDetails_rankedList 6 + } u; +}; + +struct Z_PrivateCapOperator { + Z_InternationalString *roperator; + Z_HumanString *description; /* OPT */ +}; + +struct Z_PrivateCapabilities { + int num_operators; + Z_PrivateCapOperator **operators; /* OPT */ + int num_searchKeys; + Z_SearchKey **searchKeys; /* OPT */ + int num_description; + Z_HumanString **description; /* OPT */ +}; + +struct Z_RpnCapabilities { + int num_operators; + int **operators; /* OPT */ + bool_t *resultSetAsOperandSupported; + bool_t *restrictionOperandSupported; + Z_ProximitySupport *proximity; /* OPT */ +}; + +struct Z_Iso8777Capabilities { + int num_searchKeys; + Z_SearchKey **searchKeys; + Z_HumanString *restrictions; /* OPT */ +}; + +struct Z_ProxSupportPrivate { + int *unit; + Z_HumanString *description; /* OPT */ +}; + +struct Z_ProxSupportUnit { + int which; + union { + int *known; + Z_ProxSupportPrivate *zprivate; +#define Z_ProxSupportUnit_known 1 +#define Z_ProxSupportUnit_private 2 + } u; +}; + +struct Z_ProximitySupport { + bool_t *anySupport; + int num_unitsSupported; + Z_ProxSupportUnit **unitsSupported; /* OPT */ +}; + +struct Z_SearchKey { + Z_InternationalString *searchKey; + Z_HumanString *description; /* OPT */ +}; + +struct Z_AccessRestrictionsUnit { +#define Z_AccessRestrictionsUnit_any 0 +#define Z_AccessRestrictionsUnit_search 1 +#define Z_AccessRestrictionsUnit_present 2 +#define Z_AccessRestrictionsUnit_specific_elements 3 +#define Z_AccessRestrictionsUnit_extended_services 4 +#define Z_AccessRestrictionsUnit_by_database 5 + int *accessType; + Z_HumanString *accessText; /* OPT */ + int num_accessChallenges; + Odr_oid **accessChallenges; /* OPT */ +}; + +struct Z_AccessRestrictions { + int num; + Z_AccessRestrictionsUnit **elements; +}; + +struct Z_CostsOtherCharge { + Z_HumanString *forWhat; + Z_Charge *charge; +}; + +struct Z_Costs { + Z_Charge *connectCharge; /* OPT */ + Z_Charge *connectTime; /* OPT */ + Z_Charge *displayCharge; /* OPT */ + Z_Charge *searchCharge; /* OPT */ + Z_Charge *subscriptCharge; /* OPT */ + int num_otherCharges; + Z_CostsOtherCharge **otherCharges; /* OPT */ +}; + +struct Z_Charge { + Z_IntUnit *cost; + Z_Unit *perWhat; /* OPT */ + Z_HumanString *text; /* OPT */ +}; + +struct Z_DatabaseList { + int num_databases; + Z_DatabaseName **databases; +}; + +struct Z_AttributeCombinations { + Z_AttributeSetId *defaultAttributeSet; + int num_legalCombinations; + Z_AttributeCombination **legalCombinations; +}; + +struct Z_AttributeCombination { + int num_occurrences; + Z_AttributeOccurrence **occurrences; +}; + +struct Z_AttributeValueList { + int num_attributes; + Z_StringOrNumeric **attributes; +}; + +struct Z_AttributeOccurrence { + Z_AttributeSetId *attributeSet; /* OPT */ + int *attributeType; + Odr_null *mustBeSupplied; /* OPT */ + int which; + union { + Odr_null *any_or_none; + Z_AttributeValueList *specific; +#define Z_AttributeOcc_any_or_none 1 +#define Z_AttributeOcc_specific 2 + } attributeValues; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-grs.h b/include/yaz/z-grs.h new file mode 100644 index 0000000..98d37cd --- /dev/null +++ b/include/yaz/z-grs.h @@ -0,0 +1,178 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H RecordSyntax-generic */ + +#ifndef z_grs_H +#define z_grs_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_GenericRecord Z_GenericRecord; +YAZ_EXPORT int z_GenericRecord (ODR o, Z_GenericRecord **p, int opt, const char *name); + +typedef struct Z_TaggedElement Z_TaggedElement; +YAZ_EXPORT int z_TaggedElement (ODR o, Z_TaggedElement **p, int opt, const char *name); + +typedef struct Z_ElementData Z_ElementData; +YAZ_EXPORT int z_ElementData (ODR o, Z_ElementData **p, int opt, const char *name); + +typedef struct Z_ElementMetaData Z_ElementMetaData; +YAZ_EXPORT int z_ElementMetaData (ODR o, Z_ElementMetaData **p, int opt, const char *name); + +typedef struct Z_TagPath_s Z_TagPath_s; +YAZ_EXPORT int z_TagPath_s (ODR o, Z_TagPath_s **p, int opt, const char *name); + +typedef struct Z_TagPath Z_TagPath; +YAZ_EXPORT int z_TagPath (ODR o, Z_TagPath **p, int opt, const char *name); + +typedef struct Z_Order Z_Order; +YAZ_EXPORT int z_Order (ODR o, Z_Order **p, int opt, const char *name); + +typedef struct Z_Usage Z_Usage; +YAZ_EXPORT int z_Usage (ODR o, Z_Usage **p, int opt, const char *name); + +typedef struct Z_HitVector Z_HitVector; +YAZ_EXPORT int z_HitVector (ODR o, Z_HitVector **p, int opt, const char *name); + +typedef struct Z_Triple Z_Triple; +YAZ_EXPORT int z_Triple (ODR o, Z_Triple **p, int opt, const char *name); + +typedef struct Z_Variant Z_Variant; +YAZ_EXPORT int z_Variant (ODR o, Z_Variant **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_GenericRecord { + int num_elements; + Z_TaggedElement **elements; +}; + +struct Z_TaggedElement { + int *tagType; /* OPT */ + Z_StringOrNumeric *tagValue; + int *tagOccurrence; /* OPT */ + Z_ElementData *content; + Z_ElementMetaData *metaData; /* OPT */ + Z_Variant *appliedVariant; /* OPT */ +}; + +struct Z_ElementData { + int which; + union { + Odr_oct *octets; + int *numeric; + char *date; + Z_External *ext; + Z_InternationalString *string; + bool_t *trueOrFalse; + Odr_oid *oid; + Z_IntUnit *intUnit; + Odr_null *elementNotThere; + Odr_null *elementEmpty; + Odr_null *noDataRequested; + Z_External *diagnostic; + Z_GenericRecord *subtree; +#define Z_ElementData_octets 1 +#define Z_ElementData_numeric 2 +#define Z_ElementData_date 3 +#define Z_ElementData_ext 4 +#define Z_ElementData_string 5 +#define Z_ElementData_trueOrFalse 6 +#define Z_ElementData_oid 7 +#define Z_ElementData_intUnit 8 +#define Z_ElementData_elementNotThere 9 +#define Z_ElementData_elementEmpty 10 +#define Z_ElementData_noDataRequested 11 +#define Z_ElementData_diagnostic 12 +#define Z_ElementData_subtree 13 + } u; +}; + +struct Z_ElementMetaData { + Z_Order *seriesOrder; /* OPT */ + Z_Usage *usageRight; /* OPT */ + int num_hits; + Z_HitVector **hits; /* OPT */ + Z_InternationalString *displayName; /* OPT */ + int num_supportedVariants; + Z_Variant **supportedVariants; /* OPT */ + Z_InternationalString *message; /* OPT */ + Odr_oct *elementDescriptor; /* OPT */ + Z_TagPath *surrogateFor; /* OPT */ + Z_TagPath *surrogateElement; /* OPT */ + Z_External *other; /* OPT */ +}; + +struct Z_TagPath_s { + int *tagType; /* OPT */ + Z_StringOrNumeric *tagValue; + int *tagOccurrence; /* OPT */ +}; + +struct Z_TagPath { + int num; + Z_TagPath_s **elements; +}; + +struct Z_Order { + bool_t *ascending; + int *order; +}; + +struct Z_Usage { +#define Z_Usage_redistributable 1 +#define Z_Usage_restricted 2 +#define Z_Usage_licensePointer 3 + int *type; + Z_InternationalString *restriction; /* OPT */ +}; + +struct Z_HitVector { + Z_Term *satisfier; /* OPT */ + Z_IntUnit *offsetIntoElement; /* OPT */ + Z_IntUnit *length; /* OPT */ + int *hitRank; /* OPT */ + Odr_oct *targetToken; /* OPT */ +}; + +struct Z_Triple { + Odr_oid *variantSetId; /* OPT */ + int *zclass; + int *type; + int which; + union { + int *integer; + Z_InternationalString *internationalString; + Odr_oct *octetString; + Odr_oid *objectIdentifier; + bool_t *boolean; + Odr_null *null; + Z_Unit *unit; + Z_IntUnit *valueAndUnit; +#define Z_Triple_integer 1 +#define Z_Triple_internationalString 2 +#define Z_Triple_octetString 3 +#define Z_Triple_objectIdentifier 4 +#define Z_Triple_boolean 5 +#define Z_Triple_null 6 +#define Z_Triple_unit 7 +#define Z_Triple_valueAndUnit 8 + } value; +}; + +struct Z_Variant { + Odr_oid *globalVariantSetId; /* OPT */ + int num_triples; + Z_Triple **triples; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-opac.h b/include/yaz/z-opac.h new file mode 100644 index 0000000..1ed2674 --- /dev/null +++ b/include/yaz/z-opac.h @@ -0,0 +1,95 @@ +/* YC 0.2: Tue Feb 29 16:45:06 CET 2000 */ +/* Module-H RecordSyntax-opac */ + +#ifndef z_opac_H +#define z_opac_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_OPACRecord Z_OPACRecord; +YAZ_EXPORT int z_OPACRecord (ODR o, Z_OPACRecord **p, int opt, const char *name); + +typedef struct Z_HoldingsRecord Z_HoldingsRecord; +YAZ_EXPORT int z_HoldingsRecord (ODR o, Z_HoldingsRecord **p, int opt, const char *name); + +typedef struct Z_HoldingsAndCircData Z_HoldingsAndCircData; +YAZ_EXPORT int z_HoldingsAndCircData (ODR o, Z_HoldingsAndCircData **p, int opt, const char *name); + +typedef struct Z_Volume Z_Volume; +YAZ_EXPORT int z_Volume (ODR o, Z_Volume **p, int opt, const char *name); + +typedef struct Z_CircRecord Z_CircRecord; +YAZ_EXPORT int z_CircRecord (ODR o, Z_CircRecord **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_OPACRecord { + Z_External *bibliographicRecord; /* OPT */ + int num_holdingsData; + Z_HoldingsRecord **holdingsData; /* OPT */ +}; + +struct Z_HoldingsRecord { + int which; + union { + Z_External *marcHoldingsRecord; + Z_HoldingsAndCircData *holdingsAndCirc; +#define Z_HoldingsRecord_marcHoldingsRecord 1 +#define Z_HoldingsRecord_holdingsAndCirc 2 + } u; +}; + +struct Z_HoldingsAndCircData { + Z_InternationalString *typeOfRecord; /* OPT */ + Z_InternationalString *encodingLevel; /* OPT */ + Z_InternationalString *format; /* OPT */ + Z_InternationalString *receiptAcqStatus; /* OPT */ + Z_InternationalString *generalRetention; /* OPT */ + Z_InternationalString *completeness; /* OPT */ + Z_InternationalString *dateOfReport; /* OPT */ + Z_InternationalString *nucCode; /* OPT */ + Z_InternationalString *localLocation; /* OPT */ + Z_InternationalString *shelvingLocation; /* OPT */ + Z_InternationalString *callNumber; /* OPT */ + Z_InternationalString *shelvingData; /* OPT */ + Z_InternationalString *copyNumber; /* OPT */ + Z_InternationalString *publicNote; /* OPT */ + Z_InternationalString *reproductionNote; /* OPT */ + Z_InternationalString *termsUseRepro; /* OPT */ + Z_InternationalString *enumAndChron; /* OPT */ + int num_volumes; + Z_Volume **volumes; /* OPT */ + int num_circulationData; + Z_CircRecord **circulationData; /* OPT */ +}; + +struct Z_Volume { + Z_InternationalString *enumeration; /* OPT */ + Z_InternationalString *chronology; /* OPT */ + Z_InternationalString *enumAndChron; /* OPT */ +}; + +struct Z_CircRecord { + bool_t *availableNow; + Z_InternationalString *availablityDate; /* OPT */ + Z_InternationalString *availableThru; /* OPT */ + Z_InternationalString *restrictions; /* OPT */ + Z_InternationalString *itemId; /* OPT */ + bool_t *renewable; + bool_t *onHold; + Z_InternationalString *enumAndChron; /* OPT */ + Z_InternationalString *midspine; /* OPT */ + Z_InternationalString *temporaryLocation; /* OPT */ +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-rrf1.h b/include/yaz/z-rrf1.h new file mode 100644 index 0000000..f258a1a --- /dev/null +++ b/include/yaz/z-rrf1.h @@ -0,0 +1,59 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ResourceReport-Format-Resource-1 */ + +#ifndef z_rrf1_H +#define z_rrf1_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_ResourceReport1 Z_ResourceReport1; +YAZ_EXPORT int z_ResourceReport1 (ODR o, Z_ResourceReport1 **p, int opt, const char *name); + +typedef struct Z_Estimate1 Z_Estimate1; +YAZ_EXPORT int z_Estimate1 (ODR o, Z_Estimate1 **p, int opt, const char *name); + +typedef int Z_EstimateType; +YAZ_EXPORT int z_EstimateType (ODR o, Z_EstimateType **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_ResourceReport1 { + int num_estimates; + Z_Estimate1 **estimates; + Z_InternationalString *message; +}; + +struct Z_Estimate1 { + Z_EstimateType *type; + int *value; + int *currency_code; /* OPT */ +}; + +#define Z_EstimateType_currentSearchRecords 1 +#define Z_EstimateType_finalSearchRecords 2 +#define Z_EstimateType_currentPresentRecords 3 +#define Z_EstimateType_finalPresentRecords 4 +#define Z_EstimateType_currentOpTimeProcessing 5 +#define Z_EstimateType_finalOpTimeProcessing 6 +#define Z_EstimateType_currentAssocTime 7 +#define Z_EstimateType_currentOperationCost 8 +#define Z_EstimateType_finalOperationCost 9 +#define Z_EstimateType_currentAssocCost 10 +#define Z_EstimateType_finalOpTimeElapsed 11 +#define Z_EstimateType_percentComplete 12 +#define Z_EstimateType_currentSearchAssocCost 13 +#define Z_EstimateType_currentPresentAssocCost 14 +#define Z_EstimateType_currentConnectAssocCost 15 +#define Z_EstimateType_currentOtherAssocCost 16 + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-rrf2.h b/include/yaz/z-rrf2.h new file mode 100644 index 0000000..8230485 --- /dev/null +++ b/include/yaz/z-rrf2.h @@ -0,0 +1,38 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ResourceReport-Format-Resource-2 */ + +#ifndef z_rrf2_H +#define z_rrf2_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_ResourceReport2 Z_ResourceReport2; +YAZ_EXPORT int z_ResourceReport2 (ODR o, Z_ResourceReport2 **p, int opt, const char *name); + +typedef struct Z_Estimate2 Z_Estimate2; +YAZ_EXPORT int z_Estimate2 (ODR o, Z_Estimate2 **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_ResourceReport2 { + int num_estimates; + Z_Estimate2 **estimates; /* OPT */ + Z_InternationalString *message; /* OPT */ +}; + +struct Z_Estimate2 { + Z_StringOrNumeric *type; + Z_IntUnit *value; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-sum.h b/include/yaz/z-sum.h new file mode 100644 index 0000000..b868fe2 --- /dev/null +++ b/include/yaz/z-sum.h @@ -0,0 +1,51 @@ +/* YC 0.2: Tue Feb 29 16:45:06 CET 2000 */ +/* Module-H RecordSyntax-summary */ + +#ifndef z_sum_H +#define z_sum_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_BriefBib Z_BriefBib; +YAZ_EXPORT int z_BriefBib (ODR o, Z_BriefBib **p, int opt, const char *name); + +typedef struct Z_FormatSpec Z_FormatSpec; +YAZ_EXPORT int z_FormatSpec (ODR o, Z_FormatSpec **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_BriefBib { + Z_InternationalString *title; + Z_InternationalString *author; /* OPT */ + Z_InternationalString *callNumber; /* OPT */ + Z_InternationalString *recordType; /* OPT */ + Z_InternationalString *bibliographicLevel; /* OPT */ + int num_format; + Z_FormatSpec **format; /* OPT */ + Z_InternationalString *publicationPlace; /* OPT */ + Z_InternationalString *publicationDate; /* OPT */ + Z_InternationalString *targetSystemKey; /* OPT */ + Z_InternationalString *satisfyingElement; /* OPT */ + int *rank; /* OPT */ + Z_InternationalString *documentId; /* OPT */ + Z_InternationalString *abstract; /* OPT */ + Z_OtherInformation *otherInfo; /* OPT */ +}; + +struct Z_FormatSpec { + Z_InternationalString *type; + int *size; /* OPT */ + int *bestPosn; /* OPT */ +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-sutrs.h b/include/yaz/z-sutrs.h new file mode 100644 index 0000000..a9b8276 --- /dev/null +++ b/include/yaz/z-sutrs.h @@ -0,0 +1,36 @@ +/* YC 0.2: Tue Feb 29 16:45:06 CET 2000 */ +/* Module-H RecordSyntax-SUTRS */ + +#ifndef z_sutrs_H +#define z_sutrs_H + +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef Odr_oct Z_SUTRS; +YAZ_EXPORT int z_SUTRS (ODR o, Odr_oct **p, int opt); + +#ifdef __cplusplus +} +#endif +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef Z_InternationalString Z_SutrsRecord; +YAZ_EXPORT int z_SutrsRecord (ODR o, Z_SutrsRecord **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-uifr1.h b/include/yaz/z-uifr1.h new file mode 100644 index 0000000..c28dee1 --- /dev/null +++ b/include/yaz/z-uifr1.h @@ -0,0 +1,95 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H UserInfoFormat-searchResult-1 */ + +#ifndef z_uifr1_H +#define z_uifr1_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_SearchInfoReport_s Z_SearchInfoReport_s; +YAZ_EXPORT int z_SearchInfoReport_s (ODR o, Z_SearchInfoReport_s **p, int opt, const char *name); + +typedef struct Z_SearchInfoReport Z_SearchInfoReport; +YAZ_EXPORT int z_SearchInfoReport (ODR o, Z_SearchInfoReport **p, int opt, const char *name); + +typedef struct Z_ResultsByDB_sList Z_ResultsByDB_sList; +YAZ_EXPORT int z_ResultsByDB_sList (ODR o, Z_ResultsByDB_sList **p, int opt, const char *name); + +typedef struct Z_ResultsByDB_s Z_ResultsByDB_s; +YAZ_EXPORT int z_ResultsByDB_s (ODR o, Z_ResultsByDB_s **p, int opt, const char *name); + +typedef struct Z_ResultsByDB Z_ResultsByDB; +YAZ_EXPORT int z_ResultsByDB (ODR o, Z_ResultsByDB **p, int opt, const char *name); + +typedef struct Z_QueryExpressionTerm Z_QueryExpressionTerm; +YAZ_EXPORT int z_QueryExpressionTerm (ODR o, Z_QueryExpressionTerm **p, int opt, const char *name); + +typedef struct Z_QueryExpression Z_QueryExpression; +YAZ_EXPORT int z_QueryExpression (ODR o, Z_QueryExpression **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_SearchInfoReport_s { + Z_InternationalString *subqueryId; /* OPT */ + bool_t *fullQuery; + Z_QueryExpression *subqueryExpression; /* OPT */ + Z_QueryExpression *subqueryInterpretation; /* OPT */ + Z_QueryExpression *subqueryRecommendation; /* OPT */ + int *subqueryCount; /* OPT */ + Z_IntUnit *subqueryWeight; /* OPT */ + Z_ResultsByDB *resultsByDB; /* OPT */ +}; + +struct Z_SearchInfoReport { + int num; + Z_SearchInfoReport_s **elements; +}; + +struct Z_ResultsByDB_sList { + int num; + Z_DatabaseName **elements; +}; + +struct Z_ResultsByDB_s { + int which; + union { + Odr_null *all; + Z_ResultsByDB_sList *list; +#define Z_ResultsByDB_s_all 1 +#define Z_ResultsByDB_s_list 2 + } u; + int *count; /* OPT */ + Z_InternationalString *resultSetName; /* OPT */ +}; + +struct Z_ResultsByDB { + int num; + Z_ResultsByDB_s **elements; +}; + +struct Z_QueryExpressionTerm { + Z_Term *queryTerm; + Z_InternationalString *termComment; /* OPT */ +}; + +struct Z_QueryExpression { + int which; + union { + Z_QueryExpressionTerm *term; + Z_Query *query; +#define Z_QueryExpression_term 1 +#define Z_QueryExpression_query 2 + } u; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/z-univ.h b/include/yaz/z-univ.h new file mode 100644 index 0000000..eccf5f1 --- /dev/null +++ b/include/yaz/z-univ.h @@ -0,0 +1,50 @@ +/* YC 0.2: Tue Feb 29 16:45:14 CET 2000 */ +/* Module-H ResourceReport-Format-Universe-1 */ + +#ifndef z_univ_H +#define z_univ_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_UniverseReportHits Z_UniverseReportHits; +YAZ_EXPORT int z_UniverseReportHits (ODR o, Z_UniverseReportHits **p, int opt, const char *name); + +typedef struct Z_UniverseReportDuplicate Z_UniverseReportDuplicate; +YAZ_EXPORT int z_UniverseReportDuplicate (ODR o, Z_UniverseReportDuplicate **p, int opt, const char *name); + +typedef struct Z_UniverseReport Z_UniverseReport; +YAZ_EXPORT int z_UniverseReport (ODR o, Z_UniverseReport **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_UniverseReportHits { + Z_StringOrNumeric *database; + Z_StringOrNumeric *hits; +}; + +struct Z_UniverseReportDuplicate { + Z_StringOrNumeric *hitno; +}; + +struct Z_UniverseReport { + int *totalHits; + int which; + union { + Z_UniverseReportHits *databaseHits; + Z_UniverseReportDuplicate *duplicate; +#define Z_UniverseReport_databaseHits 1 +#define Z_UniverseReport_duplicate 2 + } u; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/zes-expi.h b/include/yaz/zes-expi.h new file mode 100644 index 0000000..6b6d297 --- /dev/null +++ b/include/yaz/zes-expi.h @@ -0,0 +1,105 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ESFormat-ExportInvocation */ + +#ifndef zes_expi_H +#define zes_expi_H + +#include +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_EIExportInvocationEsRequest Z_EIExportInvocationEsRequest; +YAZ_EXPORT int z_EIExportInvocationEsRequest (ODR o, Z_EIExportInvocationEsRequest **p, int opt, const char *name); + +typedef struct Z_EIExportInvocationTaskPackage Z_EIExportInvocationTaskPackage; +YAZ_EXPORT int z_EIExportInvocationTaskPackage (ODR o, Z_EIExportInvocationTaskPackage **p, int opt, const char *name); + +typedef struct Z_EIExportInvocation Z_EIExportInvocation; +YAZ_EXPORT int z_EIExportInvocation (ODR o, Z_EIExportInvocation **p, int opt, const char *name); + +typedef struct Z_EIOriginPartToKeep Z_EIOriginPartToKeep; +YAZ_EXPORT int z_EIOriginPartToKeep (ODR o, Z_EIOriginPartToKeep **p, int opt, const char *name); + +typedef struct Z_EIOriginPartNotToKeepRanges_s Z_EIOriginPartNotToKeepRanges_s; +YAZ_EXPORT int z_EIOriginPartNotToKeepRanges_s (ODR o, Z_EIOriginPartNotToKeepRanges_s **p, int opt, const char *name); + +typedef struct Z_EIOriginPartNotToKeepRanges Z_EIOriginPartNotToKeepRanges; +YAZ_EXPORT int z_EIOriginPartNotToKeepRanges (ODR o, Z_EIOriginPartNotToKeepRanges **p, int opt, const char *name); + +typedef struct Z_EIOriginPartNotToKeep Z_EIOriginPartNotToKeep; +YAZ_EXPORT int z_EIOriginPartNotToKeep (ODR o, Z_EIOriginPartNotToKeep **p, int opt, const char *name); + +typedef struct Z_EITargetPart Z_EITargetPart; +YAZ_EXPORT int z_EITargetPart (ODR o, Z_EITargetPart **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_EIExportInvocationEsRequest { + Z_EIOriginPartToKeep *toKeep; + Z_EIOriginPartNotToKeep *notToKeep; +}; + +struct Z_EIExportInvocationTaskPackage { + Z_EIOriginPartToKeep *originPart; + Z_EITargetPart *targetPart; /* OPT */ +}; + +struct Z_EIExportInvocation { + int which; + union { + Z_EIExportInvocationEsRequest *esRequest; + Z_EIExportInvocationTaskPackage *taskPackage; +#define Z_EIExportInvocation_esRequest 1 +#define Z_EIExportInvocation_taskPackage 2 + } u; +}; + +struct Z_EIOriginPartToKeep { + int which; + union { + Z_InternationalString *packageName; + Z_ESExportSpecification *packageSpec; +#define Z_EIOriginPartToKeep_packageName 1 +#define Z_EIOriginPartToKeep_packageSpec 2 + } u; + int *numberOfCopies; +}; + +struct Z_EIOriginPartNotToKeepRanges_s { + int *start; + int *count; /* OPT */ +}; + +struct Z_EIOriginPartNotToKeepRanges { + int num; + Z_EIOriginPartNotToKeepRanges_s **elements; +}; + +struct Z_EIOriginPartNotToKeep { + Z_InternationalString *resultSetId; + int which; + union { + Odr_null *all; + Z_EIOriginPartNotToKeepRanges *ranges; +#define Z_EIOriginPartNotToKeep_all 1 +#define Z_EIOriginPartNotToKeep_ranges 2 + } u; +}; + +struct Z_EITargetPart { + Z_IntUnit *estimatedQuantity; /* OPT */ + Z_IntUnit *quantitySoFar; /* OPT */ + Z_IntUnit *estimatedCost; /* OPT */ + Z_IntUnit *costSoFar; /* OPT */ +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/zes-exps.h b/include/yaz/zes-exps.h new file mode 100644 index 0000000..9ee6330 --- /dev/null +++ b/include/yaz/zes-exps.h @@ -0,0 +1,93 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ESFormat-ExportSpecification */ + +#ifndef zes_exps_H +#define zes_exps_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_ESExportSpecificationEsRequest Z_ESExportSpecificationEsRequest; +YAZ_EXPORT int z_ESExportSpecificationEsRequest (ODR o, Z_ESExportSpecificationEsRequest **p, int opt, const char *name); + +typedef struct Z_ESExportSpecificationTaskPackage Z_ESExportSpecificationTaskPackage; +YAZ_EXPORT int z_ESExportSpecificationTaskPackage (ODR o, Z_ESExportSpecificationTaskPackage **p, int opt, const char *name); + +typedef struct Z_ESExportSpecification Z_ESExportSpecification; +YAZ_EXPORT int z_ESExportSpecification (ODR o, Z_ESExportSpecification **p, int opt, const char *name); + +typedef struct Z_ESOriginPartToKeep Z_ESOriginPartToKeep; +YAZ_EXPORT int z_ESOriginPartToKeep (ODR o, Z_ESOriginPartToKeep **p, int opt, const char *name); + +typedef struct Z_ESDestinationOther Z_ESDestinationOther; +YAZ_EXPORT int z_ESDestinationOther (ODR o, Z_ESDestinationOther **p, int opt, const char *name); + +typedef struct Z_ESDestination Z_ESDestination; +YAZ_EXPORT int z_ESDestination (ODR o, Z_ESDestination **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_ESExportSpecificationEsRequest { + Z_ESOriginPartToKeep *toKeep; + Odr_null *notToKeep; +}; + +struct Z_ESExportSpecificationTaskPackage { + Z_ESOriginPartToKeep *originPart; + Odr_null *targetPart; +}; + +struct Z_ESExportSpecification { + int which; + union { + Z_ESExportSpecificationEsRequest *esRequest; + Z_ESExportSpecificationTaskPackage *taskPackage; +#define Z_ESExportSpecification_esRequest 1 +#define Z_ESExportSpecification_taskPackage 2 + } u; +}; + +struct Z_ESOriginPartToKeep { + Z_CompSpec *composition; + Z_ESDestination *exportDestination; +}; + +struct Z_ESDestinationOther { + Z_InternationalString *vehicle; /* OPT */ + Z_InternationalString *destination; +}; + +struct Z_ESDestination { + int which; + union { + Z_InternationalString *phoneNumber; + Z_InternationalString *faxNumber; + Z_InternationalString *x400address; + Z_InternationalString *emailAddress; + Z_InternationalString *pagerNumber; + Z_InternationalString *ftpAddress; + Z_InternationalString *ftamAddress; + Z_InternationalString *printerAddress; + Z_ESDestinationOther *other; +#define Z_ESDestination_phoneNumber 1 +#define Z_ESDestination_faxNumber 2 +#define Z_ESDestination_x400address 3 +#define Z_ESDestination_emailAddress 4 +#define Z_ESDestination_pagerNumber 5 +#define Z_ESDestination_ftpAddress 6 +#define Z_ESDestination_ftamAddress 7 +#define Z_ESDestination_printerAddress 8 +#define Z_ESDestination_other 9 + } u; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/zes-order.h b/include/yaz/zes-order.h new file mode 100644 index 0000000..03b8f77 --- /dev/null +++ b/include/yaz/zes-order.h @@ -0,0 +1,132 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ESFormat-ItemOrder */ + +#ifndef zes_order_H +#define zes_order_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_IORequest Z_IORequest; +YAZ_EXPORT int z_IORequest (ODR o, Z_IORequest **p, int opt, const char *name); + +typedef struct Z_IOTaskPackage Z_IOTaskPackage; +YAZ_EXPORT int z_IOTaskPackage (ODR o, Z_IOTaskPackage **p, int opt, const char *name); + +typedef struct Z_IOItemOrder Z_IOItemOrder; +YAZ_EXPORT int z_IOItemOrder (ODR o, Z_IOItemOrder **p, int opt, const char *name); + +typedef struct Z_IOContact Z_IOContact; +YAZ_EXPORT int z_IOContact (ODR o, Z_IOContact **p, int opt, const char *name); + +typedef struct Z_IOBilling Z_IOBilling; +YAZ_EXPORT int z_IOBilling (ODR o, Z_IOBilling **p, int opt, const char *name); + +typedef struct Z_IOOriginPartToKeep Z_IOOriginPartToKeep; +YAZ_EXPORT int z_IOOriginPartToKeep (ODR o, Z_IOOriginPartToKeep **p, int opt, const char *name); + +typedef struct Z_IOCreditCardInfo Z_IOCreditCardInfo; +YAZ_EXPORT int z_IOCreditCardInfo (ODR o, Z_IOCreditCardInfo **p, int opt, const char *name); + +typedef struct Z_IOResultSetItem Z_IOResultSetItem; +YAZ_EXPORT int z_IOResultSetItem (ODR o, Z_IOResultSetItem **p, int opt, const char *name); + +typedef struct Z_IOOriginPartNotToKeep Z_IOOriginPartNotToKeep; +YAZ_EXPORT int z_IOOriginPartNotToKeep (ODR o, Z_IOOriginPartNotToKeep **p, int opt, const char *name); + +typedef struct Z_IOTargetPart Z_IOTargetPart; +YAZ_EXPORT int z_IOTargetPart (ODR o, Z_IOTargetPart **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_IORequest { + Z_IOOriginPartToKeep *toKeep; /* OPT */ + Z_IOOriginPartNotToKeep *notToKeep; +}; + +struct Z_IOTaskPackage { + Z_IOOriginPartToKeep *originPart; /* OPT */ + Z_IOTargetPart *targetPart; +}; + +struct Z_IOItemOrder { + int which; + union { + Z_IORequest *esRequest; + Z_IOTaskPackage *taskPackage; +#define Z_IOItemOrder_esRequest 1 +#define Z_IOItemOrder_taskPackage 2 + } u; +}; + +struct Z_IOContact { + Z_InternationalString *name; /* OPT */ + Z_InternationalString *phone; /* OPT */ + Z_InternationalString *email; /* OPT */ +}; + +struct Z_IOBilling { + int which; + union { + Odr_null *billInvoice; + Odr_null *prepay; + Odr_null *depositAccount; + Z_IOCreditCardInfo *creditCard; + Odr_null *cardInfoPreviouslySupplied; + Odr_null *privateKnown; + Z_External *privateNotKnown; +#define Z_IOBilling_billInvoice 1 +#define Z_IOBilling_prepay 2 +#define Z_IOBilling_depositAccount 3 +#define Z_IOBilling_creditCard 4 +#define Z_IOBilling_cardInfoPreviouslySupplied 5 +#define Z_IOBilling_privateKnown 6 +#define Z_IOBilling_privateNotKnown 7 + } u; + Z_InternationalString *customerReference; /* OPT */ + Z_InternationalString *customerPONumber; /* OPT */ +}; + +struct Z_IOOriginPartToKeep { + Z_External *supplDescription; /* OPT */ + Z_IOContact *contact; /* OPT */ + Z_IOBilling *addlBilling; /* OPT */ +}; + +struct Z_IOCreditCardInfo { + Z_InternationalString *nameOnCard; + Z_InternationalString *expirationDate; + Z_InternationalString *cardNumber; +}; + +struct Z_IOResultSetItem { + Z_InternationalString *resultSetId; + int *item; +}; + +struct Z_IOOriginPartNotToKeep { + Z_IOResultSetItem *resultSetItem; /* OPT */ + Z_External *itemRequest; /* OPT */ +}; + +struct Z_IOTargetPart { + Z_External *itemRequest; /* OPT */ + Z_External *statusOrErrorReport; /* OPT */ +#define Z_IOTargetPart_notReceived 1 +#define Z_IOTargetPart_loanQueue 2 +#define Z_IOTargetPart_forwarded 3 +#define Z_IOTargetPart_unfilledCopyright 4 +#define Z_IOTargetPart_filledCopyright 5 + int *auxiliaryStatus; /* OPT */ +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/zes-pquery.h b/include/yaz/zes-pquery.h new file mode 100644 index 0000000..4607256 --- /dev/null +++ b/include/yaz/zes-pquery.h @@ -0,0 +1,77 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ESFormat-PersistentQuery */ + +#ifndef zes_pquery_H +#define zes_pquery_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_PQueryPersistentQueryEsRequest Z_PQueryPersistentQueryEsRequest; +YAZ_EXPORT int z_PQueryPersistentQueryEsRequest (ODR o, Z_PQueryPersistentQueryEsRequest **p, int opt, const char *name); + +typedef struct Z_PQueryPersistentQueryTaskPackage Z_PQueryPersistentQueryTaskPackage; +YAZ_EXPORT int z_PQueryPersistentQueryTaskPackage (ODR o, Z_PQueryPersistentQueryTaskPackage **p, int opt, const char *name); + +typedef struct Z_PQueryPersistentQuery Z_PQueryPersistentQuery; +YAZ_EXPORT int z_PQueryPersistentQuery (ODR o, Z_PQueryPersistentQuery **p, int opt, const char *name); + +typedef struct Z_PQueryOriginPartToKeep Z_PQueryOriginPartToKeep; +YAZ_EXPORT int z_PQueryOriginPartToKeep (ODR o, Z_PQueryOriginPartToKeep **p, int opt, const char *name); + +typedef struct Z_PQueryOriginPartNotToKeep Z_PQueryOriginPartNotToKeep; +YAZ_EXPORT int z_PQueryOriginPartNotToKeep (ODR o, Z_PQueryOriginPartNotToKeep **p, int opt, const char *name); + +typedef Z_Query Z_PQueryTargetPart; +YAZ_EXPORT int z_PQueryTargetPart (ODR o, Z_PQueryTargetPart **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_PQueryPersistentQueryEsRequest { + Z_PQueryOriginPartToKeep *toKeep; /* OPT */ + Z_PQueryOriginPartNotToKeep *notToKeep; +}; + +struct Z_PQueryPersistentQueryTaskPackage { + Z_PQueryOriginPartToKeep *originPart; /* OPT */ + Z_PQueryTargetPart *targetPart; +}; + +struct Z_PQueryPersistentQuery { + int which; + union { + Z_PQueryPersistentQueryEsRequest *esRequest; + Z_PQueryPersistentQueryTaskPackage *taskPackage; +#define Z_PQueryPersistentQuery_esRequest 1 +#define Z_PQueryPersistentQuery_taskPackage 2 + } u; +}; + +struct Z_PQueryOriginPartToKeep { + int num_dbNames; + Z_InternationalString **dbNames; /* OPT */ + Z_OtherInformation *additionalSearchInfo; /* OPT */ +}; + +struct Z_PQueryOriginPartNotToKeep { + int which; + union { + Z_InternationalString *package; + Z_Query *query; +#define Z_PQueryOriginPartNotToKeep_package 1 +#define Z_PQueryOriginPartNotToKeep_query 2 + } u; +}; + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/zes-psched.h b/include/yaz/zes-psched.h new file mode 100644 index 0000000..c82d854 --- /dev/null +++ b/include/yaz/zes-psched.h @@ -0,0 +1,118 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ESFormat-PeriodicQuerySchedule */ + +#ifndef zes_psched_H +#define zes_psched_H + +#include +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_PQSPeriodicQueryScheduleEsRequest Z_PQSPeriodicQueryScheduleEsRequest; +YAZ_EXPORT int z_PQSPeriodicQueryScheduleEsRequest (ODR o, Z_PQSPeriodicQueryScheduleEsRequest **p, int opt, const char *name); + +typedef struct Z_PQSPeriodicQueryScheduleTaskPackage Z_PQSPeriodicQueryScheduleTaskPackage; +YAZ_EXPORT int z_PQSPeriodicQueryScheduleTaskPackage (ODR o, Z_PQSPeriodicQueryScheduleTaskPackage **p, int opt, const char *name); + +typedef struct Z_PQSPeriodicQuerySchedule Z_PQSPeriodicQuerySchedule; +YAZ_EXPORT int z_PQSPeriodicQuerySchedule (ODR o, Z_PQSPeriodicQuerySchedule **p, int opt, const char *name); + +typedef struct Z_PQSOriginPartToKeep Z_PQSOriginPartToKeep; +YAZ_EXPORT int z_PQSOriginPartToKeep (ODR o, Z_PQSOriginPartToKeep **p, int opt, const char *name); + +typedef struct Z_PQSOriginPartNotToKeep Z_PQSOriginPartNotToKeep; +YAZ_EXPORT int z_PQSOriginPartNotToKeep (ODR o, Z_PQSOriginPartNotToKeep **p, int opt, const char *name); + +typedef struct Z_PQSTargetPart Z_PQSTargetPart; +YAZ_EXPORT int z_PQSTargetPart (ODR o, Z_PQSTargetPart **p, int opt, const char *name); + +typedef struct Z_PQSPeriod Z_PQSPeriod; +YAZ_EXPORT int z_PQSPeriod (ODR o, Z_PQSPeriod **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_PQSPeriodicQueryScheduleEsRequest { + Z_PQSOriginPartToKeep *toKeep; + Z_PQSOriginPartNotToKeep *notToKeep; +}; + +struct Z_PQSPeriodicQueryScheduleTaskPackage { + Z_PQSOriginPartToKeep *originPart; + Z_PQSTargetPart *targetPart; +}; + +struct Z_PQSPeriodicQuerySchedule { + int which; + union { + Z_PQSPeriodicQueryScheduleEsRequest *esRequest; + Z_PQSPeriodicQueryScheduleTaskPackage *taskPackage; +#define Z_PQSPeriodicQuerySchedule_esRequest 1 +#define Z_PQSPeriodicQuerySchedule_taskPackage 2 + } u; +}; + +struct Z_PQSOriginPartToKeep { + bool_t *activeFlag; + int num_databaseNames; + Z_InternationalString **databaseNames; /* OPT */ +#define Z_PQSOriginPartToKeep_replace 1 +#define Z_PQSOriginPartToKeep_append 2 +#define Z_PQSOriginPartToKeep_createNew 3 + int *resultSetDisposition; /* OPT */ + Z_ESDestination *alertDestination; /* OPT */ + int which; + union { + Z_InternationalString *packageName; + Z_ESExportSpecification *exportPackage; +#define Z_PQSOriginPartToKeep_packageName 1 +#define Z_PQSOriginPartToKeep_exportPackage 2 + } u; /* OPT */ +}; + +struct Z_PQSOriginPartNotToKeep { + int which; + union { + Z_Query *actualQuery; + Z_InternationalString *packageName; +#define Z_PQSOriginPartNotToKeep_actualQuery 1 +#define Z_PQSOriginPartNotToKeep_packageName 2 + } u; /* OPT */ + Z_PQSPeriod *originSuggestedPeriod; /* OPT */ + char *expiration; /* OPT */ + Z_InternationalString *resultSetPackage; /* OPT */ +}; + +struct Z_PQSTargetPart { + Z_Query *actualQuery; + Z_PQSPeriod *targetStatedPeriod; + char *expiration; /* OPT */ + Z_InternationalString *resultSetPackage; /* OPT */ + char *lastQueryTime; + int *lastResultNumber; + int *numberSinceModify; /* OPT */ +}; + +struct Z_PQSPeriod { + int which; + union { + Z_IntUnit *unit; + Odr_null *businessDaily; + Odr_null *continuous; + Z_InternationalString *other; +#define Z_PQSPeriod_unit 1 +#define Z_PQSPeriod_businessDaily 2 +#define Z_PQSPeriod_continuous 3 +#define Z_PQSPeriod_other 4 + } u; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/zes-pset.h b/include/yaz/zes-pset.h new file mode 100644 index 0000000..11c890e --- /dev/null +++ b/include/yaz/zes-pset.h @@ -0,0 +1,68 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ESFormat-PersistentResultSet */ + +#ifndef zes_pset_H +#define zes_pset_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_PRPersistentResultSetEsRequest Z_PRPersistentResultSetEsRequest; +YAZ_EXPORT int z_PRPersistentResultSetEsRequest (ODR o, Z_PRPersistentResultSetEsRequest **p, int opt, const char *name); + +typedef struct Z_PRPersistentResultSetTaskPackage Z_PRPersistentResultSetTaskPackage; +YAZ_EXPORT int z_PRPersistentResultSetTaskPackage (ODR o, Z_PRPersistentResultSetTaskPackage **p, int opt, const char *name); + +typedef struct Z_PRPersistentResultSet Z_PRPersistentResultSet; +YAZ_EXPORT int z_PRPersistentResultSet (ODR o, Z_PRPersistentResultSet **p, int opt, const char *name); + +typedef struct Z_PROriginPartNotToKeep Z_PROriginPartNotToKeep; +YAZ_EXPORT int z_PROriginPartNotToKeep (ODR o, Z_PROriginPartNotToKeep **p, int opt, const char *name); + +typedef struct Z_PRTargetPart Z_PRTargetPart; +YAZ_EXPORT int z_PRTargetPart (ODR o, Z_PRTargetPart **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_PRPersistentResultSetEsRequest { + Odr_null *toKeep; + Z_PROriginPartNotToKeep *notToKeep; /* OPT */ +}; + +struct Z_PRPersistentResultSetTaskPackage { + Odr_null *originPart; + Z_PRTargetPart *targetPart; /* OPT */ +}; + +struct Z_PRPersistentResultSet { + int which; + union { + Z_PRPersistentResultSetEsRequest *esRequest; + Z_PRPersistentResultSetTaskPackage *taskPackage; +#define Z_PRPersistentResultSet_esRequest 1 +#define Z_PRPersistentResultSet_taskPackage 2 + } u; +}; + +struct Z_PROriginPartNotToKeep { + Z_InternationalString *originSuppliedResultSet; /* OPT */ +#define Z_PROriginPartNotToKeep_replace 1 +#define Z_PROriginPartNotToKeep_append 2 + int *replaceOrAppend; /* OPT */ +}; + +struct Z_PRTargetPart { + Z_InternationalString *targetSuppliedResultSet; /* OPT */ + int *numberOfRecords; /* OPT */ +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/zes-update.h b/include/yaz/zes-update.h new file mode 100644 index 0000000..fc66b35 --- /dev/null +++ b/include/yaz/zes-update.h @@ -0,0 +1,163 @@ +/* YC 0.2: Tue Feb 29 15:20:49 CET 2000 */ +/* Module-H ESFormat-Update */ + +#ifndef zes_update_H +#define zes_update_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_IUUpdateEsRequest Z_IUUpdateEsRequest; +YAZ_EXPORT int z_IUUpdateEsRequest (ODR o, Z_IUUpdateEsRequest **p, int opt, const char *name); + +typedef struct Z_IUUpdateTaskPackage Z_IUUpdateTaskPackage; +YAZ_EXPORT int z_IUUpdateTaskPackage (ODR o, Z_IUUpdateTaskPackage **p, int opt, const char *name); + +typedef struct Z_IUUpdate Z_IUUpdate; +YAZ_EXPORT int z_IUUpdate (ODR o, Z_IUUpdate **p, int opt, const char *name); + +typedef struct Z_IUOriginPartToKeep Z_IUOriginPartToKeep; +YAZ_EXPORT int z_IUOriginPartToKeep (ODR o, Z_IUOriginPartToKeep **p, int opt, const char *name); + +typedef struct Z_IUTargetPart Z_IUTargetPart; +YAZ_EXPORT int z_IUTargetPart (ODR o, Z_IUTargetPart **p, int opt, const char *name); + +typedef struct Z_IUSuppliedRecordsId Z_IUSuppliedRecordsId; +YAZ_EXPORT int z_IUSuppliedRecordsId (ODR o, Z_IUSuppliedRecordsId **p, int opt, const char *name); + +typedef struct Z_IUSuppliedRecords_elem Z_IUSuppliedRecords_elem; +YAZ_EXPORT int z_IUSuppliedRecords_elem (ODR o, Z_IUSuppliedRecords_elem **p, int opt, const char *name); + +typedef struct Z_IUSuppliedRecords Z_IUSuppliedRecords; +YAZ_EXPORT int z_IUSuppliedRecords (ODR o, Z_IUSuppliedRecords **p, int opt, const char *name); + +typedef Z_IUSuppliedRecords Z_IUOriginPartNotToKeep; +YAZ_EXPORT int z_IUOriginPartNotToKeep (ODR o, Z_IUOriginPartNotToKeep **p, int opt, const char *name); + +typedef struct Z_IUCorrelationInfo Z_IUCorrelationInfo; +YAZ_EXPORT int z_IUCorrelationInfo (ODR o, Z_IUCorrelationInfo **p, int opt, const char *name); + +typedef struct Z_IUTaskPackageRecordStructureSurrogateDiagnostics Z_IUTaskPackageRecordStructureSurrogateDiagnostics; +YAZ_EXPORT int z_IUTaskPackageRecordStructureSurrogateDiagnostics (ODR o, Z_IUTaskPackageRecordStructureSurrogateDiagnostics **p, int opt, const char *name); + +typedef struct Z_IUTaskPackageRecordStructure Z_IUTaskPackageRecordStructure; +YAZ_EXPORT int z_IUTaskPackageRecordStructure (ODR o, Z_IUTaskPackageRecordStructure **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_IUUpdateEsRequest { + Z_IUOriginPartToKeep *toKeep; + Z_IUOriginPartNotToKeep *notToKeep; +}; + +struct Z_IUUpdateTaskPackage { + Z_IUOriginPartToKeep *originPart; + Z_IUTargetPart *targetPart; +}; + +struct Z_IUUpdate { + int which; + union { + Z_IUUpdateEsRequest *esRequest; + Z_IUUpdateTaskPackage *taskPackage; +#define Z_IUUpdate_esRequest 1 +#define Z_IUUpdate_taskPackage 2 + } u; +}; + +struct Z_IUOriginPartToKeep { +#define Z_IUOriginPartToKeep_recordInsert 1 +#define Z_IUOriginPartToKeep_recordReplace 2 +#define Z_IUOriginPartToKeep_recordDelete 3 +#define Z_IUOriginPartToKeep_elementUpdate 4 +#define Z_IUOriginPartToKeep_specialUpdate 5 + int *action; + Z_InternationalString *databaseName; + Odr_oid *schema; /* OPT */ + Z_InternationalString *elementSetName; /* OPT */ + Z_External *actionQualifier; /* OPT */ +}; + + + +struct Z_IUTargetPart { +#define Z_IUTargetPart_success 1 +#define Z_IUTargetPart_partial 2 +#define Z_IUTargetPart_failure 3 + int *updateStatus; + int num_globalDiagnostics; + Z_DiagRec **globalDiagnostics; /* OPT */ + int num_taskPackageRecords; + Z_IUTaskPackageRecordStructure **taskPackageRecords; +}; + +struct Z_IUSuppliedRecordsId { + int which; + union { + char *timeStamp; + Z_InternationalString *versionNumber; + Z_External *previousVersion; +#define Z_IUSuppliedRecordsId_timeStamp 1 +#define Z_IUSuppliedRecordsId_versionNumber 2 +#define Z_IUSuppliedRecordsId_previousVersion 3 + } u; +}; + +struct Z_IUSuppliedRecords_elem { + int which; + union { + int *number; + Z_InternationalString *string; + Odr_oct *opaque; +#define Z_IUSuppliedRecords_elem_number 1 +#define Z_IUSuppliedRecords_elem_string 2 +#define Z_IUSuppliedRecords_elem_opaque 3 + } u; /* OPT */ + Z_IUSuppliedRecordsId *supplementalId; /* OPT */ + Z_IUCorrelationInfo *correlationInfo; /* OPT */ + Z_External *record; +}; + +struct Z_IUSuppliedRecords { + int num; + Z_IUSuppliedRecords_elem **elements; +}; + +struct Z_IUCorrelationInfo { + Z_InternationalString *note; /* OPT */ + int *id; /* OPT */ +}; + +struct Z_IUTaskPackageRecordStructureSurrogateDiagnostics { + int num; + Z_DiagRec **elements; +}; + +struct Z_IUTaskPackageRecordStructure { + int which; + union { + Z_External *record; + Z_IUTaskPackageRecordStructureSurrogateDiagnostics *surrogateDiagnostics; +#define Z_IUTaskPackageRecordStructure_record 1 +#define Z_IUTaskPackageRecordStructure_surrogateDiagnostics 2 + } u; /* OPT */ + Z_IUCorrelationInfo *correlationInfo; /* OPT */ +#define Z_IUTaskPackageRecordStructure_success 1 +#define Z_IUTaskPackageRecordStructure_queued 2 +#define Z_IUTaskPackageRecordStructure_inProcess 3 +#define Z_IUTaskPackageRecordStructure_failure 4 + int *recordStatus; + int num_supplementalDiagnostics; + Z_DiagRec **supplementalDiagnostics; /* OPT */ +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/include/yaz/zes-update0.h b/include/yaz/zes-update0.h new file mode 100644 index 0000000..e86a065 --- /dev/null +++ b/include/yaz/zes-update0.h @@ -0,0 +1,151 @@ +/* YC 0.2: Tue Feb 29 16:45:07 CET 2000 */ +/* Module-H ESFormat-Update0 */ + +#ifndef zes_update0_H +#define zes_update0_H + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct Z_IU0UpdateEsRequest Z_IU0UpdateEsRequest; +YAZ_EXPORT int z_IU0UpdateEsRequest (ODR o, Z_IU0UpdateEsRequest **p, int opt, const char *name); + +typedef struct Z_IU0UpdateTaskPackage Z_IU0UpdateTaskPackage; +YAZ_EXPORT int z_IU0UpdateTaskPackage (ODR o, Z_IU0UpdateTaskPackage **p, int opt, const char *name); + +typedef struct Z_IU0Update Z_IU0Update; +YAZ_EXPORT int z_IU0Update (ODR o, Z_IU0Update **p, int opt, const char *name); + +typedef struct Z_IU0OriginPartToKeep Z_IU0OriginPartToKeep; +YAZ_EXPORT int z_IU0OriginPartToKeep (ODR o, Z_IU0OriginPartToKeep **p, int opt, const char *name); + +typedef struct Z_IU0TargetPart Z_IU0TargetPart; +YAZ_EXPORT int z_IU0TargetPart (ODR o, Z_IU0TargetPart **p, int opt, const char *name); + +typedef struct Z_IU0SuppliedRecordsId Z_IU0SuppliedRecordsId; +YAZ_EXPORT int z_IU0SuppliedRecordsId (ODR o, Z_IU0SuppliedRecordsId **p, int opt, const char *name); + +typedef struct Z_IU0SuppliedRecords_elem Z_IU0SuppliedRecords_elem; +YAZ_EXPORT int z_IU0SuppliedRecords_elem (ODR o, Z_IU0SuppliedRecords_elem **p, int opt, const char *name); + +typedef struct Z_IU0SuppliedRecords Z_IU0SuppliedRecords; +YAZ_EXPORT int z_IU0SuppliedRecords (ODR o, Z_IU0SuppliedRecords **p, int opt, const char *name); + +typedef Z_IU0SuppliedRecords Z_IU0OriginPartNotToKeep; +YAZ_EXPORT int z_IU0OriginPartNotToKeep (ODR o, Z_IU0OriginPartNotToKeep **p, int opt, const char *name); + +typedef struct Z_IU0CorrelationInfo Z_IU0CorrelationInfo; +YAZ_EXPORT int z_IU0CorrelationInfo (ODR o, Z_IU0CorrelationInfo **p, int opt, const char *name); + +typedef struct Z_IU0TaskPackageRecordStructure Z_IU0TaskPackageRecordStructure; +YAZ_EXPORT int z_IU0TaskPackageRecordStructure (ODR o, Z_IU0TaskPackageRecordStructure **p, int opt, const char *name); +#ifdef __cplusplus +} +#endif +#ifdef __cplusplus +extern "C" { +#endif +struct Z_IU0UpdateEsRequest { + Z_IU0OriginPartToKeep *toKeep; + Z_IU0OriginPartNotToKeep *notToKeep; +}; + +struct Z_IU0UpdateTaskPackage { + Z_IU0OriginPartToKeep *originPart; + Z_IU0TargetPart *targetPart; +}; + +struct Z_IU0Update { + int which; + union { + Z_IU0UpdateEsRequest *esRequest; + Z_IU0UpdateTaskPackage *taskPackage; +#define Z_IU0Update_esRequest 1 +#define Z_IU0Update_taskPackage 2 + } u; +}; + +struct Z_IU0OriginPartToKeep { +#define Z_IU0OriginPartToKeep_recordInsert 1 +#define Z_IU0OriginPartToKeep_recordReplace 2 +#define Z_IU0OriginPartToKeep_recordDelete 3 +#define Z_IU0OriginPartToKeep_elementUpdate 4 + int *action; + Z_InternationalString *databaseName; + Odr_oid *schema; /* OPT */ + Z_InternationalString *elementSetName; /* OPT */ +}; + + + +struct Z_IU0TargetPart { +#define Z_IU0TargetPart_success 1 +#define Z_IU0TargetPart_partial 2 +#define Z_IU0TargetPart_failure 3 + int *updateStatus; + int num_globalDiagnostics; + Z_DiagRec **globalDiagnostics; /* OPT */ + int num_taskPackageRecords; + Z_IU0TaskPackageRecordStructure **taskPackageRecords; +}; + +struct Z_IU0SuppliedRecordsId { + int which; + union { + char *timeStamp; + Z_InternationalString *versionNumber; + Z_External *previousVersion; +#define Z_IU0SuppliedRecordsId_timeStamp 1 +#define Z_IU0SuppliedRecordsId_versionNumber 2 +#define Z_IU0SuppliedRecordsId_previousVersion 3 + } u; +}; + +struct Z_IU0SuppliedRecords_elem { + int which; + union { + int *number; + Z_InternationalString *string; + Odr_oct *opaque; +#define Z_IU0SuppliedRecords_elem_number 1 +#define Z_IU0SuppliedRecords_elem_string 2 +#define Z_IU0SuppliedRecords_elem_opaque 3 + } u; /* OPT */ + Z_IU0SuppliedRecordsId *supplementalId; /* OPT */ + Z_IU0CorrelationInfo *correlationInfo; /* OPT */ + Z_External *record; +}; + +struct Z_IU0SuppliedRecords { + int num; + Z_IU0SuppliedRecords_elem **elements; +}; + +struct Z_IU0CorrelationInfo { + Z_InternationalString *note; /* OPT */ + int *id; /* OPT */ +}; + +struct Z_IU0TaskPackageRecordStructure { + int which; + union { + Z_External *record; + Z_DiagRec *diagnostic; +#define Z_IU0TaskPackageRecordStructure_record 1 +#define Z_IU0TaskPackageRecordStructure_diagnostic 2 + } u; /* OPT */ + Z_IU0CorrelationInfo *correlationInfo; /* OPT */ +#define Z_IU0TaskPackageRecordStructure_success 1 +#define Z_IU0TaskPackageRecordStructure_queued 2 +#define Z_IU0TaskPackageRecordStructure_inProcess 3 +#define Z_IU0TaskPackageRecordStructure_failure 4 + int *recordStatus; +}; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/z39.50/zes-expi.c b/z39.50/zes-expi.c new file mode 100644 index 0000000..430f909 --- /dev/null +++ b/z39.50/zes-expi.c @@ -0,0 +1,124 @@ +/* YC 0.2 Tue Feb 29 16:45:07 CET 2000 */ +/* Module-C: ESFormat-ExportInvocation */ + +#include + +int z_EIExportInvocationEsRequest (ODR o, Z_EIExportInvocationEsRequest **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_EIOriginPartToKeep, + &(*p)->toKeep, ODR_CONTEXT, 1, 0, "toKeep") && + odr_explicit_tag (o, z_EIOriginPartNotToKeep, + &(*p)->notToKeep, ODR_CONTEXT, 2, 0, "notToKeep") && + odr_sequence_end (o); +} + +int z_EIExportInvocationTaskPackage (ODR o, Z_EIExportInvocationTaskPackage **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_EIOriginPartToKeep, + &(*p)->originPart, ODR_CONTEXT, 1, 0, "originPart") && + odr_explicit_tag (o, z_EITargetPart, + &(*p)->targetPart, ODR_CONTEXT, 2, 1, "targetPart") && + odr_sequence_end (o); +} + +int z_EIExportInvocation (ODR o, Z_EIExportInvocation **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_EIExportInvocation_esRequest, + (Odr_fun) z_EIExportInvocationEsRequest, "esRequest"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_EIExportInvocation_taskPackage, + (Odr_fun) z_EIExportInvocationTaskPackage, "taskPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_EIOriginPartToKeep (ODR o, Z_EIOriginPartToKeep **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_EIOriginPartToKeep_packageName, + (Odr_fun) z_InternationalString, "packageName"}, + {ODR_EXPLICIT, ODR_CONTEXT, 2, Z_EIOriginPartToKeep_packageSpec, + (Odr_fun) z_ESExportSpecification, "packageSpec"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 1, "exportSpec") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o) && + odr_implicit_tag (o, odr_integer, + &(*p)->numberOfCopies, ODR_CONTEXT, 2, 0, "numberOfCopies") && + odr_sequence_end (o); +} + +int z_EIOriginPartNotToKeepRanges_s (ODR o, Z_EIOriginPartNotToKeepRanges_s **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, odr_integer, + &(*p)->start, ODR_CONTEXT, 1, 0, "start") && + odr_implicit_tag (o, odr_integer, + &(*p)->count, ODR_CONTEXT, 2, 1, "count") && + odr_sequence_end (o); +} + +int z_EIOriginPartNotToKeepRanges (ODR o, Z_EIOriginPartNotToKeepRanges **p, int opt, const char *name) +{ + if (!odr_initmember (o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_sequence_of (o, (Odr_fun) z_EIOriginPartNotToKeepRanges_s, &(*p)->elements, + &(*p)->num, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_EIOriginPartNotToKeep (ODR o, Z_EIOriginPartNotToKeep **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_EIOriginPartNotToKeep_all, + (Odr_fun) odr_null, "all"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_EIOriginPartNotToKeep_ranges, + (Odr_fun) z_EIOriginPartNotToKeepRanges, "ranges"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->resultSetId, ODR_CONTEXT, 1, 0, "resultSetId") && + odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 2, "records") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o) && + odr_sequence_end (o); +} + +int z_EITargetPart (ODR o, Z_EITargetPart **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_IntUnit, + &(*p)->estimatedQuantity, ODR_CONTEXT, 1, 1, "estimatedQuantity") && + odr_implicit_tag (o, z_IntUnit, + &(*p)->quantitySoFar, ODR_CONTEXT, 2, 1, "quantitySoFar") && + odr_implicit_tag (o, z_IntUnit, + &(*p)->estimatedCost, ODR_CONTEXT, 3, 1, "estimatedCost") && + odr_implicit_tag (o, z_IntUnit, + &(*p)->costSoFar, ODR_CONTEXT, 4, 1, "costSoFar") && + odr_sequence_end (o); +} diff --git a/z39.50/zes-exps.c b/z39.50/zes-exps.c new file mode 100644 index 0000000..4da0edf --- /dev/null +++ b/z39.50/zes-exps.c @@ -0,0 +1,100 @@ +/* YC 0.2 Tue Feb 29 16:45:07 CET 2000 */ +/* Module-C: ESFormat-ExportSpecification */ + +#include + +int z_ESExportSpecificationEsRequest (ODR o, Z_ESExportSpecificationEsRequest **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_ESOriginPartToKeep, + &(*p)->toKeep, ODR_CONTEXT, 1, 0, "toKeep") && + odr_implicit_tag (o, odr_null, + &(*p)->notToKeep, ODR_CONTEXT, 2, 0, "notToKeep") && + odr_sequence_end (o); +} + +int z_ESExportSpecificationTaskPackage (ODR o, Z_ESExportSpecificationTaskPackage **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_ESOriginPartToKeep, + &(*p)->originPart, ODR_CONTEXT, 1, 0, "originPart") && + odr_implicit_tag (o, odr_null, + &(*p)->targetPart, ODR_CONTEXT, 2, 0, "targetPart") && + odr_sequence_end (o); +} + +int z_ESExportSpecification (ODR o, Z_ESExportSpecification **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_ESExportSpecification_esRequest, + (Odr_fun) z_ESExportSpecificationEsRequest, "esRequest"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_ESExportSpecification_taskPackage, + (Odr_fun) z_ESExportSpecificationTaskPackage, "taskPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_ESOriginPartToKeep (ODR o, Z_ESOriginPartToKeep **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_CompSpec, + &(*p)->composition, ODR_CONTEXT, 1, 0, "composition") && + odr_explicit_tag (o, z_ESDestination, + &(*p)->exportDestination, ODR_CONTEXT, 2, 0, "exportDestination") && + odr_sequence_end (o); +} + +int z_ESDestinationOther (ODR o, Z_ESDestinationOther **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->vehicle, ODR_CONTEXT, 1, 1, "vehicle") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->destination, ODR_CONTEXT, 2, 0, "destination") && + odr_sequence_end (o); +} + +int z_ESDestination (ODR o, Z_ESDestination **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_ESDestination_phoneNumber, + (Odr_fun) z_InternationalString, "phoneNumber"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_ESDestination_faxNumber, + (Odr_fun) z_InternationalString, "faxNumber"}, + {ODR_IMPLICIT, ODR_CONTEXT, 3, Z_ESDestination_x400address, + (Odr_fun) z_InternationalString, "x400address"}, + {ODR_IMPLICIT, ODR_CONTEXT, 4, Z_ESDestination_emailAddress, + (Odr_fun) z_InternationalString, "emailAddress"}, + {ODR_IMPLICIT, ODR_CONTEXT, 5, Z_ESDestination_pagerNumber, + (Odr_fun) z_InternationalString, "pagerNumber"}, + {ODR_IMPLICIT, ODR_CONTEXT, 6, Z_ESDestination_ftpAddress, + (Odr_fun) z_InternationalString, "ftpAddress"}, + {ODR_IMPLICIT, ODR_CONTEXT, 7, Z_ESDestination_ftamAddress, + (Odr_fun) z_InternationalString, "ftamAddress"}, + {ODR_IMPLICIT, ODR_CONTEXT, 8, Z_ESDestination_printerAddress, + (Odr_fun) z_InternationalString, "printerAddress"}, + {ODR_IMPLICIT, ODR_CONTEXT, 100, Z_ESDestination_other, + (Odr_fun) z_ESDestinationOther, "other"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} diff --git a/z39.50/zes-order.c b/z39.50/zes-order.c new file mode 100644 index 0000000..9a2e9d8 --- /dev/null +++ b/z39.50/zes-order.c @@ -0,0 +1,157 @@ +/* YC 0.2 Tue Feb 29 16:45:07 CET 2000 */ +/* Module-C: ESFormat-ItemOrder */ + +#include + +int z_IORequest (ODR o, Z_IORequest **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_IOOriginPartToKeep, + &(*p)->toKeep, ODR_CONTEXT, 1, 1, "toKeep") && + odr_explicit_tag (o, z_IOOriginPartNotToKeep, + &(*p)->notToKeep, ODR_CONTEXT, 2, 0, "notToKeep") && + odr_sequence_end (o); +} + +int z_IOTaskPackage (ODR o, Z_IOTaskPackage **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_IOOriginPartToKeep, + &(*p)->originPart, ODR_CONTEXT, 1, 1, "originPart") && + odr_explicit_tag (o, z_IOTargetPart, + &(*p)->targetPart, ODR_CONTEXT, 2, 0, "targetPart") && + odr_sequence_end (o); +} + +int z_IOItemOrder (ODR o, Z_IOItemOrder **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IOItemOrder_esRequest, + (Odr_fun) z_IORequest, "esRequest"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IOItemOrder_taskPackage, + (Odr_fun) z_IOTaskPackage, "taskPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_IOContact (ODR o, Z_IOContact **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->name, ODR_CONTEXT, 1, 1, "name") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->phone, ODR_CONTEXT, 2, 1, "phone") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->email, ODR_CONTEXT, 3, 1, "email") && + odr_sequence_end (o); +} + +int z_IOBilling (ODR o, Z_IOBilling **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 0, Z_IOBilling_billInvoice, + (Odr_fun) odr_null, "billInvoice"}, + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IOBilling_prepay, + (Odr_fun) odr_null, "prepay"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IOBilling_depositAccount, + (Odr_fun) odr_null, "depositAccount"}, + {ODR_IMPLICIT, ODR_CONTEXT, 3, Z_IOBilling_creditCard, + (Odr_fun) z_IOCreditCardInfo, "creditCard"}, + {ODR_IMPLICIT, ODR_CONTEXT, 4, Z_IOBilling_cardInfoPreviouslySupplied, + (Odr_fun) odr_null, "cardInfoPreviouslySupplied"}, + {ODR_IMPLICIT, ODR_CONTEXT, 5, Z_IOBilling_privateKnown, + (Odr_fun) odr_null, "privateKnown"}, + {ODR_IMPLICIT, ODR_CONTEXT, 6, Z_IOBilling_privateNotKnown, + (Odr_fun) z_External, "privateNotKnown"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 1, "paymentMethod") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o) && + odr_implicit_tag (o, z_InternationalString, + &(*p)->customerReference, ODR_CONTEXT, 2, 1, "customerReference") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->customerPONumber, ODR_CONTEXT, 3, 1, "customerPONumber") && + odr_sequence_end (o); +} + +int z_IOOriginPartToKeep (ODR o, Z_IOOriginPartToKeep **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_External, + &(*p)->supplDescription, ODR_CONTEXT, 1, 1, "supplDescription") && + odr_implicit_tag (o, z_IOContact, + &(*p)->contact, ODR_CONTEXT, 2, 1, "contact") && + odr_implicit_tag (o, z_IOBilling, + &(*p)->addlBilling, ODR_CONTEXT, 3, 1, "addlBilling") && + odr_sequence_end (o); +} + +int z_IOCreditCardInfo (ODR o, Z_IOCreditCardInfo **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->nameOnCard, ODR_CONTEXT, 1, 0, "nameOnCard") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->expirationDate, ODR_CONTEXT, 2, 0, "expirationDate") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->cardNumber, ODR_CONTEXT, 3, 0, "cardNumber") && + odr_sequence_end (o); +} + +int z_IOResultSetItem (ODR o, Z_IOResultSetItem **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->resultSetId, ODR_CONTEXT, 1, 0, "resultSetId") && + odr_implicit_tag (o, odr_integer, + &(*p)->item, ODR_CONTEXT, 2, 0, "item") && + odr_sequence_end (o); +} + +int z_IOOriginPartNotToKeep (ODR o, Z_IOOriginPartNotToKeep **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_IOResultSetItem, + &(*p)->resultSetItem, ODR_CONTEXT, 1, 1, "resultSetItem") && + odr_implicit_tag (o, z_External, + &(*p)->itemRequest, ODR_CONTEXT, 2, 1, "itemRequest") && + odr_sequence_end (o); +} + +int z_IOTargetPart (ODR o, Z_IOTargetPart **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_External, + &(*p)->itemRequest, ODR_CONTEXT, 1, 1, "itemRequest") && + odr_implicit_tag (o, z_External, + &(*p)->statusOrErrorReport, ODR_CONTEXT, 2, 1, "statusOrErrorReport") && + odr_implicit_tag (o, odr_integer, + &(*p)->auxiliaryStatus, ODR_CONTEXT, 3, 1, "auxiliaryStatus") && + odr_sequence_end (o); +} diff --git a/z39.50/zes-pquery.c b/z39.50/zes-pquery.c new file mode 100644 index 0000000..bdf2605 --- /dev/null +++ b/z39.50/zes-pquery.c @@ -0,0 +1,80 @@ +/* YC 0.2 Tue Feb 29 16:45:07 CET 2000 */ +/* Module-C: ESFormat-PersistentQuery */ + +#include + +int z_PQueryPersistentQueryEsRequest (ODR o, Z_PQueryPersistentQueryEsRequest **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_PQueryOriginPartToKeep, + &(*p)->toKeep, ODR_CONTEXT, 1, 1, "toKeep") && + odr_explicit_tag (o, z_PQueryOriginPartNotToKeep, + &(*p)->notToKeep, ODR_CONTEXT, 2, 0, "notToKeep") && + odr_sequence_end (o); +} + +int z_PQueryPersistentQueryTaskPackage (ODR o, Z_PQueryPersistentQueryTaskPackage **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_PQueryOriginPartToKeep, + &(*p)->originPart, ODR_CONTEXT, 1, 1, "originPart") && + odr_explicit_tag (o, z_PQueryTargetPart, + &(*p)->targetPart, ODR_CONTEXT, 2, 0, "targetPart") && + odr_sequence_end (o); +} + +int z_PQueryPersistentQuery (ODR o, Z_PQueryPersistentQuery **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_PQueryPersistentQuery_esRequest, + (Odr_fun) z_PQueryPersistentQueryEsRequest, "esRequest"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_PQueryPersistentQuery_taskPackage, + (Odr_fun) z_PQueryPersistentQueryTaskPackage, "taskPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_PQueryOriginPartToKeep (ODR o, Z_PQueryOriginPartToKeep **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_settag (o, ODR_CONTEXT, 2) && + (odr_sequence_of(o, (Odr_fun) z_InternationalString, &(*p)->dbNames, + &(*p)->num_dbNames, "dbNames") || odr_ok(o)) && + odr_explicit_tag (o, z_OtherInformation, + &(*p)->additionalSearchInfo, ODR_CONTEXT, 3, 1, "additionalSearchInfo") && + odr_sequence_end (o); +} + +int z_PQueryOriginPartNotToKeep (ODR o, Z_PQueryOriginPartNotToKeep **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_PQueryOriginPartNotToKeep_package, + (Odr_fun) z_InternationalString, "package"}, + {ODR_EXPLICIT, ODR_CONTEXT, 2, Z_PQueryOriginPartNotToKeep_query, + (Odr_fun) z_Query, "query"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_PQueryTargetPart (ODR o, Z_PQueryTargetPart **p, int opt, const char *name) +{ + return z_Query (o, p, opt, name); +} diff --git a/z39.50/zes-psched.c b/z39.50/zes-psched.c new file mode 100644 index 0000000..0cc0fdb --- /dev/null +++ b/z39.50/zes-psched.c @@ -0,0 +1,139 @@ +/* YC 0.2 Tue Feb 29 16:45:07 CET 2000 */ +/* Module-C: ESFormat-PeriodicQuerySchedule */ + +#include + +int z_PQSPeriodicQueryScheduleEsRequest (ODR o, Z_PQSPeriodicQueryScheduleEsRequest **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_PQSOriginPartToKeep, + &(*p)->toKeep, ODR_CONTEXT, 1, 0, "toKeep") && + odr_explicit_tag (o, z_PQSOriginPartNotToKeep, + &(*p)->notToKeep, ODR_CONTEXT, 2, 0, "notToKeep") && + odr_sequence_end (o); +} + +int z_PQSPeriodicQueryScheduleTaskPackage (ODR o, Z_PQSPeriodicQueryScheduleTaskPackage **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_PQSOriginPartToKeep, + &(*p)->originPart, ODR_CONTEXT, 1, 0, "originPart") && + odr_explicit_tag (o, z_PQSTargetPart, + &(*p)->targetPart, ODR_CONTEXT, 2, 0, "targetPart") && + odr_sequence_end (o); +} + +int z_PQSPeriodicQuerySchedule (ODR o, Z_PQSPeriodicQuerySchedule **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_PQSPeriodicQuerySchedule_esRequest, + (Odr_fun) z_PQSPeriodicQueryScheduleEsRequest, "esRequest"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_PQSPeriodicQuerySchedule_taskPackage, + (Odr_fun) z_PQSPeriodicQueryScheduleTaskPackage, "taskPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_PQSOriginPartToKeep (ODR o, Z_PQSOriginPartToKeep **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_PQSOriginPartToKeep_packageName, + (Odr_fun) z_InternationalString, "packageName"}, + {ODR_EXPLICIT, ODR_CONTEXT, 2, Z_PQSOriginPartToKeep_exportPackage, + (Odr_fun) z_ESExportSpecification, "exportPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, odr_bool, + &(*p)->activeFlag, ODR_CONTEXT, 1, 0, "activeFlag") && + odr_implicit_settag (o, ODR_CONTEXT, 2) && + (odr_sequence_of(o, (Odr_fun) z_InternationalString, &(*p)->databaseNames, + &(*p)->num_databaseNames, "databaseNames") || odr_ok(o)) && + odr_implicit_tag (o, odr_integer, + &(*p)->resultSetDisposition, ODR_CONTEXT, 3, 1, "resultSetDisposition") && + odr_explicit_tag (o, z_ESDestination, + &(*p)->alertDestination, ODR_CONTEXT, 4, 1, "alertDestination") && + ((odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 5, "exportParameters") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o)) || odr_ok(o)) && + odr_sequence_end (o); +} + +int z_PQSOriginPartNotToKeep (ODR o, Z_PQSOriginPartNotToKeep **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_EXPLICIT, ODR_CONTEXT, 1, Z_PQSOriginPartNotToKeep_actualQuery, + (Odr_fun) z_Query, "actualQuery"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_PQSOriginPartNotToKeep_packageName, + (Odr_fun) z_InternationalString, "packageName"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + ((odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 1, "querySpec") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o)) || odr_ok(o)) && + odr_explicit_tag (o, z_PQSPeriod, + &(*p)->originSuggestedPeriod, ODR_CONTEXT, 2, 1, "originSuggestedPeriod") && + odr_implicit_tag (o, odr_generalizedtime, + &(*p)->expiration, ODR_CONTEXT, 3, 1, "expiration") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->resultSetPackage, ODR_CONTEXT, 4, 1, "resultSetPackage") && + odr_sequence_end (o); +} + +int z_PQSTargetPart (ODR o, Z_PQSTargetPart **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_Query, + &(*p)->actualQuery, ODR_CONTEXT, 1, 0, "actualQuery") && + odr_explicit_tag (o, z_PQSPeriod, + &(*p)->targetStatedPeriod, ODR_CONTEXT, 2, 0, "targetStatedPeriod") && + odr_implicit_tag (o, odr_generalizedtime, + &(*p)->expiration, ODR_CONTEXT, 3, 1, "expiration") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->resultSetPackage, ODR_CONTEXT, 4, 1, "resultSetPackage") && + odr_implicit_tag (o, odr_generalizedtime, + &(*p)->lastQueryTime, ODR_CONTEXT, 5, 0, "lastQueryTime") && + odr_implicit_tag (o, odr_integer, + &(*p)->lastResultNumber, ODR_CONTEXT, 6, 0, "lastResultNumber") && + odr_implicit_tag (o, odr_integer, + &(*p)->numberSinceModify, ODR_CONTEXT, 7, 1, "numberSinceModify") && + odr_sequence_end (o); +} + +int z_PQSPeriod (ODR o, Z_PQSPeriod **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_PQSPeriod_unit, + (Odr_fun) z_IntUnit, "unit"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_PQSPeriod_businessDaily, + (Odr_fun) odr_null, "businessDaily"}, + {ODR_IMPLICIT, ODR_CONTEXT, 3, Z_PQSPeriod_continuous, + (Odr_fun) odr_null, "continuous"}, + {ODR_IMPLICIT, ODR_CONTEXT, 4, Z_PQSPeriod_other, + (Odr_fun) z_InternationalString, "other"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} diff --git a/z39.50/zes-pset.c b/z39.50/zes-pset.c new file mode 100644 index 0000000..b9aaaaf --- /dev/null +++ b/z39.50/zes-pset.c @@ -0,0 +1,69 @@ +/* YC 0.2 Tue Feb 29 16:45:07 CET 2000 */ +/* Module-C: ESFormat-PersistentResultSet */ + +#include + +int z_PRPersistentResultSetEsRequest (ODR o, Z_PRPersistentResultSetEsRequest **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, odr_null, + &(*p)->toKeep, ODR_CONTEXT, 1, 0, "toKeep") && + odr_explicit_tag (o, z_PROriginPartNotToKeep, + &(*p)->notToKeep, ODR_CONTEXT, 2, 1, "notToKeep") && + odr_sequence_end (o); +} + +int z_PRPersistentResultSetTaskPackage (ODR o, Z_PRPersistentResultSetTaskPackage **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, odr_null, + &(*p)->originPart, ODR_CONTEXT, 1, 0, "originPart") && + odr_explicit_tag (o, z_PRTargetPart, + &(*p)->targetPart, ODR_CONTEXT, 2, 1, "targetPart") && + odr_sequence_end (o); +} + +int z_PRPersistentResultSet (ODR o, Z_PRPersistentResultSet **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_PRPersistentResultSet_esRequest, + (Odr_fun) z_PRPersistentResultSetEsRequest, "esRequest"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_PRPersistentResultSet_taskPackage, + (Odr_fun) z_PRPersistentResultSetTaskPackage, "taskPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_PROriginPartNotToKeep (ODR o, Z_PROriginPartNotToKeep **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->originSuppliedResultSet, ODR_CONTEXT, 1, 1, "originSuppliedResultSet") && + odr_implicit_tag (o, odr_integer, + &(*p)->replaceOrAppend, ODR_CONTEXT, 2, 1, "replaceOrAppend") && + odr_sequence_end (o); +} + +int z_PRTargetPart (ODR o, Z_PRTargetPart **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->targetSuppliedResultSet, ODR_CONTEXT, 1, 1, "targetSuppliedResultSet") && + odr_implicit_tag (o, odr_integer, + &(*p)->numberOfRecords, ODR_CONTEXT, 2, 1, "numberOfRecords") && + odr_sequence_end (o); +} diff --git a/z39.50/zes-update.c b/z39.50/zes-update.c new file mode 100644 index 0000000..85b0aa7 --- /dev/null +++ b/z39.50/zes-update.c @@ -0,0 +1,188 @@ +/* YC 0.2 Tue Feb 29 15:20:49 CET 2000 */ +/* Module-C: ESFormat-Update */ + +#include + +int z_IUUpdateEsRequest (ODR o, Z_IUUpdateEsRequest **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_IUOriginPartToKeep, + &(*p)->toKeep, ODR_CONTEXT, 1, 0, "toKeep") && + odr_explicit_tag (o, z_IUOriginPartNotToKeep, + &(*p)->notToKeep, ODR_CONTEXT, 2, 0, "notToKeep") && + odr_sequence_end (o); +} + +int z_IUUpdateTaskPackage (ODR o, Z_IUUpdateTaskPackage **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_IUOriginPartToKeep, + &(*p)->originPart, ODR_CONTEXT, 1, 0, "originPart") && + odr_explicit_tag (o, z_IUTargetPart, + &(*p)->targetPart, ODR_CONTEXT, 2, 0, "targetPart") && + odr_sequence_end (o); +} + +int z_IUUpdate (ODR o, Z_IUUpdate **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IUUpdate_esRequest, + (Odr_fun) z_IUUpdateEsRequest, "esRequest"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IUUpdate_taskPackage, + (Odr_fun) z_IUUpdateTaskPackage, "taskPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_IUOriginPartToKeep (ODR o, Z_IUOriginPartToKeep **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, odr_integer, + &(*p)->action, ODR_CONTEXT, 1, 0, "action") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->databaseName, ODR_CONTEXT, 2, 0, "databaseName") && + odr_implicit_tag (o, odr_oid, + &(*p)->schema, ODR_CONTEXT, 3, 1, "schema") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->elementSetName, ODR_CONTEXT, 4, 1, "elementSetName") && + odr_implicit_tag (o, z_External, + &(*p)->actionQualifier, ODR_CONTEXT, 5, 1, "actionQualifier") && + odr_sequence_end (o); +} + +int z_IUOriginPartNotToKeep (ODR o, Z_IUOriginPartNotToKeep **p, int opt, const char *name) +{ + return z_IUSuppliedRecords (o, p, opt, name); +} + +int z_IUTargetPart (ODR o, Z_IUTargetPart **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, odr_integer, + &(*p)->updateStatus, ODR_CONTEXT, 1, 0, "updateStatus") && + odr_implicit_settag (o, ODR_CONTEXT, 2) && + (odr_sequence_of(o, (Odr_fun) z_DiagRec, &(*p)->globalDiagnostics, + &(*p)->num_globalDiagnostics, "globalDiagnostics") || odr_ok(o)) && + odr_implicit_settag (o, ODR_CONTEXT, 3) && + odr_sequence_of(o, (Odr_fun) z_IUTaskPackageRecordStructure, &(*p)->taskPackageRecords, + &(*p)->num_taskPackageRecords, "taskPackageRecords") && + odr_sequence_end (o); +} + +int z_IUSuppliedRecordsId (ODR o, Z_IUSuppliedRecordsId **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IUSuppliedRecordsId_timeStamp, + (Odr_fun) odr_generalizedtime, "timeStamp"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IUSuppliedRecordsId_versionNumber, + (Odr_fun) z_InternationalString, "versionNumber"}, + {ODR_IMPLICIT, ODR_CONTEXT, 3, Z_IUSuppliedRecordsId_previousVersion, + (Odr_fun) z_External, "previousVersion"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_IUSuppliedRecords_elem (ODR o, Z_IUSuppliedRecords_elem **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IUSuppliedRecords_elem_number, + (Odr_fun) odr_integer, "number"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IUSuppliedRecords_elem_string, + (Odr_fun) z_InternationalString, "string"}, + {ODR_IMPLICIT, ODR_CONTEXT, 3, Z_IUSuppliedRecords_elem_opaque, + (Odr_fun) odr_octetstring, "opaque"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + ((odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 1, "recordId") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o)) || odr_ok(o)) && + odr_explicit_tag (o, z_IUSuppliedRecordsId, + &(*p)->supplementalId, ODR_CONTEXT, 2, 1, "supplementalId") && + odr_implicit_tag (o, z_IUCorrelationInfo, + &(*p)->correlationInfo, ODR_CONTEXT, 3, 1, "correlationInfo") && + odr_implicit_tag (o, z_External, + &(*p)->record, ODR_CONTEXT, 4, 0, "record") && + odr_sequence_end (o); +} + +int z_IUSuppliedRecords (ODR o, Z_IUSuppliedRecords **p, int opt, const char *name) +{ + if (!odr_initmember (o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_sequence_of (o, (Odr_fun) z_IUSuppliedRecords_elem, &(*p)->elements, + &(*p)->num, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_IUCorrelationInfo (ODR o, Z_IUCorrelationInfo **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->note, ODR_CONTEXT, 1, 1, "note") && + odr_implicit_tag (o, odr_integer, + &(*p)->id, ODR_CONTEXT, 2, 1, "id") && + odr_sequence_end (o); +} + +int z_IUTaskPackageRecordStructureSurrogateDiagnostics (ODR o, Z_IUTaskPackageRecordStructureSurrogateDiagnostics **p, int opt, const char *name) +{ + if (!odr_initmember (o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_sequence_of (o, (Odr_fun) z_DiagRec, &(*p)->elements, + &(*p)->num, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_IUTaskPackageRecordStructure (ODR o, Z_IUTaskPackageRecordStructure **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IUTaskPackageRecordStructure_record, + (Odr_fun) z_External, "record"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IUTaskPackageRecordStructure_surrogateDiagnostics, + (Odr_fun) z_IUTaskPackageRecordStructureSurrogateDiagnostics, "surrogateDiagnostics"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + ((odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 1, "recordOrSurDiag") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o)) || odr_ok(o)) && + odr_implicit_tag (o, z_IUCorrelationInfo, + &(*p)->correlationInfo, ODR_CONTEXT, 2, 1, "correlationInfo") && + odr_implicit_tag (o, odr_integer, + &(*p)->recordStatus, ODR_CONTEXT, 3, 0, "recordStatus") && + odr_implicit_settag (o, ODR_CONTEXT, 4) && + (odr_sequence_of(o, (Odr_fun) z_DiagRec, &(*p)->supplementalDiagnostics, + &(*p)->num_supplementalDiagnostics, "supplementalDiagnostics") || odr_ok(o)) && + odr_sequence_end (o); +} diff --git a/z39.50/zes-update0.c b/z39.50/zes-update0.c new file mode 100644 index 0000000..8ad90bd --- /dev/null +++ b/z39.50/zes-update0.c @@ -0,0 +1,172 @@ +/* YC 0.2 Tue Feb 29 16:45:07 CET 2000 */ +/* Module-C: ESFormat-Update0 */ + +#include + +int z_IU0UpdateEsRequest (ODR o, Z_IU0UpdateEsRequest **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_IU0OriginPartToKeep, + &(*p)->toKeep, ODR_CONTEXT, 1, 0, "toKeep") && + odr_explicit_tag (o, z_IU0OriginPartNotToKeep, + &(*p)->notToKeep, ODR_CONTEXT, 2, 0, "notToKeep") && + odr_sequence_end (o); +} + +int z_IU0UpdateTaskPackage (ODR o, Z_IU0UpdateTaskPackage **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_explicit_tag (o, z_IU0OriginPartToKeep, + &(*p)->originPart, ODR_CONTEXT, 1, 0, "originPart") && + odr_explicit_tag (o, z_IU0TargetPart, + &(*p)->targetPart, ODR_CONTEXT, 2, 0, "targetPart") && + odr_sequence_end (o); +} + +int z_IU0Update (ODR o, Z_IU0Update **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IU0Update_esRequest, + (Odr_fun) z_IU0UpdateEsRequest, "esRequest"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IU0Update_taskPackage, + (Odr_fun) z_IU0UpdateTaskPackage, "taskPackage"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_IU0OriginPartToKeep (ODR o, Z_IU0OriginPartToKeep **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, odr_integer, + &(*p)->action, ODR_CONTEXT, 1, 0, "action") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->databaseName, ODR_CONTEXT, 2, 0, "databaseName") && + odr_implicit_tag (o, odr_oid, + &(*p)->schema, ODR_CONTEXT, 3, 1, "schema") && + odr_implicit_tag (o, z_InternationalString, + &(*p)->elementSetName, ODR_CONTEXT, 4, 1, "elementSetName") && + odr_sequence_end (o); +} + +int z_IU0OriginPartNotToKeep (ODR o, Z_IU0OriginPartNotToKeep **p, int opt, const char *name) +{ + return z_IU0SuppliedRecords (o, p, opt, name); +} + +int z_IU0TargetPart (ODR o, Z_IU0TargetPart **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, odr_integer, + &(*p)->updateStatus, ODR_CONTEXT, 1, 0, "updateStatus") && + odr_implicit_settag (o, ODR_CONTEXT, 2) && + (odr_sequence_of(o, (Odr_fun) z_DiagRec, &(*p)->globalDiagnostics, + &(*p)->num_globalDiagnostics, "globalDiagnostics") || odr_ok(o)) && + odr_implicit_settag (o, ODR_CONTEXT, 3) && + odr_sequence_of(o, (Odr_fun) z_IU0TaskPackageRecordStructure, &(*p)->taskPackageRecords, + &(*p)->num_taskPackageRecords, "taskPackageRecords") && + odr_sequence_end (o); +} + +int z_IU0SuppliedRecordsId (ODR o, Z_IU0SuppliedRecordsId **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IU0SuppliedRecordsId_timeStamp, + (Odr_fun) odr_generalizedtime, "timeStamp"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IU0SuppliedRecordsId_versionNumber, + (Odr_fun) z_InternationalString, "versionNumber"}, + {ODR_IMPLICIT, ODR_CONTEXT, 3, Z_IU0SuppliedRecordsId_previousVersion, + (Odr_fun) z_External, "previousVersion"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_initmember(o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_choice(o, arm, &(*p)->u, &(*p)->which, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_IU0SuppliedRecords_elem (ODR o, Z_IU0SuppliedRecords_elem **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IU0SuppliedRecords_elem_number, + (Odr_fun) odr_integer, "number"}, + {ODR_IMPLICIT, ODR_CONTEXT, 2, Z_IU0SuppliedRecords_elem_string, + (Odr_fun) z_InternationalString, "string"}, + {ODR_IMPLICIT, ODR_CONTEXT, 3, Z_IU0SuppliedRecords_elem_opaque, + (Odr_fun) odr_octetstring, "opaque"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + ((odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 1, "recordId") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o)) || odr_ok(o)) && + odr_explicit_tag (o, z_IU0SuppliedRecordsId, + &(*p)->supplementalId, ODR_CONTEXT, 2, 1, "supplementalId") && + odr_implicit_tag (o, z_IU0CorrelationInfo, + &(*p)->correlationInfo, ODR_CONTEXT, 3, 1, "correlationInfo") && + odr_implicit_tag (o, z_External, + &(*p)->record, ODR_CONTEXT, 4, 0, "record") && + odr_sequence_end (o); +} + +int z_IU0SuppliedRecords (ODR o, Z_IU0SuppliedRecords **p, int opt, const char *name) +{ + if (!odr_initmember (o, p, sizeof(**p))) + return opt && odr_ok(o); + if (odr_sequence_of (o, (Odr_fun) z_IU0SuppliedRecords_elem, &(*p)->elements, + &(*p)->num, name)) + return 1; + *p = 0; + return opt && odr_ok(o); +} + +int z_IU0CorrelationInfo (ODR o, Z_IU0CorrelationInfo **p, int opt, const char *name) +{ + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + odr_implicit_tag (o, z_InternationalString, + &(*p)->note, ODR_CONTEXT, 1, 1, "note") && + odr_implicit_tag (o, odr_integer, + &(*p)->id, ODR_CONTEXT, 2, 1, "id") && + odr_sequence_end (o); +} + +int z_IU0TaskPackageRecordStructure (ODR o, Z_IU0TaskPackageRecordStructure **p, int opt, const char *name) +{ + static Odr_arm arm[] = { + {ODR_IMPLICIT, ODR_CONTEXT, 1, Z_IU0TaskPackageRecordStructure_record, + (Odr_fun) z_External, "record"}, + {ODR_EXPLICIT, ODR_CONTEXT, 2, Z_IU0TaskPackageRecordStructure_diagnostic, + (Odr_fun) z_DiagRec, "diagnostic"}, + {-1, -1, -1, -1, (Odr_fun) 0, 0} + }; + if (!odr_sequence_begin (o, p, sizeof(**p), name)) + return opt && odr_ok (o); + return + ((odr_constructed_begin (o, &(*p)->u, ODR_CONTEXT, 1, "recordOrSurDiag") && + odr_choice (o, arm, &(*p)->u, &(*p)->which, 0) && + odr_constructed_end (o)) || odr_ok(o)) && + odr_implicit_tag (o, z_IU0CorrelationInfo, + &(*p)->correlationInfo, ODR_CONTEXT, 2, 1, "correlationInfo") && + odr_implicit_tag (o, odr_integer, + &(*p)->recordStatus, ODR_CONTEXT, 3, 0, "recordStatus") && + odr_sequence_end (o); +} -- 1.7.10.4