perl/lib/IDZebra.pm

   1 # This file was automatically generated by SWIG
   2 package IDZebra;
   3 require Exporter;
   4 require DynaLoader;
   5 @ISA = qw(Exporter DynaLoader);
   6 package IDZebrac;
   7 bootstrap IDZebra;
   8 package IDZebra;
   9 @EXPORT = qw( );
  10
  11 # ---------- BASE METHODS -------------
  12
  13 package IDZebra;
  14
  15 sub TIEHASH {
  16     my ($classname,$obj) = @_;
  17     return bless $obj, $classname;
  18 }
  19
  20 sub CLEAR { }
  21
  22 sub FIRSTKEY { }
  23
  24 sub NEXTKEY { }
  25
  26 sub this {
  27     my $ptr = shift;
  28     return tied(%$ptr);
  29 }
  30
  31
  32 # ------- FUNCTION WRAPPERS --------
  33
  34 package IDZebra;
  35
  36 *DESTROY = *IDZebrac::DESTROY;
  37 *logLevel = *IDZebrac::logLevel;
  38 *logFile = *IDZebrac::logFile;
  39 *logMsg = *IDZebrac::logMsg;
  40 *odr_createmem = *IDZebrac::odr_createmem;
  41 *odr_reset = *IDZebrac::odr_reset;
  42 *odr_destroy = *IDZebrac::odr_destroy;
  43 *odr_malloc = *IDZebrac::odr_malloc;
  44 *start = *IDZebrac::start;
  45 *open = *IDZebrac::open;
  46 *close = *IDZebrac::close;
  47 *stop = *IDZebrac::stop;
  48 *errCode = *IDZebrac::errCode;
  49 *errString = *IDZebrac::errString;
  50 *errAdd = *IDZebrac::errAdd;
  51 *init_recordGroup = *IDZebrac::init_recordGroup;
  52 *res_get_recordGroup = *IDZebrac::res_get_recordGroup;
  53 *set_group = *IDZebrac::set_group;
  54 *select_database = *IDZebrac::select_database;
  55 *select_databases = *IDZebrac::select_databases;
  56 *begin_trans = *IDZebrac::begin_trans;
  57 *end_trans = *IDZebrac::end_trans;
  58 *trans_no = *IDZebrac::trans_no;
  59 *begin_read = *IDZebrac::begin_read;
  60 *end_read = *IDZebrac::end_read;
  61 *commit = *IDZebrac::commit;
  62 *get_shadow_enable = *IDZebrac::get_shadow_enable;
  63 *set_shadow_enable = *IDZebrac::set_shadow_enable;
  64 *init = *IDZebrac::init;
  65 *compact = *IDZebrac::compact;
  66 *repository_update = *IDZebrac::repository_update;
  67 *repository_delete = *IDZebrac::repository_delete;
  68 *repository_show = *IDZebrac::repository_show;
  69 *update_record = *IDZebrac::update_record;
  70 *delete_record = *IDZebrac::delete_record;
  71 *search_PQF = *IDZebrac::search_PQF;
  72 *cql_transform_open_fname = *IDZebrac::cql_transform_open_fname;
  73 *cql_transform_close = *IDZebrac::cql_transform_close;
  74 *cql_transform_error = *IDZebrac::cql_transform_error;
  75 *cql2pqf = *IDZebrac::cql2pqf;
  76 *records_retrieve = *IDZebrac::records_retrieve;
  77 *record_retrieve = *IDZebrac::record_retrieve;
  78 *deleteResultSet = *IDZebrac::deleteResultSet;
  79 *sort = *IDZebrac::sort;
  80 *scan_PQF = *IDZebrac::scan_PQF;
  81 sub getScanEntry {
  82     my @args = @_;
  83     my $result = IDZebrac::getScanEntry(@args);
  84     return undef if (!defined($result));
  85     my %resulthash;
  86     tie %resulthash, ref($result), $result;
  87     return bless \%resulthash, ref($result);
  88 }
  89 *nmem_create = *IDZebrac::nmem_create;
  90 *nmem_destroy = *IDZebrac::nmem_destroy;
  91 *data1_create = *IDZebrac::data1_create;
  92 *data1_createx = *IDZebrac::data1_createx;
  93 *data1_destroy = *IDZebrac::data1_destroy;
  94 *get_parent_tag = *IDZebrac::get_parent_tag;
  95 *data1_read_node = *IDZebrac::data1_read_node;
  96 *data1_read_nodex = *IDZebrac::data1_read_nodex;
  97 *data1_read_record = *IDZebrac::data1_read_record;
  98 *data1_read_absyn = *IDZebrac::data1_read_absyn;
  99 *data1_gettagbynum = *IDZebrac::data1_gettagbynum;
 100 *data1_empty_tagset = *IDZebrac::data1_empty_tagset;
 101 *data1_read_tagset = *IDZebrac::data1_read_tagset;
 102 *data1_getelementbytagname = *IDZebrac::data1_getelementbytagname;
 103 *data1_nodetogr = *IDZebrac::data1_nodetogr;
 104 *data1_gettagbyname = *IDZebrac::data1_gettagbyname;
 105 *data1_free_tree = *IDZebrac::data1_free_tree;
 106 *data1_nodetobuf = *IDZebrac::data1_nodetobuf;
 107 *data1_mk_tag_data_wd = *IDZebrac::data1_mk_tag_data_wd;
 108 *data1_mk_tag_data = *IDZebrac::data1_mk_tag_data;
 109 *data1_maptype = *IDZebrac::data1_maptype;
 110 *data1_read_varset = *IDZebrac::data1_read_varset;
 111 *data1_getvartypebyct = *IDZebrac::data1_getvartypebyct;
 112 *data1_read_espec1 = *IDZebrac::data1_read_espec1;
 113 *data1_doespec1 = *IDZebrac::data1_doespec1;
 114 *data1_getesetbyname = *IDZebrac::data1_getesetbyname;
 115 *data1_getelementbyname = *IDZebrac::data1_getelementbyname;
 116 *data1_mk_node2 = *IDZebrac::data1_mk_node2;
 117 *data1_mk_tag = *IDZebrac::data1_mk_tag;
 118 *data1_mk_tag_n = *IDZebrac::data1_mk_tag_n;
 119 *data1_tag_add_attr = *IDZebrac::data1_tag_add_attr;
 120 *data1_mk_text_n = *IDZebrac::data1_mk_text_n;
 121 *data1_mk_text_nf = *IDZebrac::data1_mk_text_nf;
 122 *data1_mk_text = *IDZebrac::data1_mk_text;
 123 *data1_mk_comment_n = *IDZebrac::data1_mk_comment_n;
 124 *data1_mk_comment = *IDZebrac::data1_mk_comment;
 125 *data1_mk_preprocess = *IDZebrac::data1_mk_preprocess;
 126 *data1_mk_root = *IDZebrac::data1_mk_root;
 127 *data1_set_root = *IDZebrac::data1_set_root;
 128 *data1_mk_tag_data_int = *IDZebrac::data1_mk_tag_data_int;
 129 *data1_mk_tag_data_oid = *IDZebrac::data1_mk_tag_data_oid;
 130 *data1_mk_tag_data_text = *IDZebrac::data1_mk_tag_data_text;
 131 *data1_mk_tag_data_text_uni = *IDZebrac::data1_mk_tag_data_text_uni;
 132 *data1_get_absyn = *IDZebrac::data1_get_absyn;
 133 *data1_search_tag = *IDZebrac::data1_search_tag;
 134 *data1_mk_tag_uni = *IDZebrac::data1_mk_tag_uni;
 135 *data1_get_attset = *IDZebrac::data1_get_attset;
 136 *data1_read_maptab = *IDZebrac::data1_read_maptab;
 137 *data1_map_record = *IDZebrac::data1_map_record;
 138 *data1_read_marctab = *IDZebrac::data1_read_marctab;
 139 *data1_nodetomarc = *IDZebrac::data1_nodetomarc;
 140 *data1_nodetoidsgml = *IDZebrac::data1_nodetoidsgml;
 141 *data1_nodetoexplain = *IDZebrac::data1_nodetoexplain;
 142 *data1_nodetosummary = *IDZebrac::data1_nodetosummary;
 143 *data1_nodetosoif = *IDZebrac::data1_nodetosoif;
 144 *data1_get_wrbuf = *IDZebrac::data1_get_wrbuf;
 145 *data1_get_read_buf = *IDZebrac::data1_get_read_buf;
 146 *data1_get_map_buf = *IDZebrac::data1_get_map_buf;
 147 *data1_absyn_cache_get = *IDZebrac::data1_absyn_cache_get;
 148 *data1_attset_cache_get = *IDZebrac::data1_attset_cache_get;
 149 *data1_nmem_get = *IDZebrac::data1_nmem_get;
 150 *data1_pr_tree = *IDZebrac::data1_pr_tree;
 151 *data1_print_tree = *IDZebrac::data1_print_tree;
 152 *data1_insert_string = *IDZebrac::data1_insert_string;
 153 *data1_insert_string_n = *IDZebrac::data1_insert_string_n;
 154 *data1_read_sgml = *IDZebrac::data1_read_sgml;
 155 *data1_absyn_trav = *IDZebrac::data1_absyn_trav;
 156 *data1_attset_search_id = *IDZebrac::data1_attset_search_id;
 157 *data1_getNodeValue = *IDZebrac::data1_getNodeValue;
 158 *data1_LookupNode = *IDZebrac::data1_LookupNode;
 159 *data1_CountOccurences = *IDZebrac::data1_CountOccurences;
 160 *data1_path_fopen = *IDZebrac::data1_path_fopen;
 161 *data1_set_tabpath = *IDZebrac::data1_set_tabpath;
 162 *data1_set_tabroot = *IDZebrac::data1_set_tabroot;
 163 *data1_get_tabpath = *IDZebrac::data1_get_tabpath;
 164 *data1_get_tabroot = *IDZebrac::data1_get_tabroot;
 165 *grs_perl_readf = *IDZebrac::grs_perl_readf;
 166 *grs_perl_readline = *IDZebrac::grs_perl_readline;
 167 *grs_perl_getc = *IDZebrac::grs_perl_getc;
 168 *grs_perl_seekf = *IDZebrac::grs_perl_seekf;
 169 *grs_perl_tellf = *IDZebrac::grs_perl_tellf;
 170 *grs_perl_endf = *IDZebrac::grs_perl_endf;
 171 *grs_perl_get_dh = *IDZebrac::grs_perl_get_dh;
 172 *grs_perl_get_mem = *IDZebrac::grs_perl_get_mem;
 173 *grs_perl_set_res = *IDZebrac::grs_perl_set_res;
 174
 175 ############# Class : IDZebra::recordGroup ##############
 176
 177 package IDZebra::recordGroup;
 178 @ISA = qw( IDZebra );
 179 %OWNER = ();
 180 %BLESSEDMEMBERS = (
 181 );
 182
 183 %ITERATORS = ();
 184 *swig_groupName_get = *IDZebrac::recordGroup_groupName_get;
 185 *swig_groupName_set = *IDZebrac::recordGroup_groupName_set;
 186 *swig_databaseName_get = *IDZebrac::recordGroup_databaseName_get;
 187 *swig_databaseName_set = *IDZebrac::recordGroup_databaseName_set;
 188 *swig_path_get = *IDZebrac::recordGroup_path_get;
 189 *swig_path_set = *IDZebrac::recordGroup_path_set;
 190 *swig_recordId_get = *IDZebrac::recordGroup_recordId_get;
 191 *swig_recordId_set = *IDZebrac::recordGroup_recordId_set;
 192 *swig_recordType_get = *IDZebrac::recordGroup_recordType_get;
 193 *swig_recordType_set = *IDZebrac::recordGroup_recordType_set;
 194 *swig_flagStoreData_get = *IDZebrac::recordGroup_flagStoreData_get;
 195 *swig_flagStoreData_set = *IDZebrac::recordGroup_flagStoreData_set;
 196 *swig_flagStoreKeys_get = *IDZebrac::recordGroup_flagStoreKeys_get;
 197 *swig_flagStoreKeys_set = *IDZebrac::recordGroup_flagStoreKeys_set;
 198 *swig_flagRw_get = *IDZebrac::recordGroup_flagRw_get;
 199 *swig_flagRw_set = *IDZebrac::recordGroup_flagRw_set;
 200 *swig_fileVerboseLimit_get = *IDZebrac::recordGroup_fileVerboseLimit_get;
 201 *swig_fileVerboseLimit_set = *IDZebrac::recordGroup_fileVerboseLimit_set;
 202 *swig_databaseNamePath_get = *IDZebrac::recordGroup_databaseNamePath_get;
 203 *swig_databaseNamePath_set = *IDZebrac::recordGroup_databaseNamePath_set;
 204 *swig_explainDatabase_get = *IDZebrac::recordGroup_explainDatabase_get;
 205 *swig_explainDatabase_set = *IDZebrac::recordGroup_explainDatabase_set;
 206 *swig_followLinks_get = *IDZebrac::recordGroup_followLinks_get;
 207 *swig_followLinks_set = *IDZebrac::recordGroup_followLinks_set;
 208 sub new {
 209     my $pkg = shift;
 210     my @args = @_;
 211     my $self = IDZebrac::new_recordGroup(@args);
 212     return undef if (!defined($self));
 213     $OWNER{$self} = 1;
 214     my %retval;
 215     tie %retval, "IDZebra::recordGroup", $self;
 216     return bless \%retval, $pkg;
 217 }
 218
 219 sub DESTROY {
 220     return unless $_[0]->isa('HASH');
 221     my $self = tied(%{$_[0]});
 222     return unless defined $self;
 223     delete $ITERATORS{$self};
 224     if (exists $OWNER{$self}) {
 225         IDZebrac::delete_recordGroup($self);
 226         delete $OWNER{$self};
 227     }
 228 }
 229
 230 sub DISOWN {
 231     my $self = shift;
 232     my $ptr = tied(%$self);
 233     delete $OWNER{$ptr};
 234     };
 235
 236 sub ACQUIRE {
 237     my $self = shift;
 238     my $ptr = tied(%$self);
 239     $OWNER{$ptr} = 1;
 240     };
 241
 242 sub FETCH {
 243     my ($self,$field) = @_;
 244     my $member_func = "swig_${field}_get";
 245     my $val = $self->$member_func();
 246     if (exists $BLESSEDMEMBERS{$field}) {
 247         return undef if (!defined($val));
 248         my %retval;
 249         tie %retval,$BLESSEDMEMBERS{$field},$val;
 250         return bless \%retval, $BLESSEDMEMBERS{$field};
 251     }
 252     return $val;
 253 }
 254
 255 sub STORE {
 256     my ($self,$field,$newval) = @_;
 257     my $member_func = "swig_${field}_set";
 258     if (exists $BLESSEDMEMBERS{$field}) {
 259         $self->$member_func(tied(%{$newval}));
 260     } else {
 261         $self->$member_func($newval);
 262     }
 263 }
 264
 265
 266 ############# Class : IDZebra::RetrievalObj ##############
 267
 268 package IDZebra::RetrievalObj;
 269 @ISA = qw( IDZebra );
 270 %OWNER = ();
 271 %BLESSEDMEMBERS = (
 272 );
 273
 274 %ITERATORS = ();
 275 *swig_noOfRecords_get = *IDZebrac::RetrievalObj_noOfRecords_get;
 276 *swig_noOfRecords_set = *IDZebrac::RetrievalObj_noOfRecords_set;
 277 *swig_records_get = *IDZebrac::RetrievalObj_records_get;
 278 *swig_records_set = *IDZebrac::RetrievalObj_records_set;
 279 sub new {
 280     my $pkg = shift;
 281     my @args = @_;
 282     my $self = IDZebrac::new_RetrievalObj(@args);
 283     return undef if (!defined($self));
 284     $OWNER{$self} = 1;
 285     my %retval;
 286     tie %retval, "IDZebra::RetrievalObj", $self;
 287     return bless \%retval, $pkg;
 288 }
 289
 290 sub DESTROY {
 291     return unless $_[0]->isa('HASH');
 292     my $self = tied(%{$_[0]});
 293     return unless defined $self;
 294     delete $ITERATORS{$self};
 295     if (exists $OWNER{$self}) {
 296         IDZebrac::delete_RetrievalObj($self);
 297         delete $OWNER{$self};
 298     }
 299 }
 300
 301 sub DISOWN {
 302     my $self = shift;
 303     my $ptr = tied(%$self);
 304     delete $OWNER{$ptr};
 305     };
 306
 307 sub ACQUIRE {
 308     my $self = shift;
 309     my $ptr = tied(%$self);
 310     $OWNER{$ptr} = 1;
 311     };
 312
 313 sub FETCH {
 314     my ($self,$field) = @_;
 315     my $member_func = "swig_${field}_get";
 316     my $val = $self->$member_func();
 317     if (exists $BLESSEDMEMBERS{$field}) {
 318         return undef if (!defined($val));
 319         my %retval;
 320         tie %retval,$BLESSEDMEMBERS{$field},$val;
 321         return bless \%retval, $BLESSEDMEMBERS{$field};
 322     }
 323     return $val;
 324 }
 325
 326 sub STORE {
 327     my ($self,$field,$newval) = @_;
 328     my $member_func = "swig_${field}_set";
 329     if (exists $BLESSEDMEMBERS{$field}) {
 330         $self->$member_func(tied(%{$newval}));
 331     } else {
 332         $self->$member_func($newval);
 333     }
 334 }
 335
 336
 337 ############# Class : IDZebra::RetrievalRecordBuf ##############
 338
 339 package IDZebra::RetrievalRecordBuf;
 340 @ISA = qw( IDZebra );
 341 %OWNER = ();
 342 %BLESSEDMEMBERS = (
 343 );
 344
 345 %ITERATORS = ();
 346 *swig_buf_get = *IDZebrac::RetrievalRecordBuf_buf_get;
 347 *swig_buf_set = *IDZebrac::RetrievalRecordBuf_buf_set;
 348 *swig_len_get = *IDZebrac::RetrievalRecordBuf_len_get;
 349 *swig_len_set = *IDZebrac::RetrievalRecordBuf_len_set;
 350 sub new {
 351     my $pkg = shift;
 352     my @args = @_;
 353     my $self = IDZebrac::new_RetrievalRecordBuf(@args);
 354     return undef if (!defined($self));
 355     $OWNER{$self} = 1;
 356     my %retval;
 357     tie %retval, "IDZebra::RetrievalRecordBuf", $self;
 358     return bless \%retval, $pkg;
 359 }
 360
 361 sub DESTROY {
 362     return unless $_[0]->isa('HASH');
 363     my $self = tied(%{$_[0]});
 364     return unless defined $self;
 365     delete $ITERATORS{$self};
 366     if (exists $OWNER{$self}) {
 367         IDZebrac::delete_RetrievalRecordBuf($self);
 368         delete $OWNER{$self};
 369     }
 370 }
 371
 372 sub DISOWN {
 373     my $self = shift;
 374     my $ptr = tied(%$self);
 375     delete $OWNER{$ptr};
 376     };
 377
 378 sub ACQUIRE {
 379     my $self = shift;
 380     my $ptr = tied(%$self);
 381     $OWNER{$ptr} = 1;
 382     };
 383
 384 sub FETCH {
 385     my ($self,$field) = @_;
 386     my $member_func = "swig_${field}_get";
 387     my $val = $self->$member_func();
 388     if (exists $BLESSEDMEMBERS{$field}) {
 389         return undef if (!defined($val));
 390         my %retval;
 391         tie %retval,$BLESSEDMEMBERS{$field},$val;
 392         return bless \%retval, $BLESSEDMEMBERS{$field};
 393     }
 394     return $val;
 395 }
 396
 397 sub STORE {
 398     my ($self,$field,$newval) = @_;
 399     my $member_func = "swig_${field}_set";
 400     if (exists $BLESSEDMEMBERS{$field}) {
 401         $self->$member_func(tied(%{$newval}));
 402     } else {
 403         $self->$member_func($newval);
 404     }
 405 }
 406
 407
 408 ############# Class : IDZebra::RetrievalRecord ##############
 409
 410 package IDZebra::RetrievalRecord;
 411 @ISA = qw( IDZebra );
 412 %OWNER = ();
 413 %BLESSEDMEMBERS = (
 414     buf => 'IDZebra::RetrievalRecordBuf',
 415 );
 416
 417 %ITERATORS = ();
 418 *swig_errCode_get = *IDZebrac::RetrievalRecord_errCode_get;
 419 *swig_errCode_set = *IDZebrac::RetrievalRecord_errCode_set;
 420 *swig_errString_get = *IDZebrac::RetrievalRecord_errString_get;
 421 *swig_errString_set = *IDZebrac::RetrievalRecord_errString_set;
 422 *swig_position_get = *IDZebrac::RetrievalRecord_position_get;
 423 *swig_position_set = *IDZebrac::RetrievalRecord_position_set;
 424 *swig_base_get = *IDZebrac::RetrievalRecord_base_get;
 425 *swig_base_set = *IDZebrac::RetrievalRecord_base_set;
 426 *swig_sysno_get = *IDZebrac::RetrievalRecord_sysno_get;
 427 *swig_sysno_set = *IDZebrac::RetrievalRecord_sysno_set;
 428 *swig_score_get = *IDZebrac::RetrievalRecord_score_get;
 429 *swig_score_set = *IDZebrac::RetrievalRecord_score_set;
 430 *swig_format_get = *IDZebrac::RetrievalRecord_format_get;
 431 *swig_format_set = *IDZebrac::RetrievalRecord_format_set;
 432 *swig_buf_get = *IDZebrac::RetrievalRecord_buf_get;
 433 *swig_buf_set = *IDZebrac::RetrievalRecord_buf_set;
 434 sub new {
 435     my $pkg = shift;
 436     my @args = @_;
 437     my $self = IDZebrac::new_RetrievalRecord(@args);
 438     return undef if (!defined($self));
 439     $OWNER{$self} = 1;
 440     my %retval;
 441     tie %retval, "IDZebra::RetrievalRecord", $self;
 442     return bless \%retval, $pkg;
 443 }
 444
 445 sub DESTROY {
 446     return unless $_[0]->isa('HASH');
 447     my $self = tied(%{$_[0]});
 448     return unless defined $self;
 449     delete $ITERATORS{$self};
 450     if (exists $OWNER{$self}) {
 451         IDZebrac::delete_RetrievalRecord($self);
 452         delete $OWNER{$self};
 453     }
 454 }
 455
 456 sub DISOWN {
 457     my $self = shift;
 458     my $ptr = tied(%$self);
 459     delete $OWNER{$ptr};
 460     };
 461
 462 sub ACQUIRE {
 463     my $self = shift;
 464     my $ptr = tied(%$self);
 465     $OWNER{$ptr} = 1;
 466     };
 467
 468 sub FETCH {
 469     my ($self,$field) = @_;
 470     my $member_func = "swig_${field}_get";
 471     my $val = $self->$member_func();
 472     if (exists $BLESSEDMEMBERS{$field}) {
 473         return undef if (!defined($val));
 474         my %retval;
 475         tie %retval,$BLESSEDMEMBERS{$field},$val;
 476         return bless \%retval, $BLESSEDMEMBERS{$field};
 477     }
 478     return $val;
 479 }
 480
 481 sub STORE {
 482     my ($self,$field,$newval) = @_;
 483     my $member_func = "swig_${field}_set";
 484     if (exists $BLESSEDMEMBERS{$field}) {
 485         $self->$member_func(tied(%{$newval}));
 486     } else {
 487         $self->$member_func($newval);
 488     }
 489 }
 490
 491
 492 ############# Class : IDZebra::scanEntry ##############
 493
 494 package IDZebra::scanEntry;
 495 @ISA = qw( IDZebra );
 496 %OWNER = ();
 497 %BLESSEDMEMBERS = (
 498 );
 499
 500 %ITERATORS = ();
 501 *swig_occurrences_get = *IDZebrac::scanEntry_occurrences_get;
 502 *swig_occurrences_set = *IDZebrac::scanEntry_occurrences_set;
 503 *swig_term_get = *IDZebrac::scanEntry_term_get;
 504 *swig_term_set = *IDZebrac::scanEntry_term_set;
 505 sub new {
 506     my $pkg = shift;
 507     my @args = @_;
 508     my $self = IDZebrac::new_scanEntry(@args);
 509     return undef if (!defined($self));
 510     $OWNER{$self} = 1;
 511     my %retval;
 512     tie %retval, "IDZebra::scanEntry", $self;
 513     return bless \%retval, $pkg;
 514 }
 515
 516 sub DESTROY {
 517     return unless $_[0]->isa('HASH');
 518     my $self = tied(%{$_[0]});
 519     return unless defined $self;
 520     delete $ITERATORS{$self};
 521     if (exists $OWNER{$self}) {
 522         IDZebrac::delete_scanEntry($self);
 523         delete $OWNER{$self};
 524     }
 525 }
 526
 527 sub DISOWN {
 528     my $self = shift;
 529     my $ptr = tied(%$self);
 530     delete $OWNER{$ptr};
 531     };
 532
 533 sub ACQUIRE {
 534     my $self = shift;
 535     my $ptr = tied(%$self);
 536     $OWNER{$ptr} = 1;
 537     };
 538
 539 sub FETCH {
 540     my ($self,$field) = @_;
 541     my $member_func = "swig_${field}_get";
 542     my $val = $self->$member_func();
 543     if (exists $BLESSEDMEMBERS{$field}) {
 544         return undef if (!defined($val));
 545         my %retval;
 546         tie %retval,$BLESSEDMEMBERS{$field},$val;
 547         return bless \%retval, $BLESSEDMEMBERS{$field};
 548     }
 549     return $val;
 550 }
 551
 552 sub STORE {
 553     my ($self,$field,$newval) = @_;
 554     my $member_func = "swig_${field}_set";
 555     if (exists $BLESSEDMEMBERS{$field}) {
 556         $self->$member_func(tied(%{$newval}));
 557     } else {
 558         $self->$member_func($newval);
 559     }
 560 }
 561
 562
 563 ############# Class : IDZebra::ScanObj ##############
 564
 565 package IDZebra::ScanObj;
 566 @ISA = qw( IDZebra );
 567 %OWNER = ();
 568 %BLESSEDMEMBERS = (
 569     entries => 'IDZebra::scanEntry',
 570 );
 571
 572 %ITERATORS = ();
 573 *swig_num_entries_get = *IDZebrac::ScanObj_num_entries_get;
 574 *swig_num_entries_set = *IDZebrac::ScanObj_num_entries_set;
 575 *swig_position_get = *IDZebrac::ScanObj_position_get;
 576 *swig_position_set = *IDZebrac::ScanObj_position_set;
 577 *swig_is_partial_get = *IDZebrac::ScanObj_is_partial_get;
 578 *swig_is_partial_set = *IDZebrac::ScanObj_is_partial_set;
 579 *swig_entries_get = *IDZebrac::ScanObj_entries_get;
 580 *swig_entries_set = *IDZebrac::ScanObj_entries_set;
 581 sub new {
 582     my $pkg = shift;
 583     my @args = @_;
 584     my $self = IDZebrac::new_ScanObj(@args);
 585     return undef if (!defined($self));
 586     $OWNER{$self} = 1;
 587     my %retval;
 588     tie %retval, "IDZebra::ScanObj", $self;
 589     return bless \%retval, $pkg;
 590 }
 591
 592 sub DESTROY {
 593     return unless $_[0]->isa('HASH');
 594     my $self = tied(%{$_[0]});
 595     return unless defined $self;
 596     delete $ITERATORS{$self};
 597     if (exists $OWNER{$self}) {
 598         IDZebrac::delete_ScanObj($self);
 599         delete $OWNER{$self};
 600     }
 601 }
 602
 603 sub DISOWN {
 604     my $self = shift;
 605     my $ptr = tied(%$self);
 606     delete $OWNER{$ptr};
 607     };
 608
 609 sub ACQUIRE {
 610     my $self = shift;
 611     my $ptr = tied(%$self);
 612     $OWNER{$ptr} = 1;
 613     };
 614
 615 sub FETCH {
 616     my ($self,$field) = @_;
 617     my $member_func = "swig_${field}_get";
 618     my $val = $self->$member_func();
 619     if (exists $BLESSEDMEMBERS{$field}) {
 620         return undef if (!defined($val));
 621         my %retval;
 622         tie %retval,$BLESSEDMEMBERS{$field},$val;
 623         return bless \%retval, $BLESSEDMEMBERS{$field};
 624     }
 625     return $val;
 626 }
 627
 628 sub STORE {
 629     my ($self,$field,$newval) = @_;
 630     my $member_func = "swig_${field}_set";
 631     if (exists $BLESSEDMEMBERS{$field}) {
 632         $self->$member_func(tied(%{$newval}));
 633     } else {
 634         $self->$member_func($newval);
 635     }
 636 }
 637
 638
 639 ############# Class : IDZebra::ZebraTransactionStatus ##############
 640
 641 package IDZebra::ZebraTransactionStatus;
 642 @ISA = qw( IDZebra );
 643 %OWNER = ();
 644 %BLESSEDMEMBERS = (
 645 );
 646
 647 %ITERATORS = ();
 648 *swig_processed_get = *IDZebrac::ZebraTransactionStatus_processed_get;
 649 *swig_processed_set = *IDZebrac::ZebraTransactionStatus_processed_set;
 650 *swig_inserted_get = *IDZebrac::ZebraTransactionStatus_inserted_get;
 651 *swig_inserted_set = *IDZebrac::ZebraTransactionStatus_inserted_set;
 652 *swig_updated_get = *IDZebrac::ZebraTransactionStatus_updated_get;
 653 *swig_updated_set = *IDZebrac::ZebraTransactionStatus_updated_set;
 654 *swig_deleted_get = *IDZebrac::ZebraTransactionStatus_deleted_get;
 655 *swig_deleted_set = *IDZebrac::ZebraTransactionStatus_deleted_set;
 656 *swig_utime_get = *IDZebrac::ZebraTransactionStatus_utime_get;
 657 *swig_utime_set = *IDZebrac::ZebraTransactionStatus_utime_set;
 658 *swig_stime_get = *IDZebrac::ZebraTransactionStatus_stime_get;
 659 *swig_stime_set = *IDZebrac::ZebraTransactionStatus_stime_set;
 660 sub new {
 661     my $pkg = shift;
 662     my @args = @_;
 663     my $self = IDZebrac::new_ZebraTransactionStatus(@args);
 664     return undef if (!defined($self));
 665     $OWNER{$self} = 1;
 666     my %retval;
 667     tie %retval, "IDZebra::ZebraTransactionStatus", $self;
 668     return bless \%retval, $pkg;
 669 }
 670
 671 sub DESTROY {
 672     return unless $_[0]->isa('HASH');
 673     my $self = tied(%{$_[0]});
 674     return unless defined $self;
 675     delete $ITERATORS{$self};
 676     if (exists $OWNER{$self}) {
 677         IDZebrac::delete_ZebraTransactionStatus($self);
 678         delete $OWNER{$self};
 679     }
 680 }
 681
 682 sub DISOWN {
 683     my $self = shift;
 684     my $ptr = tied(%$self);
 685     delete $OWNER{$ptr};
 686     };
 687
 688 sub ACQUIRE {
 689     my $self = shift;
 690     my $ptr = tied(%$self);
 691     $OWNER{$ptr} = 1;
 692     };
 693
 694 sub FETCH {
 695     my ($self,$field) = @_;
 696     my $member_func = "swig_${field}_get";
 697     my $val = $self->$member_func();
 698     if (exists $BLESSEDMEMBERS{$field}) {
 699         return undef if (!defined($val));
 700         my %retval;
 701         tie %retval,$BLESSEDMEMBERS{$field},$val;
 702         return bless \%retval, $BLESSEDMEMBERS{$field};
 703     }
 704     return $val;
 705 }
 706
 707 sub STORE {
 708     my ($self,$field,$newval) = @_;
 709     my $member_func = "swig_${field}_set";
 710     if (exists $BLESSEDMEMBERS{$field}) {
 711         $self->$member_func(tied(%{$newval}));
 712     } else {
 713         $self->$member_func($newval);
 714     }
 715 }
 716
 717
 718 # ------- VARIABLE STUBS --------
 719
 720 package IDZebra;
 721
 722 *LOG_FATAL = *IDZebrac::LOG_FATAL;
 723 *LOG_DEBUG = *IDZebrac::LOG_DEBUG;
 724 *LOG_WARN = *IDZebrac::LOG_WARN;
 725 *LOG_LOG = *IDZebrac::LOG_LOG;
 726 *LOG_ERRNO = *IDZebrac::LOG_ERRNO;
 727 *LOG_FILE = *IDZebrac::LOG_FILE;
 728 *LOG_APP = *IDZebrac::LOG_APP;
 729 *LOG_MALLOC = *IDZebrac::LOG_MALLOC;
 730 *LOG_ALL = *IDZebrac::LOG_ALL;
 731 *LOG_DEFAULT_LEVEL = *IDZebrac::LOG_DEFAULT_LEVEL;
 732 *ODR_DECODE = *IDZebrac::ODR_DECODE;
 733 *ODR_ENCODE = *IDZebrac::ODR_ENCODE;
 734 *ODR_PRINT = *IDZebrac::ODR_PRINT;
 735 *DATA1K_unknown = *IDZebrac::DATA1K_unknown;
 736 *DATA1K_structured = *IDZebrac::DATA1K_structured;
 737 *DATA1K_string = *IDZebrac::DATA1K_string;
 738 *DATA1K_numeric = *IDZebrac::DATA1K_numeric;
 739 *DATA1K_bool = *IDZebrac::DATA1K_bool;
 740 *DATA1K_oid = *IDZebrac::DATA1K_oid;
 741 *DATA1K_generalizedtime = *IDZebrac::DATA1K_generalizedtime;
 742 *DATA1K_intunit = *IDZebrac::DATA1K_intunit;
 743 *DATA1K_int = *IDZebrac::DATA1K_int;
 744 *DATA1K_octetstring = *IDZebrac::DATA1K_octetstring;
 745 *DATA1K_null = *IDZebrac::DATA1K_null;
 746 *DATA1T_numeric = *IDZebrac::DATA1T_numeric;
 747 *DATA1T_string = *IDZebrac::DATA1T_string;
 748 *DATA1N_root = *IDZebrac::DATA1N_root;
 749 *DATA1N_tag = *IDZebrac::DATA1N_tag;
 750 *DATA1N_data = *IDZebrac::DATA1N_data;
 751 *DATA1N_variant = *IDZebrac::DATA1N_variant;
 752 *DATA1N_comment = *IDZebrac::DATA1N_comment;
 753 *DATA1N_preprocess = *IDZebrac::DATA1N_preprocess;
 754 *DATA1I_inctxt = *IDZebrac::DATA1I_inctxt;
 755 *DATA1I_incbin = *IDZebrac::DATA1I_incbin;
 756 *DATA1I_text = *IDZebrac::DATA1I_text;
 757 *DATA1I_num = *IDZebrac::DATA1I_num;
 758 *DATA1I_oid = *IDZebrac::DATA1I_oid;
 759 *DATA1_LOCALDATA = *IDZebrac::DATA1_LOCALDATA;
 760 *DATA1_FLAG_XML = *IDZebrac::DATA1_FLAG_XML;
 761 1;