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