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