idzebra.pm

harvest是一个下载html网页得机器人

%ITERATORS = ();
*swig_errCode_get = *IDZebrac::RetrievalRecord_errCode_get;
*swig_errCode_set = *IDZebrac::RetrievalRecord_errCode_set;
*swig_errString_get = *IDZebrac::RetrievalRecord_errString_get;
*swig_errString_set = *IDZebrac::RetrievalRecord_errString_set;
*swig_position_get = *IDZebrac::RetrievalRecord_position_get;
*swig_position_set = *IDZebrac::RetrievalRecord_position_set;
*swig_base_get = *IDZebrac::RetrievalRecord_base_get;
*swig_base_set = *IDZebrac::RetrievalRecord_base_set;
*swig_sysno_get = *IDZebrac::RetrievalRecord_sysno_get;
*swig_sysno_set = *IDZebrac::RetrievalRecord_sysno_set;
*swig_score_get = *IDZebrac::RetrievalRecord_score_get;
*swig_score_set = *IDZebrac::RetrievalRecord_score_set;
*swig_format_get = *IDZebrac::RetrievalRecord_format_get;
*swig_format_set = *IDZebrac::RetrievalRecord_format_set;
*swig_buf_get = *IDZebrac::RetrievalRecord_buf_get;
*swig_buf_set = *IDZebrac::RetrievalRecord_buf_set;
sub new {
    my $pkg = shift;
    my @args = @_;
    my $self = IDZebrac::new_RetrievalRecord(@args);
    return undef if (!defined($self));
    $OWNER{$self} = 1;
    my %retval;
    tie %retval, "IDZebra::RetrievalRecord", $self;
    return bless \%retval, $pkg;
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        IDZebrac::delete_RetrievalRecord($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
    };

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
    };

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    my $val = $self->$member_func();
    if (exists $BLESSEDMEMBERS{$field}) {
        return undef if (!defined($val));
        my %retval;
        tie %retval,$BLESSEDMEMBERS{$field},$val;
        return bless \%retval, $BLESSEDMEMBERS{$field};
    }
    return $val;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (exists $BLESSEDMEMBERS{$field}) {
        $self->$member_func(tied(%{$newval}));
    } else {
        $self->$member_func($newval);
    }
}


############# Class : IDZebra::scanEntry ##############

package IDZebra::scanEntry;
@ISA = qw( IDZebra );
%OWNER = ();
%BLESSEDMEMBERS = (
);

%ITERATORS = ();
*swig_occurrences_get = *IDZebrac::scanEntry_occurrences_get;
*swig_occurrences_set = *IDZebrac::scanEntry_occurrences_set;
*swig_term_get = *IDZebrac::scanEntry_term_get;
*swig_term_set = *IDZebrac::scanEntry_term_set;
sub new {
    my $pkg = shift;
    my @args = @_;
    my $self = IDZebrac::new_scanEntry(@args);
    return undef if (!defined($self));
    $OWNER{$self} = 1;
    my %retval;
    tie %retval, "IDZebra::scanEntry", $self;
    return bless \%retval, $pkg;
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        IDZebrac::delete_scanEntry($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
    };

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
    };

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    my $val = $self->$member_func();
    if (exists $BLESSEDMEMBERS{$field}) {
        return undef if (!defined($val));
        my %retval;
        tie %retval,$BLESSEDMEMBERS{$field},$val;
        return bless \%retval, $BLESSEDMEMBERS{$field};
    }
    return $val;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (exists $BLESSEDMEMBERS{$field}) {
        $self->$member_func(tied(%{$newval}));
    } else {
        $self->$member_func($newval);
    }
}


############# Class : IDZebra::ScanObj ##############

package IDZebra::ScanObj;
@ISA = qw( IDZebra );
%OWNER = ();
%BLESSEDMEMBERS = (
    entries => 'IDZebra::scanEntry',
);

%ITERATORS = ();
*swig_num_entries_get = *IDZebrac::ScanObj_num_entries_get;
*swig_num_entries_set = *IDZebrac::ScanObj_num_entries_set;
*swig_position_get = *IDZebrac::ScanObj_position_get;
*swig_position_set = *IDZebrac::ScanObj_position_set;
*swig_is_partial_get = *IDZebrac::ScanObj_is_partial_get;
*swig_is_partial_set = *IDZebrac::ScanObj_is_partial_set;
*swig_entries_get = *IDZebrac::ScanObj_entries_get;
*swig_entries_set = *IDZebrac::ScanObj_entries_set;
sub new {
    my $pkg = shift;
    my @args = @_;
    my $self = IDZebrac::new_ScanObj(@args);
    return undef if (!defined($self));
    $OWNER{$self} = 1;
    my %retval;
    tie %retval, "IDZebra::ScanObj", $self;
    return bless \%retval, $pkg;
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        IDZebrac::delete_ScanObj($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
    };

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
    };

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    my $val = $self->$member_func();
    if (exists $BLESSEDMEMBERS{$field}) {
        return undef if (!defined($val));
        my %retval;
        tie %retval,$BLESSEDMEMBERS{$field},$val;
        return bless \%retval, $BLESSEDMEMBERS{$field};
    }
    return $val;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (exists $BLESSEDMEMBERS{$field}) {
        $self->$member_func(tied(%{$newval}));
    } else {
        $self->$member_func($newval);
    }
}


