+ result = (RetrievalRecordBuf *) ((arg1)->buf);
+
+ {
+ ST(argvi) = newSVpv(result->buf,result->len);
+ sv_2mortal(ST(argvi));
+ argvi++;
+ }
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_new_RetrievalRecord) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ RetrievalRecord *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_RetrievalRecord();");
+ }
+ result = (RetrievalRecord *)(RetrievalRecord *) calloc(1, sizeof(RetrievalRecord));
+
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RetrievalRecord,0);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_delete_RetrievalRecord) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ RetrievalRecord *arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_RetrievalRecord(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
+ SWIG_croak("Type error in argument 1 of delete_RetrievalRecord. Expected _p_RetrievalRecord");
+ }
+ }
+ free((char *) arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanEntry_occurrences_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanEntry *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ScanEntry_occurrences_set(self,occurrences);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanEntry_occurrences_set. Expected _p_ScanEntry");
+ }
+ }
+ arg2 = (int) SvIV(ST(1));
+ if (arg1) (arg1)->occurrences = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanEntry_occurrences_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanEntry *arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ScanEntry_occurrences_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanEntry_occurrences_get. Expected _p_ScanEntry");
+ }
+ }
+ result = (int) ((arg1)->occurrences);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanEntry_term_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanEntry *arg1 ;
+ char *arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ScanEntry_term_set(self,term);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanEntry_term_set. Expected _p_ScanEntry");
+ }
+ }
+ if (!SvOK((SV*) ST(1))) arg2 = 0;
+ else arg2 = (char *) SvPV(ST(1), PL_na);
+ {
+ if (arg1->term) free((char*)arg1->term);
+ arg1->term = (char *) malloc(strlen(arg2)+1);
+ strcpy((char*)arg1->term,arg2);
+ }
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanEntry_term_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanEntry *arg1 ;
+ char *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ScanEntry_term_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanEntry_term_get. Expected _p_ScanEntry");
+ }
+ }
+ result = (char *) ((arg1)->term);
+
+ ST(argvi) = sv_newmortal();
+ if (result) {
+ sv_setpv((SV*)ST(argvi++), (char *) result);
+ }else {
+ sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
+ }
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_new_ScanEntry) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanEntry *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_ScanEntry();");
+ }
+ result = (ScanEntry *)(ScanEntry *) calloc(1, sizeof(ScanEntry));
+
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ScanEntry,0);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_delete_ScanEntry) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanEntry *arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_ScanEntry(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) {
+ SWIG_croak("Type error in argument 1 of delete_ScanEntry. Expected _p_ScanEntry");
+ }
+ }
+ free((char *) arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanObj_num_entries_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ScanObj_num_entries_set(self,num_entries);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanObj_num_entries_set. Expected _p_ScanObj");
+ }
+ }
+ arg2 = (int) SvIV(ST(1));
+ if (arg1) (arg1)->num_entries = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanObj_num_entries_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ScanObj_num_entries_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanObj_num_entries_get. Expected _p_ScanObj");
+ }
+ }
+ result = (int) ((arg1)->num_entries);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanObj_position_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ScanObj_position_set(self,position);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanObj_position_set. Expected _p_ScanObj");
+ }
+ }
+ arg2 = (int) SvIV(ST(1));
+ if (arg1) (arg1)->position = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanObj_position_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ScanObj_position_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanObj_position_get. Expected _p_ScanObj");
+ }
+ }
+ result = (int) ((arg1)->position);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanObj_is_partial_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ScanObj_is_partial_set(self,is_partial);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanObj_is_partial_set. Expected _p_ScanObj");
+ }
+ }
+ arg2 = (int) SvIV(ST(1));
+ if (arg1) (arg1)->is_partial = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanObj_is_partial_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ScanObj_is_partial_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanObj_is_partial_get. Expected _p_ScanObj");
+ }
+ }
+ result = (int) ((arg1)->is_partial);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanObj_entries_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ ScanEntry *arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ScanObj_entries_set(self,entries);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanObj_entries_set. Expected _p_ScanObj");
+ }
+ }
+ {
+ if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ScanEntry,0) < 0) {
+ SWIG_croak("Type error in argument 2 of ScanObj_entries_set. Expected _p_ScanEntry");
+ }
+ }
+ if (arg1) (arg1)->entries = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ScanObj_entries_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ ScanEntry *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ScanObj_entries_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ScanObj_entries_get. Expected _p_ScanObj");
+ }
+ }
+ result = (ScanEntry *) ((arg1)->entries);
+
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ScanEntry,0);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_new_ScanObj) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_ScanObj();");
+ }
+ result = (ScanObj *)(ScanObj *) calloc(1, sizeof(ScanObj));
+
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ScanObj,0);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_delete_ScanObj) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ScanObj *arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_ScanObj(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
+ SWIG_croak("Type error in argument 1 of delete_ScanObj. Expected _p_ScanObj");
+ }
+ }
+ free((char *) arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_processed_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_processed_set(self,processed);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_processed_set. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ arg2 = (int) SvIV(ST(1));
+ if (arg1) (arg1)->processed = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_processed_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_processed_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_processed_get. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ result = (int) ((arg1)->processed);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_inserted_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_inserted_set(self,inserted);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_inserted_set. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ arg2 = (int) SvIV(ST(1));
+ if (arg1) (arg1)->inserted = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_inserted_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_inserted_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_inserted_get. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ result = (int) ((arg1)->inserted);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_updated_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_updated_set(self,updated);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_updated_set. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ arg2 = (int) SvIV(ST(1));
+ if (arg1) (arg1)->updated = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_updated_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_updated_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_updated_get. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ result = (int) ((arg1)->updated);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_deleted_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_deleted_set(self,deleted);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_deleted_set. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ arg2 = (int) SvIV(ST(1));
+ if (arg1) (arg1)->deleted = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_deleted_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_deleted_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_deleted_get. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ result = (int) ((arg1)->deleted);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_utime_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ long arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_utime_set(self,utime);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_utime_set. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ arg2 = (long) SvIV(ST(1));
+ if (arg1) (arg1)->utime = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_utime_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ long result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_utime_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_utime_get. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ result = (long) ((arg1)->utime);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_stime_set) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ long arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_stime_set(self,stime);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_stime_set. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ arg2 = (long) SvIV(ST(1));
+ if (arg1) (arg1)->stime = arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_ZebraTransactionStatus_stime_get) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ long result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: ZebraTransactionStatus_stime_get(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_stime_get. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ result = (long) ((arg1)->stime);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_new_ZebraTransactionStatus) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_ZebraTransactionStatus();");
+ }
+ result = (ZebraTransactionStatus *)(ZebraTransactionStatus *) calloc(1, sizeof(ZebraTransactionStatus));
+
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ZebraTransactionStatus,0);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_delete_ZebraTransactionStatus) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraTransactionStatus *arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_ZebraTransactionStatus(self);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
+ SWIG_croak("Type error in argument 1 of delete_ZebraTransactionStatus. Expected _p_ZebraTransactionStatus");
+ }
+ }
+ free((char *) arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_init__SWIG_0) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: init();");
+ }
+ init();
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_DESTROY) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: DESTROY();");
+ }
+ DESTROY();
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_logLevel) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ int arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: logLevel(level);");
+ }
+ arg1 = (int) SvIV(ST(0));
+ logLevel(arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_logFile) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ char *arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: logFile(fname);");
+ }
+ if (!SvOK((SV*) ST(0))) arg1 = 0;
+ else arg1 = (char *) SvPV(ST(0), PL_na);
+ logFile((char const *)arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_logMsg) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ int arg1 ;
+ char *arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: logMsg(level,message);");
+ }
+ arg1 = (int) SvIV(ST(0));
+ if (!SvOK((SV*) ST(1))) arg2 = 0;
+ else arg2 = (char *) SvPV(ST(1), PL_na);
+ logMsg(arg1,(char const *)arg2);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_odr_createmem) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ int arg1 ;
+ ODR result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: odr_createmem(direction);");
+ }
+ arg1 = (int) SvIV(ST(0));
+ result = odr_createmem(arg1);
+
+ {
+ ODR * resultobj = (ODR *) malloc(sizeof(ODR));
+ memmove(resultobj, &result, sizeof(ODR));
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ODR,0);
+ }
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_odr_reset) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ODR arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: odr_reset(o);");
+ }
+ {
+ ODR * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
+ SWIG_croak("Type error in argument 1 of odr_reset. Expected _p_ODR");
+ }
+ arg1 = *argp;
+ }
+ odr_reset(arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_odr_destroy) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ODR arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: odr_destroy(o);");
+ }
+ {
+ ODR * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
+ SWIG_croak("Type error in argument 1 of odr_destroy. Expected _p_ODR");
+ }
+ arg1 = *argp;
+ }
+ odr_destroy(arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_odr_malloc) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ODR arg1 ;
+ int arg2 ;
+ void *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: odr_malloc(o,size);");
+ }
+ {
+ ODR * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
+ SWIG_croak("Type error in argument 1 of odr_malloc. Expected _p_ODR");
+ }
+ arg1 = *argp;
+ }
+ arg2 = (int) SvIV(ST(1));
+ result = (void *)odr_malloc(arg1,arg2);
+
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_void,0);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_start) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ char *arg1 ;
+ ZebraService result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: start(configName);");
+ }
+ if (!SvOK((SV*) ST(0))) arg1 = 0;
+ else arg1 = (char *) SvPV(ST(0), PL_na);
+ result = zebra_start((char const *)arg1);
+
+ {
+ ZebraService * resultobj = (ZebraService *) malloc(sizeof(ZebraService));
+ memmove(resultobj, &result, sizeof(ZebraService));
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ZebraService,0);
+ }
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_open) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraService arg1 ;
+ ZebraHandle result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: open(zs);");
+ }
+ {
+ ZebraService * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraService,0) < 0) {
+ SWIG_croak("Type error in argument 1 of open. Expected _p_ZebraService");
+ }
+ arg1 = *argp;
+ }
+ result = zebra_open(arg1);
+
+ {
+ ZebraHandle * resultobj = (ZebraHandle *) malloc(sizeof(ZebraHandle));
+ memmove(resultobj, &result, sizeof(ZebraHandle));
+ ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ZebraHandle,0);
+ }
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_close) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraHandle arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: close(zh);");
+ }
+ {
+ ZebraHandle * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
+ SWIG_croak("Type error in argument 1 of close. Expected _p_ZebraHandle");
+ }
+ arg1 = *argp;
+ }
+ zebra_close(arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_stop) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraService arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: stop(zs);");
+ }
+ {
+ ZebraService * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraService,0) < 0) {
+ SWIG_croak("Type error in argument 1 of stop. Expected _p_ZebraService");
+ }
+ arg1 = *argp;
+ }
+ zebra_stop(arg1);
+
+
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_errCode) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraHandle arg1 ;
+ int result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: errCode(zh);");
+ }
+ {
+ ZebraHandle * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
+ SWIG_croak("Type error in argument 1 of errCode. Expected _p_ZebraHandle");
+ }
+ arg1 = *argp;
+ }
+ result = (int)zebra_errCode(arg1);
+
+ ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++), (IV) result);
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_errString) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraHandle arg1 ;
+ char *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: errString(zh);");
+ }
+ {
+ ZebraHandle * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
+ SWIG_croak("Type error in argument 1 of errString. Expected _p_ZebraHandle");
+ }
+ arg1 = *argp;
+ }
+ result = (char *)zebra_errString(arg1);
+
+ ST(argvi) = sv_newmortal();
+ if (result) {
+ sv_setpv((SV*)ST(argvi++), (char *) result);
+ }else {
+ sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
+ }
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_errAdd) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ ZebraHandle arg1 ;
+ char *result;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: errAdd(zh);");
+ }
+ {
+ ZebraHandle * argp;
+ if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
+ SWIG_croak("Type error in argument 1 of errAdd. Expected _p_ZebraHandle");
+ }
+ arg1 = *argp;
+ }
+ result = (char *)zebra_errAdd(arg1);
+
+ ST(argvi) = sv_newmortal();
+ if (result) {
+ sv_setpv((SV*)ST(argvi++), (char *) result);
+ }else {
+ sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
+ }
+ XSRETURN(argvi);
+ fail:
+ (void) _swigerr;
+ }
+ croak(_swigerr);
+}
+
+
+XS(_wrap_init_recordGroup) {
+ char _swigmsg[SWIG_MAX_ERRMSG] = "";
+ const char *_swigerr = _swigmsg;
+ {
+ recordGroup *arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: init_recordGroup(rg);");
+ }
+ {
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
+ SWIG_croak("Type error in argument 1 of init_recordGroup. Expected _p_recordGroup");
+ }
+ }
+ init_recordGroup(arg1);
+