############# Class : IDZebra::ZebraTransactionStatus ##############

package IDZebra::ZebraTransactionStatus;
@ISA = qw( IDZebra );
%OWNER = ();
%BLESSEDMEMBERS = (
);

%ITERATORS = ();
*swig_processed_get = *IDZebrac::ZebraTransactionStatus_processed_get;
*swig_processed_set = *IDZebrac::ZebraTransactionStatus_processed_set;
*swig_inserted_get = *IDZebrac::ZebraTransactionStatus_inserted_get;
*swig_inserted_set = *IDZebrac::ZebraTransactionStatus_inserted_set;
*swig_updated_get = *IDZebrac::ZebraTransactionStatus_updated_get;
*swig_updated_set = *IDZebrac::ZebraTransactionStatus_updated_set;
*swig_deleted_get = *IDZebrac::ZebraTransactionStatus_deleted_get;
*swig_deleted_set = *IDZebrac::ZebraTransactionStatus_deleted_set;
*swig_utime_get = *IDZebrac::ZebraTransactionStatus_utime_get;
*swig_utime_set = *IDZebrac::ZebraTransactionStatus_utime_set;
*swig_stime_get = *IDZebrac::ZebraTransactionStatus_stime_get;
*swig_stime_set = *IDZebrac::ZebraTransactionStatus_stime_set;
sub new {
    my $pkg = shift;
    my @args = @_;
    my $self = IDZebrac::new_ZebraTransactionStatus(@args);
    return undef if (!defined($self));
    $OWNER{$self} = 1;
    my %retval;
    tie %retval, "IDZebra::ZebraTransactionStatus", $self;
    return bless \%retval, $pkg;
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        IDZebrac::delete_ZebraTransactionStatus($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
    };

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
    };

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    my $val = $self->$member_func();
    if (exists $BLESSEDMEMBERS{$field}) {
        return undef if (!defined($val));
        my %retval;
        tie %retval,$BLESSEDMEMBERS{$field},$val;
        return bless \%retval, $BLESSEDMEMBERS{$field};
    }
    return $val;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (exists $BLESSEDMEMBERS{$field}) {
        $self->$member_func(tied(%{$newval}));
    } else {
        $self->$member_func($newval);
    }
}


# ------- VARIABLE STUBS --------

package IDZebra;

*LOG_FATAL = *IDZebrac::LOG_FATAL;
*LOG_DEBUG = *IDZebrac::LOG_DEBUG;
*LOG_WARN = *IDZebrac::LOG_WARN;
*LOG_LOG = *IDZebrac::LOG_LOG;
*LOG_ERRNO = *IDZebrac::LOG_ERRNO;
*LOG_FILE = *IDZebrac::LOG_FILE;
*LOG_APP = *IDZebrac::LOG_APP;
*LOG_MALLOC = *IDZebrac::LOG_MALLOC;
*LOG_ALL = *IDZebrac::LOG_ALL;
*LOG_DEFAULT_LEVEL = *IDZebrac::LOG_DEFAULT_LEVEL;
*ODR_DECODE = *IDZebrac::ODR_DECODE;
*ODR_ENCODE = *IDZebrac::ODR_ENCODE;
*ODR_PRINT = *IDZebrac::ODR_PRINT;
*DATA1K_unknown = *IDZebrac::DATA1K_unknown;
*DATA1K_structured = *IDZebrac::DATA1K_structured;
*DATA1K_string = *IDZebrac::DATA1K_string;
*DATA1K_numeric = *IDZebrac::DATA1K_numeric;
*DATA1K_bool = *IDZebrac::DATA1K_bool;
*DATA1K_oid = *IDZebrac::DATA1K_oid;
*DATA1K_generalizedtime = *IDZebrac::DATA1K_generalizedtime;
*DATA1K_intunit = *IDZebrac::DATA1K_intunit;
*DATA1K_int = *IDZebrac::DATA1K_int;
*DATA1K_octetstring = *IDZebrac::DATA1K_octetstring;
*DATA1K_null = *IDZebrac::DATA1K_null;
*DATA1T_numeric = *IDZebrac::DATA1T_numeric;
*DATA1T_string = *IDZebrac::DATA1T_string;
*DATA1N_root = *IDZebrac::DATA1N_root;
*DATA1N_tag = *IDZebrac::DATA1N_tag;
*DATA1N_data = *IDZebrac::DATA1N_data;
*DATA1N_variant = *IDZebrac::DATA1N_variant;
*DATA1N_comment = *IDZebrac::DATA1N_comment;
*DATA1N_preprocess = *IDZebrac::DATA1N_preprocess;
*DATA1I_inctxt = *IDZebrac::DATA1I_inctxt;
*DATA1I_incbin = *IDZebrac::DATA1I_incbin;
*DATA1I_text = *IDZebrac::DATA1I_text;
*DATA1I_num = *IDZebrac::DATA1I_num;
*DATA1I_oid = *IDZebrac::DATA1I_oid;
*DATA1_LOCALDATA = *IDZebrac::DATA1_LOCALDATA;
*DATA1_FLAG_XML = *IDZebrac::DATA1_FLAG_XML;
1;