# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

package solv;
use base qw(Exporter);
use base qw(DynaLoader);
package solvc;
bootstrap solv;
package solv;
@EXPORT = qw();

# ---------- BASE METHODS -------------

package solv;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package solv;

*xfopen = *solvc::xfopen;
*xfopen_fd = *solvc::xfopen_fd;

############# Class : solv::Selection ##############

package solv::Selection;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_pool_get = *solvc::Selection_pool_get;
*swig_pool_set = *solvc::Selection_pool_set;
*swig_flags_get = *solvc::Selection_flags_get;
*swig_flags_set = *solvc::Selection_flags_set;
*SELECTION_NAME = *solvc::Selection_SELECTION_NAME;
*SELECTION_NAME = *solvc::Selection_SELECTION_NAME;
*SELECTION_PROVIDES = *solvc::Selection_SELECTION_PROVIDES;
*SELECTION_PROVIDES = *solvc::Selection_SELECTION_PROVIDES;
*SELECTION_FILELIST = *solvc::Selection_SELECTION_FILELIST;
*SELECTION_FILELIST = *solvc::Selection_SELECTION_FILELIST;
*SELECTION_CANON = *solvc::Selection_SELECTION_CANON;
*SELECTION_CANON = *solvc::Selection_SELECTION_CANON;
*SELECTION_DOTARCH = *solvc::Selection_SELECTION_DOTARCH;
*SELECTION_DOTARCH = *solvc::Selection_SELECTION_DOTARCH;
*SELECTION_REL = *solvc::Selection_SELECTION_REL;
*SELECTION_REL = *solvc::Selection_SELECTION_REL;
*SELECTION_INSTALLED_ONLY = *solvc::Selection_SELECTION_INSTALLED_ONLY;
*SELECTION_INSTALLED_ONLY = *solvc::Selection_SELECTION_INSTALLED_ONLY;
*SELECTION_GLOB = *solvc::Selection_SELECTION_GLOB;
*SELECTION_GLOB = *solvc::Selection_SELECTION_GLOB;
*SELECTION_FLAT = *solvc::Selection_SELECTION_FLAT;
*SELECTION_FLAT = *solvc::Selection_SELECTION_FLAT;
*SELECTION_NOCASE = *solvc::Selection_SELECTION_NOCASE;
*SELECTION_NOCASE = *solvc::Selection_SELECTION_NOCASE;
*SELECTION_SKIP_KIND = *solvc::Selection_SELECTION_SKIP_KIND;
*SELECTION_SKIP_KIND = *solvc::Selection_SELECTION_SKIP_KIND;
*SELECTION_MATCH_DEPSTR = *solvc::Selection_SELECTION_MATCH_DEPSTR;
*SELECTION_MATCH_DEPSTR = *solvc::Selection_SELECTION_MATCH_DEPSTR;
*SELECTION_SOURCE_ONLY = *solvc::Selection_SELECTION_SOURCE_ONLY;
*SELECTION_SOURCE_ONLY = *solvc::Selection_SELECTION_SOURCE_ONLY;
*SELECTION_WITH_SOURCE = *solvc::Selection_SELECTION_WITH_SOURCE;
*SELECTION_WITH_SOURCE = *solvc::Selection_SELECTION_WITH_SOURCE;
*SELECTION_WITH_DISABLED = *solvc::Selection_SELECTION_WITH_DISABLED;
*SELECTION_WITH_DISABLED = *solvc::Selection_SELECTION_WITH_DISABLED;
*SELECTION_WITH_BADARCH = *solvc::Selection_SELECTION_WITH_BADARCH;
*SELECTION_WITH_BADARCH = *solvc::Selection_SELECTION_WITH_BADARCH;
*SELECTION_WITH_ALL = *solvc::Selection_SELECTION_WITH_ALL;
*SELECTION_WITH_ALL = *solvc::Selection_SELECTION_WITH_ALL;
*SELECTION_ADD = *solvc::Selection_SELECTION_ADD;
*SELECTION_ADD = *solvc::Selection_SELECTION_ADD;
*SELECTION_SUBTRACT = *solvc::Selection_SELECTION_SUBTRACT;
*SELECTION_SUBTRACT = *solvc::Selection_SELECTION_SUBTRACT;
*SELECTION_FILTER = *solvc::Selection_SELECTION_FILTER;
*SELECTION_FILTER = *solvc::Selection_SELECTION_FILTER;
*SELECTION_FILTER_KEEP_IFEMPTY = *solvc::Selection_SELECTION_FILTER_KEEP_IFEMPTY;
*SELECTION_FILTER_KEEP_IFEMPTY = *solvc::Selection_SELECTION_FILTER_KEEP_IFEMPTY;
*SELECTION_FILTER_SWAPPED = *solvc::Selection_SELECTION_FILTER_SWAPPED;
*SELECTION_FILTER_SWAPPED = *solvc::Selection_SELECTION_FILTER_SWAPPED;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Selection(@_);
    bless $self, $pkg if defined($self);
}

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

*isempty = *solvc::Selection_isempty;
*clone = *solvc::Selection_clone;
*filter = *solvc::Selection_filter;
*add = *solvc::Selection_add;
*add_raw = *solvc::Selection_add_raw;
*subtract = *solvc::Selection_subtract;
*select = *solvc::Selection_select;
*matchdeps = *solvc::Selection_matchdeps;
*matchdepid = *solvc::Selection_matchdepid;
*matchsolvable = *solvc::Selection_matchsolvable;
*jobs = *solvc::Selection_jobs;
*solvables = *solvc::Selection_solvables;
*str = *solvc::Selection_str;
*repr = *solvc::Selection_repr;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Dep ##############

package solv::Dep;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_pool_get = *solvc::Dep_pool_get;
*swig_pool_set = *solvc::Dep_pool_set;
*swig_id_get = *solvc::Dep_id_get;
*swig_id_set = *solvc::Dep_id_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Dep(@_);
    bless $self, $pkg if defined($self);
}

*Rel = *solvc::Dep_Rel;
*Selection_name = *solvc::Dep_Selection_name;
*Selection_provides = *solvc::Dep_Selection_provides;
*str = *solvc::Dep_str;
*__eq__ = *solvc::Dep___eq__;
*__ne__ = *solvc::Dep___ne__;
*repr = *solvc::Dep_repr;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Dep($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;
}


############# Class : solv::Dataiterator ##############

package solv::Dataiterator;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*SEARCH_STRING = *solvc::Dataiterator_SEARCH_STRING;
*SEARCH_STRING = *solvc::Dataiterator_SEARCH_STRING;
*SEARCH_STRINGSTART = *solvc::Dataiterator_SEARCH_STRINGSTART;
*SEARCH_STRINGSTART = *solvc::Dataiterator_SEARCH_STRINGSTART;
*SEARCH_STRINGEND = *solvc::Dataiterator_SEARCH_STRINGEND;
*SEARCH_STRINGEND = *solvc::Dataiterator_SEARCH_STRINGEND;
*SEARCH_SUBSTRING = *solvc::Dataiterator_SEARCH_SUBSTRING;
*SEARCH_SUBSTRING = *solvc::Dataiterator_SEARCH_SUBSTRING;
*SEARCH_GLOB = *solvc::Dataiterator_SEARCH_GLOB;
*SEARCH_GLOB = *solvc::Dataiterator_SEARCH_GLOB;
*SEARCH_REGEX = *solvc::Dataiterator_SEARCH_REGEX;
*SEARCH_REGEX = *solvc::Dataiterator_SEARCH_REGEX;
*SEARCH_NOCASE = *solvc::Dataiterator_SEARCH_NOCASE;
*SEARCH_NOCASE = *solvc::Dataiterator_SEARCH_NOCASE;
*SEARCH_FILES = *solvc::Dataiterator_SEARCH_FILES;
*SEARCH_FILES = *solvc::Dataiterator_SEARCH_FILES;
*SEARCH_COMPLETE_FILELIST = *solvc::Dataiterator_SEARCH_COMPLETE_FILELIST;
*SEARCH_COMPLETE_FILELIST = *solvc::Dataiterator_SEARCH_COMPLETE_FILELIST;
*SEARCH_CHECKSUMS = *solvc::Dataiterator_SEARCH_CHECKSUMS;
*SEARCH_CHECKSUMS = *solvc::Dataiterator_SEARCH_CHECKSUMS;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Dataiterator(@_);
    bless $self, $pkg if defined($self);
}

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

*__next__ = *solvc::Dataiterator___next__;
*prepend_keyname = *solvc::Dataiterator_prepend_keyname;
*skip_solvable = *solvc::Dataiterator_skip_solvable;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::XSolvable ##############

package solv::XSolvable;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_pool_get = *solvc::XSolvable_pool_get;
*swig_pool_set = *solvc::XSolvable_pool_set;
*swig_id_get = *solvc::XSolvable_id_get;
*swig_id_set = *solvc::XSolvable_id_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_XSolvable(@_);
    bless $self, $pkg if defined($self);
}

*str = *solvc::XSolvable_str;
*lookup_str = *solvc::XSolvable_lookup_str;
*lookup_id = *solvc::XSolvable_lookup_id;
*lookup_num = *solvc::XSolvable_lookup_num;
*lookup_void = *solvc::XSolvable_lookup_void;
*lookup_checksum = *solvc::XSolvable_lookup_checksum;
*lookup_idarray = *solvc::XSolvable_lookup_idarray;
*lookup_deparray = *solvc::XSolvable_lookup_deparray;
*lookup_location = *solvc::XSolvable_lookup_location;
*lookup_sourcepkg = *solvc::XSolvable_lookup_sourcepkg;
*Dataiterator = *solvc::XSolvable_Dataiterator;
*installable = *solvc::XSolvable_installable;
*isinstalled = *solvc::XSolvable_isinstalled;
*swig_name_get = *solvc::XSolvable_name_get;
*swig_name_set = *solvc::XSolvable_name_set;
*swig_nameid_get = *solvc::XSolvable_nameid_get;
*swig_nameid_set = *solvc::XSolvable_nameid_set;
*swig_evr_get = *solvc::XSolvable_evr_get;
*swig_evr_set = *solvc::XSolvable_evr_set;
*swig_evrid_get = *solvc::XSolvable_evrid_get;
*swig_evrid_set = *solvc::XSolvable_evrid_set;
*swig_arch_get = *solvc::XSolvable_arch_get;
*swig_arch_set = *solvc::XSolvable_arch_set;
*swig_archid_get = *solvc::XSolvable_archid_get;
*swig_archid_set = *solvc::XSolvable_archid_set;
*swig_vendor_get = *solvc::XSolvable_vendor_get;
*swig_vendor_set = *solvc::XSolvable_vendor_set;
*swig_vendorid_get = *solvc::XSolvable_vendorid_get;
*swig_vendorid_set = *solvc::XSolvable_vendorid_set;
*swig_repo_get = *solvc::XSolvable_repo_get;
*swig_repo_set = *solvc::XSolvable_repo_set;
*add_provides = *solvc::XSolvable_add_provides;
*add_obsoletes = *solvc::XSolvable_add_obsoletes;
*add_conflicts = *solvc::XSolvable_add_conflicts;
*add_requires = *solvc::XSolvable_add_requires;
*add_recommends = *solvc::XSolvable_add_recommends;
*add_suggests = *solvc::XSolvable_add_suggests;
*add_supplements = *solvc::XSolvable_add_supplements;
*add_enhances = *solvc::XSolvable_add_enhances;
*unset = *solvc::XSolvable_unset;
*add_deparray = *solvc::XSolvable_add_deparray;
*Selection = *solvc::XSolvable_Selection;
*identical = *solvc::XSolvable_identical;
*evrcmp = *solvc::XSolvable_evrcmp;
*matchesdep = *solvc::XSolvable_matchesdep;
*__eq__ = *solvc::XSolvable___eq__;
*__ne__ = *solvc::XSolvable___ne__;
*repr = *solvc::XSolvable_repr;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_XSolvable($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;
}


############# Class : solv::Ruleinfo ##############

package solv::Ruleinfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_solv_get = *solvc::Ruleinfo_solv_get;
*swig_solv_set = *solvc::Ruleinfo_solv_set;
*swig_type_get = *solvc::Ruleinfo_type_get;
*swig_type_set = *solvc::Ruleinfo_type_set;
*swig_dep_id_get = *solvc::Ruleinfo_dep_id_get;
*swig_dep_id_set = *solvc::Ruleinfo_dep_id_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Ruleinfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_solvable_get = *solvc::Ruleinfo_solvable_get;
*swig_solvable_set = *solvc::Ruleinfo_solvable_set;
*swig_othersolvable_get = *solvc::Ruleinfo_othersolvable_get;
*swig_othersolvable_set = *solvc::Ruleinfo_othersolvable_set;
*swig_dep_get = *solvc::Ruleinfo_dep_get;
*swig_dep_set = *solvc::Ruleinfo_dep_set;
*problemstr = *solvc::Ruleinfo_problemstr;
*str = *solvc::Ruleinfo_str;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Ruleinfo($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;
}


############# Class : solv::XRule ##############

package solv::XRule;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_solv_get = *solvc::XRule_solv_get;
*swig_solv_set = *solvc::XRule_solv_set;
*swig_id_get = *solvc::XRule_id_get;
*swig_id_set = *solvc::XRule_id_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_XRule(@_);
    bless $self, $pkg if defined($self);
}

*swig_type_get = *solvc::XRule_type_get;
*swig_type_set = *solvc::XRule_type_set;
*info = *solvc::XRule_info;
*allinfos = *solvc::XRule_allinfos;
*get_learnt = *solvc::XRule_get_learnt;
*get_decisionlist = *solvc::XRule_get_decisionlist;
*get_decisionsetlist = *solvc::XRule_get_decisionsetlist;
*__eq__ = *solvc::XRule___eq__;
*__ne__ = *solvc::XRule___ne__;
*repr = *solvc::XRule_repr;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_XRule($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;
}


############# Class : solv::XRepodata ##############

package solv::XRepodata;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_repo_get = *solvc::XRepodata_repo_get;
*swig_repo_set = *solvc::XRepodata_repo_set;
*swig_id_get = *solvc::XRepodata_id_get;
*swig_id_set = *solvc::XRepodata_id_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_XRepodata(@_);
    bless $self, $pkg if defined($self);
}

*new_handle = *solvc::XRepodata_new_handle;
*set_id = *solvc::XRepodata_set_id;
*set_num = *solvc::XRepodata_set_num;
*set_str = *solvc::XRepodata_set_str;
*set_void = *solvc::XRepodata_set_void;
*set_poolstr = *solvc::XRepodata_set_poolstr;
*add_idarray = *solvc::XRepodata_add_idarray;
*add_flexarray = *solvc::XRepodata_add_flexarray;
*set_checksum = *solvc::XRepodata_set_checksum;
*set_sourcepkg = *solvc::XRepodata_set_sourcepkg;
*set_location = *solvc::XRepodata_set_location;
*unset = *solvc::XRepodata_unset;
*lookup_str = *solvc::XRepodata_lookup_str;
*lookup_id = *solvc::XRepodata_lookup_id;
*lookup_num = *solvc::XRepodata_lookup_num;
*lookup_void = *solvc::XRepodata_lookup_void;
*lookup_idarray = *solvc::XRepodata_lookup_idarray;
*lookup_checksum = *solvc::XRepodata_lookup_checksum;
*internalize = *solvc::XRepodata_internalize;
*create_stubs = *solvc::XRepodata_create_stubs;
*write = *solvc::XRepodata_write;
*str2dir = *solvc::XRepodata_str2dir;
*dir2str = *solvc::XRepodata_dir2str;
*add_dirstr = *solvc::XRepodata_add_dirstr;
*add_solv = *solvc::XRepodata_add_solv;
*extend_to_repo = *solvc::XRepodata_extend_to_repo;
*__eq__ = *solvc::XRepodata___eq__;
*__ne__ = *solvc::XRepodata___ne__;
*repr = *solvc::XRepodata_repr;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_XRepodata($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;
}


############# Class : solv::Pool_solvable_iterator ##############

package solv::Pool_solvable_iterator;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = solvc::new_Pool_solvable_iterator(@_);
    bless $self, $pkg if defined($self);
}

*__next__ = *solvc::Pool_solvable_iterator___next__;
*__getitem__ = *solvc::Pool_solvable_iterator___getitem__;
*__len__ = *solvc::Pool_solvable_iterator___len__;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Pool_solvable_iterator($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;
}


############# Class : solv::Pool_repo_iterator ##############

package solv::Pool_repo_iterator;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = solvc::new_Pool_repo_iterator(@_);
    bless $self, $pkg if defined($self);
}

*__next__ = *solvc::Pool_repo_iterator___next__;
*__getitem__ = *solvc::Pool_repo_iterator___getitem__;
*__len__ = *solvc::Pool_repo_iterator___len__;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Pool_repo_iterator($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;
}


############# Class : solv::Repo_solvable_iterator ##############

package solv::Repo_solvable_iterator;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = solvc::new_Repo_solvable_iterator(@_);
    bless $self, $pkg if defined($self);
}

*__next__ = *solvc::Repo_solvable_iterator___next__;
*__getitem__ = *solvc::Repo_solvable_iterator___getitem__;
*__len__ = *solvc::Repo_solvable_iterator___len__;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Repo_solvable_iterator($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;
}


############# Class : solv::Datamatch ##############

package solv::Datamatch;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_pool_get = *solvc::Datamatch_pool_get;
*swig_pool_set = *solvc::Datamatch_pool_set;
*swig_repo_get = *solvc::Datamatch_repo_get;
*swig_repo_set = *solvc::Datamatch_repo_set;
*swig_solvid_get = *solvc::Datamatch_solvid_get;
*swig_solvid_set = *solvc::Datamatch_solvid_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Datamatch($self);
        delete $OWNER{$self};
    }
}

*swig_solvable_get = *solvc::Datamatch_solvable_get;
*swig_solvable_set = *solvc::Datamatch_solvable_set;
*swig_key_id_get = *solvc::Datamatch_key_id_get;
*swig_key_id_set = *solvc::Datamatch_key_id_set;
*swig_key_idstr_get = *solvc::Datamatch_key_idstr_get;
*swig_key_idstr_set = *solvc::Datamatch_key_idstr_set;
*swig_type_id_get = *solvc::Datamatch_type_id_get;
*swig_type_id_set = *solvc::Datamatch_type_id_set;
*swig_type_idstr_get = *solvc::Datamatch_type_idstr_get;
*swig_type_idstr_set = *solvc::Datamatch_type_idstr_set;
*swig_id_get = *solvc::Datamatch_id_get;
*swig_id_set = *solvc::Datamatch_id_set;
*swig_idstr_get = *solvc::Datamatch_idstr_get;
*swig_idstr_set = *solvc::Datamatch_idstr_set;
*swig_str_get = *solvc::Datamatch_str_get;
*swig_str_set = *solvc::Datamatch_str_set;
*swig_dep_get = *solvc::Datamatch_dep_get;
*swig_dep_set = *solvc::Datamatch_dep_set;
*swig_binary_get = *solvc::Datamatch_binary_get;
*swig_binary_set = *solvc::Datamatch_binary_set;
*swig_num_get = *solvc::Datamatch_num_get;
*swig_num_set = *solvc::Datamatch_num_set;
*swig_num2_get = *solvc::Datamatch_num2_get;
*swig_num2_set = *solvc::Datamatch_num2_set;
*pos = *solvc::Datamatch_pos;
*parentpos = *solvc::Datamatch_parentpos;
*stringify = *solvc::Datamatch_stringify;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Datapos ##############

package solv::Datapos;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_repo_get = *solvc::Datapos_repo_get;
*swig_repo_set = *solvc::Datapos_repo_set;
*lookup_id = *solvc::Datapos_lookup_id;
*lookup_str = *solvc::Datapos_lookup_str;
*lookup_num = *solvc::Datapos_lookup_num;
*lookup_void = *solvc::Datapos_lookup_void;
*lookup_checksum = *solvc::Datapos_lookup_checksum;
*lookup_deltaseq = *solvc::Datapos_lookup_deltaseq;
*lookup_deltalocation = *solvc::Datapos_lookup_deltalocation;
*lookup_idarray = *solvc::Datapos_lookup_idarray;
*Dataiterator = *solvc::Datapos_Dataiterator;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Datapos($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;
}


############# Class : solv::Job ##############

package solv::Job;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_pool_get = *solvc::Job_pool_get;
*swig_pool_set = *solvc::Job_pool_set;
*swig_how_get = *solvc::Job_how_get;
*swig_how_set = *solvc::Job_how_set;
*swig_what_get = *solvc::Job_what_get;
*swig_what_set = *solvc::Job_what_set;
*SOLVER_SOLVABLE = *solvc::Job_SOLVER_SOLVABLE;
*SOLVER_SOLVABLE = *solvc::Job_SOLVER_SOLVABLE;
*SOLVER_SOLVABLE_NAME = *solvc::Job_SOLVER_SOLVABLE_NAME;
*SOLVER_SOLVABLE_NAME = *solvc::Job_SOLVER_SOLVABLE_NAME;
*SOLVER_SOLVABLE_PROVIDES = *solvc::Job_SOLVER_SOLVABLE_PROVIDES;
*SOLVER_SOLVABLE_PROVIDES = *solvc::Job_SOLVER_SOLVABLE_PROVIDES;
*SOLVER_SOLVABLE_ONE_OF = *solvc::Job_SOLVER_SOLVABLE_ONE_OF;
*SOLVER_SOLVABLE_ONE_OF = *solvc::Job_SOLVER_SOLVABLE_ONE_OF;
*SOLVER_SOLVABLE_REPO = *solvc::Job_SOLVER_SOLVABLE_REPO;
*SOLVER_SOLVABLE_REPO = *solvc::Job_SOLVER_SOLVABLE_REPO;
*SOLVER_SOLVABLE_ALL = *solvc::Job_SOLVER_SOLVABLE_ALL;
*SOLVER_SOLVABLE_ALL = *solvc::Job_SOLVER_SOLVABLE_ALL;
*SOLVER_SELECTMASK = *solvc::Job_SOLVER_SELECTMASK;
*SOLVER_SELECTMASK = *solvc::Job_SOLVER_SELECTMASK;
*SOLVER_NOOP = *solvc::Job_SOLVER_NOOP;
*SOLVER_NOOP = *solvc::Job_SOLVER_NOOP;
*SOLVER_INSTALL = *solvc::Job_SOLVER_INSTALL;
*SOLVER_INSTALL = *solvc::Job_SOLVER_INSTALL;
*SOLVER_ERASE = *solvc::Job_SOLVER_ERASE;
*SOLVER_ERASE = *solvc::Job_SOLVER_ERASE;
*SOLVER_UPDATE = *solvc::Job_SOLVER_UPDATE;
*SOLVER_UPDATE = *solvc::Job_SOLVER_UPDATE;
*SOLVER_WEAKENDEPS = *solvc::Job_SOLVER_WEAKENDEPS;
*SOLVER_WEAKENDEPS = *solvc::Job_SOLVER_WEAKENDEPS;
*SOLVER_MULTIVERSION = *solvc::Job_SOLVER_MULTIVERSION;
*SOLVER_MULTIVERSION = *solvc::Job_SOLVER_MULTIVERSION;
*SOLVER_LOCK = *solvc::Job_SOLVER_LOCK;
*SOLVER_LOCK = *solvc::Job_SOLVER_LOCK;
*SOLVER_DISTUPGRADE = *solvc::Job_SOLVER_DISTUPGRADE;
*SOLVER_DISTUPGRADE = *solvc::Job_SOLVER_DISTUPGRADE;
*SOLVER_VERIFY = *solvc::Job_SOLVER_VERIFY;
*SOLVER_VERIFY = *solvc::Job_SOLVER_VERIFY;
*SOLVER_DROP_ORPHANED = *solvc::Job_SOLVER_DROP_ORPHANED;
*SOLVER_DROP_ORPHANED = *solvc::Job_SOLVER_DROP_ORPHANED;
*SOLVER_USERINSTALLED = *solvc::Job_SOLVER_USERINSTALLED;
*SOLVER_USERINSTALLED = *solvc::Job_SOLVER_USERINSTALLED;
*SOLVER_ALLOWUNINSTALL = *solvc::Job_SOLVER_ALLOWUNINSTALL;
*SOLVER_ALLOWUNINSTALL = *solvc::Job_SOLVER_ALLOWUNINSTALL;
*SOLVER_FAVOR = *solvc::Job_SOLVER_FAVOR;
*SOLVER_FAVOR = *solvc::Job_SOLVER_FAVOR;
*SOLVER_DISFAVOR = *solvc::Job_SOLVER_DISFAVOR;
*SOLVER_DISFAVOR = *solvc::Job_SOLVER_DISFAVOR;
*SOLVER_EXCLUDEFROMWEAK = *solvc::Job_SOLVER_EXCLUDEFROMWEAK;
*SOLVER_EXCLUDEFROMWEAK = *solvc::Job_SOLVER_EXCLUDEFROMWEAK;
*SOLVER_JOBMASK = *solvc::Job_SOLVER_JOBMASK;
*SOLVER_JOBMASK = *solvc::Job_SOLVER_JOBMASK;
*SOLVER_WEAK = *solvc::Job_SOLVER_WEAK;
*SOLVER_WEAK = *solvc::Job_SOLVER_WEAK;
*SOLVER_ESSENTIAL = *solvc::Job_SOLVER_ESSENTIAL;
*SOLVER_ESSENTIAL = *solvc::Job_SOLVER_ESSENTIAL;
*SOLVER_CLEANDEPS = *solvc::Job_SOLVER_CLEANDEPS;
*SOLVER_CLEANDEPS = *solvc::Job_SOLVER_CLEANDEPS;
*SOLVER_FORCEBEST = *solvc::Job_SOLVER_FORCEBEST;
*SOLVER_FORCEBEST = *solvc::Job_SOLVER_FORCEBEST;
*SOLVER_TARGETED = *solvc::Job_SOLVER_TARGETED;
*SOLVER_TARGETED = *solvc::Job_SOLVER_TARGETED;
*SOLVER_NOTBYUSER = *solvc::Job_SOLVER_NOTBYUSER;
*SOLVER_NOTBYUSER = *solvc::Job_SOLVER_NOTBYUSER;
*SOLVER_SETEV = *solvc::Job_SOLVER_SETEV;
*SOLVER_SETEV = *solvc::Job_SOLVER_SETEV;
*SOLVER_SETEVR = *solvc::Job_SOLVER_SETEVR;
*SOLVER_SETEVR = *solvc::Job_SOLVER_SETEVR;
*SOLVER_SETARCH = *solvc::Job_SOLVER_SETARCH;
*SOLVER_SETARCH = *solvc::Job_SOLVER_SETARCH;
*SOLVER_SETVENDOR = *solvc::Job_SOLVER_SETVENDOR;
*SOLVER_SETVENDOR = *solvc::Job_SOLVER_SETVENDOR;
*SOLVER_SETREPO = *solvc::Job_SOLVER_SETREPO;
*SOLVER_SETREPO = *solvc::Job_SOLVER_SETREPO;
*SOLVER_SETNAME = *solvc::Job_SOLVER_SETNAME;
*SOLVER_SETNAME = *solvc::Job_SOLVER_SETNAME;
*SOLVER_NOAUTOSET = *solvc::Job_SOLVER_NOAUTOSET;
*SOLVER_NOAUTOSET = *solvc::Job_SOLVER_NOAUTOSET;
*SOLVER_SETMASK = *solvc::Job_SOLVER_SETMASK;
*SOLVER_SETMASK = *solvc::Job_SOLVER_SETMASK;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Job(@_);
    bless $self, $pkg if defined($self);
}

*solvables = *solvc::Job_solvables;
*isemptyupdate = *solvc::Job_isemptyupdate;
*__eq__ = *solvc::Job___eq__;
*__ne__ = *solvc::Job___ne__;
*str = *solvc::Job_str;
*repr = *solvc::Job_repr;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Job($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;
}


############# Class : solv::Pool ##############

package solv::Pool;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*POOL_FLAG_PROMOTEEPOCH = *solvc::Pool_POOL_FLAG_PROMOTEEPOCH;
*POOL_FLAG_PROMOTEEPOCH = *solvc::Pool_POOL_FLAG_PROMOTEEPOCH;
*POOL_FLAG_FORBIDSELFCONFLICTS = *solvc::Pool_POOL_FLAG_FORBIDSELFCONFLICTS;
*POOL_FLAG_FORBIDSELFCONFLICTS = *solvc::Pool_POOL_FLAG_FORBIDSELFCONFLICTS;
*POOL_FLAG_OBSOLETEUSESPROVIDES = *solvc::Pool_POOL_FLAG_OBSOLETEUSESPROVIDES;
*POOL_FLAG_OBSOLETEUSESPROVIDES = *solvc::Pool_POOL_FLAG_OBSOLETEUSESPROVIDES;
*POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES = *solvc::Pool_POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES;
*POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES = *solvc::Pool_POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES;
*POOL_FLAG_OBSOLETEUSESCOLORS = *solvc::Pool_POOL_FLAG_OBSOLETEUSESCOLORS;
*POOL_FLAG_OBSOLETEUSESCOLORS = *solvc::Pool_POOL_FLAG_OBSOLETEUSESCOLORS;
*POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS = *solvc::Pool_POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS;
*POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS = *solvc::Pool_POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS;
*POOL_FLAG_NOINSTALLEDOBSOLETES = *solvc::Pool_POOL_FLAG_NOINSTALLEDOBSOLETES;
*POOL_FLAG_NOINSTALLEDOBSOLETES = *solvc::Pool_POOL_FLAG_NOINSTALLEDOBSOLETES;
*POOL_FLAG_HAVEDISTEPOCH = *solvc::Pool_POOL_FLAG_HAVEDISTEPOCH;
*POOL_FLAG_HAVEDISTEPOCH = *solvc::Pool_POOL_FLAG_HAVEDISTEPOCH;
*POOL_FLAG_NOOBSOLETESMULTIVERSION = *solvc::Pool_POOL_FLAG_NOOBSOLETESMULTIVERSION;
*POOL_FLAG_NOOBSOLETESMULTIVERSION = *solvc::Pool_POOL_FLAG_NOOBSOLETESMULTIVERSION;
*POOL_FLAG_ADDFILEPROVIDESFILTERED = *solvc::Pool_POOL_FLAG_ADDFILEPROVIDESFILTERED;
*POOL_FLAG_ADDFILEPROVIDESFILTERED = *solvc::Pool_POOL_FLAG_ADDFILEPROVIDESFILTERED;
*POOL_FLAG_NOWHATPROVIDESAUX = *solvc::Pool_POOL_FLAG_NOWHATPROVIDESAUX;
*POOL_FLAG_NOWHATPROVIDESAUX = *solvc::Pool_POOL_FLAG_NOWHATPROVIDESAUX;
*POOL_FLAG_WHATPROVIDESWITHDISABLED = *solvc::Pool_POOL_FLAG_WHATPROVIDESWITHDISABLED;
*POOL_FLAG_WHATPROVIDESWITHDISABLED = *solvc::Pool_POOL_FLAG_WHATPROVIDESWITHDISABLED;
*DISTTYPE_RPM = *solvc::Pool_DISTTYPE_RPM;
*DISTTYPE_RPM = *solvc::Pool_DISTTYPE_RPM;
*DISTTYPE_DEB = *solvc::Pool_DISTTYPE_DEB;
*DISTTYPE_DEB = *solvc::Pool_DISTTYPE_DEB;
*DISTTYPE_ARCH = *solvc::Pool_DISTTYPE_ARCH;
*DISTTYPE_ARCH = *solvc::Pool_DISTTYPE_ARCH;
*DISTTYPE_HAIKU = *solvc::Pool_DISTTYPE_HAIKU;
*DISTTYPE_HAIKU = *solvc::Pool_DISTTYPE_HAIKU;
*DISTTYPE_CONDA = *solvc::Pool_DISTTYPE_CONDA;
*DISTTYPE_CONDA = *solvc::Pool_DISTTYPE_CONDA;
*DISTTYPE_APK = *solvc::Pool_DISTTYPE_APK;
*DISTTYPE_APK = *solvc::Pool_DISTTYPE_APK;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Pool(@_);
    bless $self, $pkg if defined($self);
}

*setdisttype = *solvc::Pool_setdisttype;
*set_debuglevel = *solvc::Pool_set_debuglevel;
*set_flag = *solvc::Pool_set_flag;
*get_flag = *solvc::Pool_get_flag;
*set_rootdir = *solvc::Pool_set_rootdir;
*get_rootdir = *solvc::Pool_get_rootdir;
*clr_loadcallback = *solvc::Pool_clr_loadcallback;
*set_loadcallback = *solvc::Pool_set_loadcallback;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Pool($self);
        delete $OWNER{$self};
    }
}

*free = *solvc::Pool_free;
*disown = *solvc::Pool_disown;
*swig_appdata_get = *solvc::Pool_appdata_get;
*swig_appdata_set = *solvc::Pool_appdata_set;
*appdata_disown = *solvc::Pool_appdata_disown;
*str2id = *solvc::Pool_str2id;
*Dep = *solvc::Pool_Dep;
*parserpmrichdep = *solvc::Pool_parserpmrichdep;
*id2str = *solvc::Pool_id2str;
*dep2str = *solvc::Pool_dep2str;
*rel2id = *solvc::Pool_rel2id;
*id2langid = *solvc::Pool_id2langid;
*setarch = *solvc::Pool_setarch;
*add_repo = *solvc::Pool_add_repo;
*lookup_str = *solvc::Pool_lookup_str;
*lookup_id = *solvc::Pool_lookup_id;
*lookup_num = *solvc::Pool_lookup_num;
*lookup_void = *solvc::Pool_lookup_void;
*lookup_checksum = *solvc::Pool_lookup_checksum;
*Dataiterator = *solvc::Pool_Dataiterator;
*Dataiterator_solvid = *solvc::Pool_Dataiterator_solvid;
*solvid2str = *solvc::Pool_solvid2str;
*solvidset2str = *solvc::Pool_solvidset2str;
*solvableset2str = *solvc::Pool_solvableset2str;
*addfileprovides = *solvc::Pool_addfileprovides;
*addfileprovides_queue = *solvc::Pool_addfileprovides_queue;
*createwhatprovides = *solvc::Pool_createwhatprovides;
*id2solvable = *solvc::Pool_id2solvable;
*swig_solvables_get = *solvc::Pool_solvables_get;
*swig_solvables_set = *solvc::Pool_solvables_set;
*solvables_iter = *solvc::Pool_solvables_iter;
*id2repo = *solvc::Pool_id2repo;
*swig_repos_get = *solvc::Pool_repos_get;
*swig_repos_set = *solvc::Pool_repos_set;
*repos_iter = *solvc::Pool_repos_iter;
*swig_installed_get = *solvc::Pool_installed_get;
*swig_installed_set = *solvc::Pool_installed_set;
*swig_errstr_get = *solvc::Pool_errstr_get;
*swig_errstr_set = *solvc::Pool_errstr_set;
*matchprovidingids = *solvc::Pool_matchprovidingids;
*Job = *solvc::Pool_Job;
*whatprovides = *solvc::Pool_whatprovides;
*best_solvables = *solvc::Pool_best_solvables;
*towhatprovides = *solvc::Pool_towhatprovides;
*set_namespaceproviders = *solvc::Pool_set_namespaceproviders;
*flush_namespaceproviders = *solvc::Pool_flush_namespaceproviders;
*whatcontainsdep = *solvc::Pool_whatcontainsdep;
*whatmatchesdep = *solvc::Pool_whatmatchesdep;
*whatmatchessolvable = *solvc::Pool_whatmatchessolvable;
*isknownarch = *solvc::Pool_isknownarch;
*Solver = *solvc::Pool_Solver;
*Selection = *solvc::Pool_Selection;
*Selection_all = *solvc::Pool_Selection_all;
*select = *solvc::Pool_select;
*matchdeps = *solvc::Pool_matchdeps;
*matchdepid = *solvc::Pool_matchdepid;
*matchsolvable = *solvc::Pool_matchsolvable;
*get_considered_list = *solvc::Pool_get_considered_list;
*get_disabled_list = *solvc::Pool_get_disabled_list;
*set_considered_list = *solvc::Pool_set_considered_list;
*set_disabled_list = *solvc::Pool_set_disabled_list;
*setpooljobs = *solvc::Pool_setpooljobs;
*getpooljobs = *solvc::Pool_getpooljobs;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Repo ##############

package solv::Repo;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_pool_get = *solvc::Repo_pool_get;
*swig_pool_set = *solvc::Repo_pool_set;
*swig_name_get = *solvc::Repo_name_get;
*swig_name_set = *solvc::Repo_name_set;
*swig_priority_get = *solvc::Repo_priority_get;
*swig_priority_set = *solvc::Repo_priority_set;
*swig_subpriority_get = *solvc::Repo_subpriority_get;
*swig_subpriority_set = *solvc::Repo_subpriority_set;
*swig_nsolvables_get = *solvc::Repo_nsolvables_get;
*swig_nsolvables_set = *solvc::Repo_nsolvables_set;
*REPO_REUSE_REPODATA = *solvc::Repo_REPO_REUSE_REPODATA;
*REPO_REUSE_REPODATA = *solvc::Repo_REPO_REUSE_REPODATA;
*REPO_NO_INTERNALIZE = *solvc::Repo_REPO_NO_INTERNALIZE;
*REPO_NO_INTERNALIZE = *solvc::Repo_REPO_NO_INTERNALIZE;
*REPO_LOCALPOOL = *solvc::Repo_REPO_LOCALPOOL;
*REPO_LOCALPOOL = *solvc::Repo_REPO_LOCALPOOL;
*REPO_USE_LOADING = *solvc::Repo_REPO_USE_LOADING;
*REPO_USE_LOADING = *solvc::Repo_REPO_USE_LOADING;
*REPO_EXTEND_SOLVABLES = *solvc::Repo_REPO_EXTEND_SOLVABLES;
*REPO_EXTEND_SOLVABLES = *solvc::Repo_REPO_EXTEND_SOLVABLES;
*REPO_USE_ROOTDIR = *solvc::Repo_REPO_USE_ROOTDIR;
*REPO_USE_ROOTDIR = *solvc::Repo_REPO_USE_ROOTDIR;
*REPO_NO_LOCATION = *solvc::Repo_REPO_NO_LOCATION;
*REPO_NO_LOCATION = *solvc::Repo_REPO_NO_LOCATION;
*SOLV_ADD_NO_STUBS = *solvc::Repo_SOLV_ADD_NO_STUBS;
*SOLV_ADD_NO_STUBS = *solvc::Repo_SOLV_ADD_NO_STUBS;
*SUSETAGS_RECORD_SHARES = *solvc::Repo_SUSETAGS_RECORD_SHARES;
*SUSETAGS_RECORD_SHARES = *solvc::Repo_SUSETAGS_RECORD_SHARES;
*free = *solvc::Repo_free;
*empty = *solvc::Repo_empty;
*isempty = *solvc::Repo_isempty;
*swig_appdata_get = *solvc::Repo_appdata_get;
*swig_appdata_set = *solvc::Repo_appdata_set;
*add_solv = *solvc::Repo_add_solv;
*add_solvable = *solvc::Repo_add_solvable;
*add_rpmdb = *solvc::Repo_add_rpmdb;
*add_rpmdb_reffp = *solvc::Repo_add_rpmdb_reffp;
*add_rpm = *solvc::Repo_add_rpm;
*add_rpmdb_pubkeys = *solvc::Repo_add_rpmdb_pubkeys;
*add_pubkey = *solvc::Repo_add_pubkey;
*add_keyring = *solvc::Repo_add_keyring;
*add_keydir = *solvc::Repo_add_keydir;
*add_rpmmd = *solvc::Repo_add_rpmmd;
*add_repomdxml = *solvc::Repo_add_repomdxml;
*add_updateinfoxml = *solvc::Repo_add_updateinfoxml;
*add_deltainfoxml = *solvc::Repo_add_deltainfoxml;
*add_debdb = *solvc::Repo_add_debdb;
*add_debpackages = *solvc::Repo_add_debpackages;
*add_deb = *solvc::Repo_add_deb;
*add_susetags = *solvc::Repo_add_susetags;
*add_content = *solvc::Repo_add_content;
*add_products = *solvc::Repo_add_products;
*add_mdk = *solvc::Repo_add_mdk;
*add_mdk_info = *solvc::Repo_add_mdk_info;
*add_arch_repo = *solvc::Repo_add_arch_repo;
*add_arch_local = *solvc::Repo_add_arch_local;
*add_arch_pkg = *solvc::Repo_add_arch_pkg;
*internalize = *solvc::Repo_internalize;
*write = *solvc::Repo_write;
*write_first_repodata = *solvc::Repo_write_first_repodata;
*Dataiterator = *solvc::Repo_Dataiterator;
*Dataiterator_meta = *solvc::Repo_Dataiterator_meta;
*swig_id_get = *solvc::Repo_id_get;
*swig_id_set = *solvc::Repo_id_set;
*swig_solvables_get = *solvc::Repo_solvables_get;
*swig_solvables_set = *solvc::Repo_solvables_set;
*swig_meta_get = *solvc::Repo_meta_get;
*swig_meta_set = *solvc::Repo_meta_set;
*solvables_iter = *solvc::Repo_solvables_iter;
*add_repodata = *solvc::Repo_add_repodata;
*create_stubs = *solvc::Repo_create_stubs;
*iscontiguous = *solvc::Repo_iscontiguous;
*first_repodata = *solvc::Repo_first_repodata;
*Selection = *solvc::Repo_Selection;
*find_pubkey = *solvc::Repo_find_pubkey;
*createshadow = *solvc::Repo_createshadow;
*moveshadow = *solvc::Repo_moveshadow;
*__eq__ = *solvc::Repo___eq__;
*__ne__ = *solvc::Repo___ne__;
*str = *solvc::Repo_str;
*repr = *solvc::Repo_repr;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Decision ##############

package solv::Decision;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_solv_get = *solvc::Decision_solv_get;
*swig_solv_set = *solvc::Decision_solv_set;
*swig_p_get = *solvc::Decision_p_get;
*swig_p_set = *solvc::Decision_p_set;
*swig_reason_get = *solvc::Decision_reason_get;
*swig_reason_set = *solvc::Decision_reason_set;
*swig_infoid_get = *solvc::Decision_infoid_get;
*swig_infoid_set = *solvc::Decision_infoid_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Decision(@_);
    bless $self, $pkg if defined($self);
}

*swig_rule_get = *solvc::Decision_rule_get;
*swig_rule_set = *solvc::Decision_rule_set;
*swig_solvable_get = *solvc::Decision_solvable_get;
*swig_solvable_set = *solvc::Decision_solvable_set;
*info = *solvc::Decision_info;
*allinfos = *solvc::Decision_allinfos;
*reasonstr = *solvc::Decision_reasonstr;
*str = *solvc::Decision_str;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Decision($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;
}


############# Class : solv::Decisionset ##############

package solv::Decisionset;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_solv_get = *solvc::Decisionset_solv_get;
*swig_solv_set = *solvc::Decisionset_solv_set;
*swig_p_get = *solvc::Decisionset_p_get;
*swig_p_set = *solvc::Decisionset_p_set;
*swig_reason_get = *solvc::Decisionset_reason_get;
*swig_reason_set = *solvc::Decisionset_reason_set;
*swig_infoid_get = *solvc::Decisionset_infoid_get;
*swig_infoid_set = *solvc::Decisionset_infoid_set;
*swig_bits_get = *solvc::Decisionset_bits_get;
*swig_bits_set = *solvc::Decisionset_bits_set;
*swig_type_get = *solvc::Decisionset_type_get;
*swig_type_set = *solvc::Decisionset_type_set;
*swig_dep_id_get = *solvc::Decisionset_dep_id_get;
*swig_dep_id_set = *solvc::Decisionset_dep_id_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Decisionset(@_);
    bless $self, $pkg if defined($self);
}

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

*info = *solvc::Decisionset_info;
*swig_dep_get = *solvc::Decisionset_dep_get;
*swig_dep_set = *solvc::Decisionset_dep_set;
*solvables = *solvc::Decisionset_solvables;
*decisions = *solvc::Decisionset_decisions;
*reasonstr = *solvc::Decisionset_reasonstr;
*str = *solvc::Decisionset_str;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Solver ##############

package solv::Solver;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_pool_get = *solvc::Solver_pool_get;
*swig_pool_set = *solvc::Solver_pool_set;
*SOLVER_RULE_UNKNOWN = *solvc::Solver_SOLVER_RULE_UNKNOWN;
*SOLVER_RULE_UNKNOWN = *solvc::Solver_SOLVER_RULE_UNKNOWN;
*SOLVER_RULE_PKG = *solvc::Solver_SOLVER_RULE_PKG;
*SOLVER_RULE_PKG = *solvc::Solver_SOLVER_RULE_PKG;
*SOLVER_RULE_PKG_NOT_INSTALLABLE = *solvc::Solver_SOLVER_RULE_PKG_NOT_INSTALLABLE;
*SOLVER_RULE_PKG_NOT_INSTALLABLE = *solvc::Solver_SOLVER_RULE_PKG_NOT_INSTALLABLE;
*SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP = *solvc::Solver_SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP;
*SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP = *solvc::Solver_SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP;
*SOLVER_RULE_PKG_REQUIRES = *solvc::Solver_SOLVER_RULE_PKG_REQUIRES;
*SOLVER_RULE_PKG_REQUIRES = *solvc::Solver_SOLVER_RULE_PKG_REQUIRES;
*SOLVER_RULE_PKG_SELF_CONFLICT = *solvc::Solver_SOLVER_RULE_PKG_SELF_CONFLICT;
*SOLVER_RULE_PKG_SELF_CONFLICT = *solvc::Solver_SOLVER_RULE_PKG_SELF_CONFLICT;
*SOLVER_RULE_PKG_CONFLICTS = *solvc::Solver_SOLVER_RULE_PKG_CONFLICTS;
*SOLVER_RULE_PKG_CONFLICTS = *solvc::Solver_SOLVER_RULE_PKG_CONFLICTS;
*SOLVER_RULE_PKG_SAME_NAME = *solvc::Solver_SOLVER_RULE_PKG_SAME_NAME;
*SOLVER_RULE_PKG_SAME_NAME = *solvc::Solver_SOLVER_RULE_PKG_SAME_NAME;
*SOLVER_RULE_PKG_OBSOLETES = *solvc::Solver_SOLVER_RULE_PKG_OBSOLETES;
*SOLVER_RULE_PKG_OBSOLETES = *solvc::Solver_SOLVER_RULE_PKG_OBSOLETES;
*SOLVER_RULE_PKG_IMPLICIT_OBSOLETES = *solvc::Solver_SOLVER_RULE_PKG_IMPLICIT_OBSOLETES;
*SOLVER_RULE_PKG_IMPLICIT_OBSOLETES = *solvc::Solver_SOLVER_RULE_PKG_IMPLICIT_OBSOLETES;
*SOLVER_RULE_PKG_INSTALLED_OBSOLETES = *solvc::Solver_SOLVER_RULE_PKG_INSTALLED_OBSOLETES;
*SOLVER_RULE_PKG_INSTALLED_OBSOLETES = *solvc::Solver_SOLVER_RULE_PKG_INSTALLED_OBSOLETES;
*SOLVER_RULE_PKG_RECOMMENDS = *solvc::Solver_SOLVER_RULE_PKG_RECOMMENDS;
*SOLVER_RULE_PKG_RECOMMENDS = *solvc::Solver_SOLVER_RULE_PKG_RECOMMENDS;
*SOLVER_RULE_PKG_CONSTRAINS = *solvc::Solver_SOLVER_RULE_PKG_CONSTRAINS;
*SOLVER_RULE_PKG_CONSTRAINS = *solvc::Solver_SOLVER_RULE_PKG_CONSTRAINS;
*SOLVER_RULE_PKG_SUPPLEMENTS = *solvc::Solver_SOLVER_RULE_PKG_SUPPLEMENTS;
*SOLVER_RULE_PKG_SUPPLEMENTS = *solvc::Solver_SOLVER_RULE_PKG_SUPPLEMENTS;
*SOLVER_RULE_UPDATE = *solvc::Solver_SOLVER_RULE_UPDATE;
*SOLVER_RULE_UPDATE = *solvc::Solver_SOLVER_RULE_UPDATE;
*SOLVER_RULE_FEATURE = *solvc::Solver_SOLVER_RULE_FEATURE;
*SOLVER_RULE_FEATURE = *solvc::Solver_SOLVER_RULE_FEATURE;
*SOLVER_RULE_JOB = *solvc::Solver_SOLVER_RULE_JOB;
*SOLVER_RULE_JOB = *solvc::Solver_SOLVER_RULE_JOB;
*SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP = *solvc::Solver_SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
*SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP = *solvc::Solver_SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
*SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM = *solvc::Solver_SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM;
*SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM = *solvc::Solver_SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM;
*SOLVER_RULE_JOB_UNKNOWN_PACKAGE = *solvc::Solver_SOLVER_RULE_JOB_UNKNOWN_PACKAGE;
*SOLVER_RULE_JOB_UNKNOWN_PACKAGE = *solvc::Solver_SOLVER_RULE_JOB_UNKNOWN_PACKAGE;
*SOLVER_RULE_JOB_UNSUPPORTED = *solvc::Solver_SOLVER_RULE_JOB_UNSUPPORTED;
*SOLVER_RULE_JOB_UNSUPPORTED = *solvc::Solver_SOLVER_RULE_JOB_UNSUPPORTED;
*SOLVER_RULE_DISTUPGRADE = *solvc::Solver_SOLVER_RULE_DISTUPGRADE;
*SOLVER_RULE_DISTUPGRADE = *solvc::Solver_SOLVER_RULE_DISTUPGRADE;
*SOLVER_RULE_INFARCH = *solvc::Solver_SOLVER_RULE_INFARCH;
*SOLVER_RULE_INFARCH = *solvc::Solver_SOLVER_RULE_INFARCH;
*SOLVER_RULE_CHOICE = *solvc::Solver_SOLVER_RULE_CHOICE;
*SOLVER_RULE_CHOICE = *solvc::Solver_SOLVER_RULE_CHOICE;
*SOLVER_RULE_LEARNT = *solvc::Solver_SOLVER_RULE_LEARNT;
*SOLVER_RULE_LEARNT = *solvc::Solver_SOLVER_RULE_LEARNT;
*SOLVER_RULE_BEST = *solvc::Solver_SOLVER_RULE_BEST;
*SOLVER_RULE_BEST = *solvc::Solver_SOLVER_RULE_BEST;
*SOLVER_RULE_YUMOBS = *solvc::Solver_SOLVER_RULE_YUMOBS;
*SOLVER_RULE_YUMOBS = *solvc::Solver_SOLVER_RULE_YUMOBS;
*SOLVER_RULE_RECOMMENDS = *solvc::Solver_SOLVER_RULE_RECOMMENDS;
*SOLVER_RULE_RECOMMENDS = *solvc::Solver_SOLVER_RULE_RECOMMENDS;
*SOLVER_RULE_BLACK = *solvc::Solver_SOLVER_RULE_BLACK;
*SOLVER_RULE_BLACK = *solvc::Solver_SOLVER_RULE_BLACK;
*SOLVER_RULE_STRICT_REPO_PRIORITY = *solvc::Solver_SOLVER_RULE_STRICT_REPO_PRIORITY;
*SOLVER_RULE_STRICT_REPO_PRIORITY = *solvc::Solver_SOLVER_RULE_STRICT_REPO_PRIORITY;
*SOLVER_SOLUTION_JOB = *solvc::Solver_SOLVER_SOLUTION_JOB;
*SOLVER_SOLUTION_JOB = *solvc::Solver_SOLVER_SOLUTION_JOB;
*SOLVER_SOLUTION_POOLJOB = *solvc::Solver_SOLVER_SOLUTION_POOLJOB;
*SOLVER_SOLUTION_POOLJOB = *solvc::Solver_SOLVER_SOLUTION_POOLJOB;
*SOLVER_SOLUTION_INFARCH = *solvc::Solver_SOLVER_SOLUTION_INFARCH;
*SOLVER_SOLUTION_INFARCH = *solvc::Solver_SOLVER_SOLUTION_INFARCH;
*SOLVER_SOLUTION_DISTUPGRADE = *solvc::Solver_SOLVER_SOLUTION_DISTUPGRADE;
*SOLVER_SOLUTION_DISTUPGRADE = *solvc::Solver_SOLVER_SOLUTION_DISTUPGRADE;
*SOLVER_SOLUTION_BEST = *solvc::Solver_SOLVER_SOLUTION_BEST;
*SOLVER_SOLUTION_BEST = *solvc::Solver_SOLVER_SOLUTION_BEST;
*SOLVER_SOLUTION_ERASE = *solvc::Solver_SOLVER_SOLUTION_ERASE;
*SOLVER_SOLUTION_ERASE = *solvc::Solver_SOLVER_SOLUTION_ERASE;
*SOLVER_SOLUTION_REPLACE = *solvc::Solver_SOLVER_SOLUTION_REPLACE;
*SOLVER_SOLUTION_REPLACE = *solvc::Solver_SOLVER_SOLUTION_REPLACE;
*SOLVER_SOLUTION_REPLACE_DOWNGRADE = *solvc::Solver_SOLVER_SOLUTION_REPLACE_DOWNGRADE;
*SOLVER_SOLUTION_REPLACE_DOWNGRADE = *solvc::Solver_SOLVER_SOLUTION_REPLACE_DOWNGRADE;
*SOLVER_SOLUTION_REPLACE_ARCHCHANGE = *solvc::Solver_SOLVER_SOLUTION_REPLACE_ARCHCHANGE;
*SOLVER_SOLUTION_REPLACE_ARCHCHANGE = *solvc::Solver_SOLVER_SOLUTION_REPLACE_ARCHCHANGE;
*SOLVER_SOLUTION_REPLACE_VENDORCHANGE = *solvc::Solver_SOLVER_SOLUTION_REPLACE_VENDORCHANGE;
*SOLVER_SOLUTION_REPLACE_VENDORCHANGE = *solvc::Solver_SOLVER_SOLUTION_REPLACE_VENDORCHANGE;
*SOLVER_SOLUTION_REPLACE_NAMECHANGE = *solvc::Solver_SOLVER_SOLUTION_REPLACE_NAMECHANGE;
*SOLVER_SOLUTION_REPLACE_NAMECHANGE = *solvc::Solver_SOLVER_SOLUTION_REPLACE_NAMECHANGE;
*POLICY_ILLEGAL_DOWNGRADE = *solvc::Solver_POLICY_ILLEGAL_DOWNGRADE;
*POLICY_ILLEGAL_DOWNGRADE = *solvc::Solver_POLICY_ILLEGAL_DOWNGRADE;
*POLICY_ILLEGAL_ARCHCHANGE = *solvc::Solver_POLICY_ILLEGAL_ARCHCHANGE;
*POLICY_ILLEGAL_ARCHCHANGE = *solvc::Solver_POLICY_ILLEGAL_ARCHCHANGE;
*POLICY_ILLEGAL_VENDORCHANGE = *solvc::Solver_POLICY_ILLEGAL_VENDORCHANGE;
*POLICY_ILLEGAL_VENDORCHANGE = *solvc::Solver_POLICY_ILLEGAL_VENDORCHANGE;
*POLICY_ILLEGAL_NAMECHANGE = *solvc::Solver_POLICY_ILLEGAL_NAMECHANGE;
*POLICY_ILLEGAL_NAMECHANGE = *solvc::Solver_POLICY_ILLEGAL_NAMECHANGE;
*SOLVER_FLAG_ALLOW_DOWNGRADE = *solvc::Solver_SOLVER_FLAG_ALLOW_DOWNGRADE;
*SOLVER_FLAG_ALLOW_DOWNGRADE = *solvc::Solver_SOLVER_FLAG_ALLOW_DOWNGRADE;
*SOLVER_FLAG_ALLOW_ARCHCHANGE = *solvc::Solver_SOLVER_FLAG_ALLOW_ARCHCHANGE;
*SOLVER_FLAG_ALLOW_ARCHCHANGE = *solvc::Solver_SOLVER_FLAG_ALLOW_ARCHCHANGE;
*SOLVER_FLAG_ALLOW_VENDORCHANGE = *solvc::Solver_SOLVER_FLAG_ALLOW_VENDORCHANGE;
*SOLVER_FLAG_ALLOW_VENDORCHANGE = *solvc::Solver_SOLVER_FLAG_ALLOW_VENDORCHANGE;
*SOLVER_FLAG_ALLOW_NAMECHANGE = *solvc::Solver_SOLVER_FLAG_ALLOW_NAMECHANGE;
*SOLVER_FLAG_ALLOW_NAMECHANGE = *solvc::Solver_SOLVER_FLAG_ALLOW_NAMECHANGE;
*SOLVER_FLAG_ALLOW_UNINSTALL = *solvc::Solver_SOLVER_FLAG_ALLOW_UNINSTALL;
*SOLVER_FLAG_ALLOW_UNINSTALL = *solvc::Solver_SOLVER_FLAG_ALLOW_UNINSTALL;
*SOLVER_FLAG_NO_UPDATEPROVIDE = *solvc::Solver_SOLVER_FLAG_NO_UPDATEPROVIDE;
*SOLVER_FLAG_NO_UPDATEPROVIDE = *solvc::Solver_SOLVER_FLAG_NO_UPDATEPROVIDE;
*SOLVER_FLAG_SPLITPROVIDES = *solvc::Solver_SOLVER_FLAG_SPLITPROVIDES;
*SOLVER_FLAG_SPLITPROVIDES = *solvc::Solver_SOLVER_FLAG_SPLITPROVIDES;
*SOLVER_FLAG_IGNORE_RECOMMENDED = *solvc::Solver_SOLVER_FLAG_IGNORE_RECOMMENDED;
*SOLVER_FLAG_IGNORE_RECOMMENDED = *solvc::Solver_SOLVER_FLAG_IGNORE_RECOMMENDED;
*SOLVER_FLAG_ADD_ALREADY_RECOMMENDED = *solvc::Solver_SOLVER_FLAG_ADD_ALREADY_RECOMMENDED;
*SOLVER_FLAG_ADD_ALREADY_RECOMMENDED = *solvc::Solver_SOLVER_FLAG_ADD_ALREADY_RECOMMENDED;
*SOLVER_FLAG_NO_INFARCHCHECK = *solvc::Solver_SOLVER_FLAG_NO_INFARCHCHECK;
*SOLVER_FLAG_NO_INFARCHCHECK = *solvc::Solver_SOLVER_FLAG_NO_INFARCHCHECK;
*SOLVER_FLAG_BEST_OBEY_POLICY = *solvc::Solver_SOLVER_FLAG_BEST_OBEY_POLICY;
*SOLVER_FLAG_BEST_OBEY_POLICY = *solvc::Solver_SOLVER_FLAG_BEST_OBEY_POLICY;
*SOLVER_FLAG_NO_AUTOTARGET = *solvc::Solver_SOLVER_FLAG_NO_AUTOTARGET;
*SOLVER_FLAG_NO_AUTOTARGET = *solvc::Solver_SOLVER_FLAG_NO_AUTOTARGET;
*SOLVER_FLAG_DUP_ALLOW_DOWNGRADE = *solvc::Solver_SOLVER_FLAG_DUP_ALLOW_DOWNGRADE;
*SOLVER_FLAG_DUP_ALLOW_DOWNGRADE = *solvc::Solver_SOLVER_FLAG_DUP_ALLOW_DOWNGRADE;
*SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE = *solvc::Solver_SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE;
*SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE = *solvc::Solver_SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE;
*SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE = *solvc::Solver_SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE;
*SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE = *solvc::Solver_SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE;
*SOLVER_FLAG_DUP_ALLOW_NAMECHANGE = *solvc::Solver_SOLVER_FLAG_DUP_ALLOW_NAMECHANGE;
*SOLVER_FLAG_DUP_ALLOW_NAMECHANGE = *solvc::Solver_SOLVER_FLAG_DUP_ALLOW_NAMECHANGE;
*SOLVER_FLAG_KEEP_ORPHANS = *solvc::Solver_SOLVER_FLAG_KEEP_ORPHANS;
*SOLVER_FLAG_KEEP_ORPHANS = *solvc::Solver_SOLVER_FLAG_KEEP_ORPHANS;
*SOLVER_FLAG_BREAK_ORPHANS = *solvc::Solver_SOLVER_FLAG_BREAK_ORPHANS;
*SOLVER_FLAG_BREAK_ORPHANS = *solvc::Solver_SOLVER_FLAG_BREAK_ORPHANS;
*SOLVER_FLAG_FOCUS_INSTALLED = *solvc::Solver_SOLVER_FLAG_FOCUS_INSTALLED;
*SOLVER_FLAG_FOCUS_INSTALLED = *solvc::Solver_SOLVER_FLAG_FOCUS_INSTALLED;
*SOLVER_FLAG_YUM_OBSOLETES = *solvc::Solver_SOLVER_FLAG_YUM_OBSOLETES;
*SOLVER_FLAG_YUM_OBSOLETES = *solvc::Solver_SOLVER_FLAG_YUM_OBSOLETES;
*SOLVER_FLAG_NEED_UPDATEPROVIDE = *solvc::Solver_SOLVER_FLAG_NEED_UPDATEPROVIDE;
*SOLVER_FLAG_NEED_UPDATEPROVIDE = *solvc::Solver_SOLVER_FLAG_NEED_UPDATEPROVIDE;
*SOLVER_FLAG_FOCUS_BEST = *solvc::Solver_SOLVER_FLAG_FOCUS_BEST;
*SOLVER_FLAG_FOCUS_BEST = *solvc::Solver_SOLVER_FLAG_FOCUS_BEST;
*SOLVER_FLAG_STRONG_RECOMMENDS = *solvc::Solver_SOLVER_FLAG_STRONG_RECOMMENDS;
*SOLVER_FLAG_STRONG_RECOMMENDS = *solvc::Solver_SOLVER_FLAG_STRONG_RECOMMENDS;
*SOLVER_FLAG_INSTALL_ALSO_UPDATES = *solvc::Solver_SOLVER_FLAG_INSTALL_ALSO_UPDATES;
*SOLVER_FLAG_INSTALL_ALSO_UPDATES = *solvc::Solver_SOLVER_FLAG_INSTALL_ALSO_UPDATES;
*SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED = *solvc::Solver_SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED;
*SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED = *solvc::Solver_SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED;
*SOLVER_FLAG_STRICT_REPO_PRIORITY = *solvc::Solver_SOLVER_FLAG_STRICT_REPO_PRIORITY;
*SOLVER_FLAG_STRICT_REPO_PRIORITY = *solvc::Solver_SOLVER_FLAG_STRICT_REPO_PRIORITY;
*SOLVER_FLAG_FOCUS_NEW = *solvc::Solver_SOLVER_FLAG_FOCUS_NEW;
*SOLVER_FLAG_FOCUS_NEW = *solvc::Solver_SOLVER_FLAG_FOCUS_NEW;
*SOLVER_REASON_UNRELATED = *solvc::Solver_SOLVER_REASON_UNRELATED;
*SOLVER_REASON_UNRELATED = *solvc::Solver_SOLVER_REASON_UNRELATED;
*SOLVER_REASON_UNIT_RULE = *solvc::Solver_SOLVER_REASON_UNIT_RULE;
*SOLVER_REASON_UNIT_RULE = *solvc::Solver_SOLVER_REASON_UNIT_RULE;
*SOLVER_REASON_KEEP_INSTALLED = *solvc::Solver_SOLVER_REASON_KEEP_INSTALLED;
*SOLVER_REASON_KEEP_INSTALLED = *solvc::Solver_SOLVER_REASON_KEEP_INSTALLED;
*SOLVER_REASON_RESOLVE_JOB = *solvc::Solver_SOLVER_REASON_RESOLVE_JOB;
*SOLVER_REASON_RESOLVE_JOB = *solvc::Solver_SOLVER_REASON_RESOLVE_JOB;
*SOLVER_REASON_UPDATE_INSTALLED = *solvc::Solver_SOLVER_REASON_UPDATE_INSTALLED;
*SOLVER_REASON_UPDATE_INSTALLED = *solvc::Solver_SOLVER_REASON_UPDATE_INSTALLED;
*SOLVER_REASON_CLEANDEPS_ERASE = *solvc::Solver_SOLVER_REASON_CLEANDEPS_ERASE;
*SOLVER_REASON_CLEANDEPS_ERASE = *solvc::Solver_SOLVER_REASON_CLEANDEPS_ERASE;
*SOLVER_REASON_RESOLVE = *solvc::Solver_SOLVER_REASON_RESOLVE;
*SOLVER_REASON_RESOLVE = *solvc::Solver_SOLVER_REASON_RESOLVE;
*SOLVER_REASON_WEAKDEP = *solvc::Solver_SOLVER_REASON_WEAKDEP;
*SOLVER_REASON_WEAKDEP = *solvc::Solver_SOLVER_REASON_WEAKDEP;
*SOLVER_REASON_RESOLVE_ORPHAN = *solvc::Solver_SOLVER_REASON_RESOLVE_ORPHAN;
*SOLVER_REASON_RESOLVE_ORPHAN = *solvc::Solver_SOLVER_REASON_RESOLVE_ORPHAN;
*SOLVER_REASON_RECOMMENDED = *solvc::Solver_SOLVER_REASON_RECOMMENDED;
*SOLVER_REASON_RECOMMENDED = *solvc::Solver_SOLVER_REASON_RECOMMENDED;
*SOLVER_REASON_SUPPLEMENTED = *solvc::Solver_SOLVER_REASON_SUPPLEMENTED;
*SOLVER_REASON_SUPPLEMENTED = *solvc::Solver_SOLVER_REASON_SUPPLEMENTED;
*SOLVER_REASON_UNSOLVABLE = *solvc::Solver_SOLVER_REASON_UNSOLVABLE;
*SOLVER_REASON_UNSOLVABLE = *solvc::Solver_SOLVER_REASON_UNSOLVABLE;
*SOLVER_REASON_PREMISE = *solvc::Solver_SOLVER_REASON_PREMISE;
*SOLVER_REASON_PREMISE = *solvc::Solver_SOLVER_REASON_PREMISE;
*SOLVER_RULE_RPM = *solvc::Solver_SOLVER_RULE_RPM;
*SOLVER_RULE_RPM = *solvc::Solver_SOLVER_RULE_RPM;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Solver($self);
        delete $OWNER{$self};
    }
}

*set_flag = *solvc::Solver_set_flag;
*get_flag = *solvc::Solver_get_flag;
*solve = *solvc::Solver_solve;
*transaction = *solvc::Solver_transaction;
*describe_decision = *solvc::Solver_describe_decision;
*describe_weakdep_decision_raw = *solvc::Solver_describe_weakdep_decision_raw;
*alternatives_count = *solvc::Solver_alternatives_count;
*get_alternative = *solvc::Solver_get_alternative;
*alternatives = *solvc::Solver_alternatives;
*write_testcase = *solvc::Solver_write_testcase;
*raw_decisions = *solvc::Solver_raw_decisions;
*all_decisions = *solvc::Solver_all_decisions;
*get_decision = *solvc::Solver_get_decision;
*get_learnt = *solvc::Solver_get_learnt;
*get_decisionlist = *solvc::Solver_get_decisionlist;
*get_recommended = *solvc::Solver_get_recommended;
*get_suggested = *solvc::Solver_get_suggested;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Chksum ##############

package solv::Chksum;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = solvc::new_Chksum(@_);
    bless $self, $pkg if defined($self);
}

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

*swig_type_get = *solvc::Chksum_type_get;
*swig_type_set = *solvc::Chksum_type_set;
*add = *solvc::Chksum_add;
*add_fp = *solvc::Chksum_add_fp;
*add_fd = *solvc::Chksum_add_fd;
*add_stat = *solvc::Chksum_add_stat;
*add_fstat = *solvc::Chksum_add_fstat;
*raw = *solvc::Chksum_raw;
*hex = *solvc::Chksum_hex;
*typestr = *solvc::Chksum_typestr;
*__eq__ = *solvc::Chksum___eq__;
*__ne__ = *solvc::Chksum___ne__;
*str = *solvc::Chksum_str;
*repr = *solvc::Chksum_repr;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Solvsig ##############

package solv::Solvsig;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_htype_get = *solvc::Solvsig_htype_get;
*swig_htype_set = *solvc::Solvsig_htype_set;
*swig_created_get = *solvc::Solvsig_created_get;
*swig_created_set = *solvc::Solvsig_created_set;
*swig_expires_get = *solvc::Solvsig_expires_get;
*swig_expires_set = *solvc::Solvsig_expires_set;
*swig_keyid_get = *solvc::Solvsig_keyid_get;
*swig_keyid_set = *solvc::Solvsig_keyid_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Solvsig(@_);
    bless $self, $pkg if defined($self);
}

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

*Chksum = *solvc::Solvsig_Chksum;
*verify = *solvc::Solvsig_verify;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::SolvFp ##############

package solv::SolvFp;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_SolvFp($self);
        delete $OWNER{$self};
    }
}

*fileno = *solvc::SolvFp_fileno;
*dup = *solvc::SolvFp_dup;
*write = *solvc::SolvFp_write;
*flush = *solvc::SolvFp_flush;
*close = *solvc::SolvFp_close;
*cloexec = *solvc::SolvFp_cloexec;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Problem ##############

package solv::Problem;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_solv_get = *solvc::Problem_solv_get;
*swig_solv_set = *solvc::Problem_solv_set;
*swig_id_get = *solvc::Problem_id_get;
*swig_id_set = *solvc::Problem_id_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Problem(@_);
    bless $self, $pkg if defined($self);
}

*findproblemrule = *solvc::Problem_findproblemrule;
*findallproblemrules = *solvc::Problem_findallproblemrules;
*solution_count = *solvc::Problem_solution_count;
*solutions = *solvc::Problem_solutions;
*get_learnt = *solvc::Problem_get_learnt;
*get_decisionlist = *solvc::Problem_get_decisionlist;
*get_decisionsetlist = *solvc::Problem_get_decisionsetlist;
*str = *solvc::Problem_str;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Problem($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;
}


############# Class : solv::Solution ##############

package solv::Solution;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_solv_get = *solvc::Solution_solv_get;
*swig_solv_set = *solvc::Solution_solv_set;
*swig_problemid_get = *solvc::Solution_problemid_get;
*swig_problemid_set = *solvc::Solution_problemid_set;
*swig_id_get = *solvc::Solution_id_get;
*swig_id_set = *solvc::Solution_id_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Solution(@_);
    bless $self, $pkg if defined($self);
}

*element_count = *solvc::Solution_element_count;
*elements = *solvc::Solution_elements;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Solution($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;
}


############# Class : solv::Solutionelement ##############

package solv::Solutionelement;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_solv_get = *solvc::Solutionelement_solv_get;
*swig_solv_set = *solvc::Solutionelement_solv_set;
*swig_problemid_get = *solvc::Solutionelement_problemid_get;
*swig_problemid_set = *solvc::Solutionelement_problemid_set;
*swig_solutionid_get = *solvc::Solutionelement_solutionid_get;
*swig_solutionid_set = *solvc::Solutionelement_solutionid_set;
*swig_type_get = *solvc::Solutionelement_type_get;
*swig_type_set = *solvc::Solutionelement_type_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_Solutionelement(@_);
    bless $self, $pkg if defined($self);
}

*str = *solvc::Solutionelement_str;
*replaceelements = *solvc::Solutionelement_replaceelements;
*illegalreplace = *solvc::Solutionelement_illegalreplace;
*swig_solvable_get = *solvc::Solutionelement_solvable_get;
*swig_solvable_set = *solvc::Solutionelement_solvable_set;
*swig_replacement_get = *solvc::Solutionelement_replacement_get;
*swig_replacement_set = *solvc::Solutionelement_replacement_set;
*swig_jobidx_get = *solvc::Solutionelement_jobidx_get;
*swig_jobidx_set = *solvc::Solutionelement_jobidx_set;
*Job = *solvc::Solutionelement_Job;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Solutionelement($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;
}


############# Class : solv::Alternative ##############

package solv::Alternative;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_solv_get = *solvc::Alternative_solv_get;
*swig_solv_set = *solvc::Alternative_solv_set;
*swig_type_get = *solvc::Alternative_type_get;
*swig_type_set = *solvc::Alternative_type_set;
*swig_dep_id_get = *solvc::Alternative_dep_id_get;
*swig_dep_id_set = *solvc::Alternative_dep_id_set;
*swig_chosen_id_get = *solvc::Alternative_chosen_id_get;
*swig_chosen_id_set = *solvc::Alternative_chosen_id_set;
*swig_level_get = *solvc::Alternative_level_get;
*swig_level_set = *solvc::Alternative_level_set;
*SOLVER_ALTERNATIVE_TYPE_RULE = *solvc::Alternative_SOLVER_ALTERNATIVE_TYPE_RULE;
*SOLVER_ALTERNATIVE_TYPE_RULE = *solvc::Alternative_SOLVER_ALTERNATIVE_TYPE_RULE;
*SOLVER_ALTERNATIVE_TYPE_RECOMMENDS = *solvc::Alternative_SOLVER_ALTERNATIVE_TYPE_RECOMMENDS;
*SOLVER_ALTERNATIVE_TYPE_RECOMMENDS = *solvc::Alternative_SOLVER_ALTERNATIVE_TYPE_RECOMMENDS;
*SOLVER_ALTERNATIVE_TYPE_SUGGESTS = *solvc::Alternative_SOLVER_ALTERNATIVE_TYPE_SUGGESTS;
*SOLVER_ALTERNATIVE_TYPE_SUGGESTS = *solvc::Alternative_SOLVER_ALTERNATIVE_TYPE_SUGGESTS;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Alternative($self);
        delete $OWNER{$self};
    }
}

*swig_chosen_get = *solvc::Alternative_chosen_get;
*swig_chosen_set = *solvc::Alternative_chosen_set;
*swig_rule_get = *solvc::Alternative_rule_get;
*swig_rule_set = *solvc::Alternative_rule_set;
*swig_depsolvable_get = *solvc::Alternative_depsolvable_get;
*swig_depsolvable_set = *solvc::Alternative_depsolvable_set;
*swig_dep_get = *solvc::Alternative_dep_get;
*swig_dep_set = *solvc::Alternative_dep_set;
*choices_raw = *solvc::Alternative_choices_raw;
*choices = *solvc::Alternative_choices;
*str = *solvc::Alternative_str;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::Transaction ##############

package solv::Transaction;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_pool_get = *solvc::Transaction_pool_get;
*swig_pool_set = *solvc::Transaction_pool_set;
*SOLVER_TRANSACTION_IGNORE = *solvc::Transaction_SOLVER_TRANSACTION_IGNORE;
*SOLVER_TRANSACTION_IGNORE = *solvc::Transaction_SOLVER_TRANSACTION_IGNORE;
*SOLVER_TRANSACTION_ERASE = *solvc::Transaction_SOLVER_TRANSACTION_ERASE;
*SOLVER_TRANSACTION_ERASE = *solvc::Transaction_SOLVER_TRANSACTION_ERASE;
*SOLVER_TRANSACTION_REINSTALLED = *solvc::Transaction_SOLVER_TRANSACTION_REINSTALLED;
*SOLVER_TRANSACTION_REINSTALLED = *solvc::Transaction_SOLVER_TRANSACTION_REINSTALLED;
*SOLVER_TRANSACTION_DOWNGRADED = *solvc::Transaction_SOLVER_TRANSACTION_DOWNGRADED;
*SOLVER_TRANSACTION_DOWNGRADED = *solvc::Transaction_SOLVER_TRANSACTION_DOWNGRADED;
*SOLVER_TRANSACTION_CHANGED = *solvc::Transaction_SOLVER_TRANSACTION_CHANGED;
*SOLVER_TRANSACTION_CHANGED = *solvc::Transaction_SOLVER_TRANSACTION_CHANGED;
*SOLVER_TRANSACTION_UPGRADED = *solvc::Transaction_SOLVER_TRANSACTION_UPGRADED;
*SOLVER_TRANSACTION_UPGRADED = *solvc::Transaction_SOLVER_TRANSACTION_UPGRADED;
*SOLVER_TRANSACTION_OBSOLETED = *solvc::Transaction_SOLVER_TRANSACTION_OBSOLETED;
*SOLVER_TRANSACTION_OBSOLETED = *solvc::Transaction_SOLVER_TRANSACTION_OBSOLETED;
*SOLVER_TRANSACTION_INSTALL = *solvc::Transaction_SOLVER_TRANSACTION_INSTALL;
*SOLVER_TRANSACTION_INSTALL = *solvc::Transaction_SOLVER_TRANSACTION_INSTALL;
*SOLVER_TRANSACTION_REINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_REINSTALL;
*SOLVER_TRANSACTION_REINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_REINSTALL;
*SOLVER_TRANSACTION_DOWNGRADE = *solvc::Transaction_SOLVER_TRANSACTION_DOWNGRADE;
*SOLVER_TRANSACTION_DOWNGRADE = *solvc::Transaction_SOLVER_TRANSACTION_DOWNGRADE;
*SOLVER_TRANSACTION_CHANGE = *solvc::Transaction_SOLVER_TRANSACTION_CHANGE;
*SOLVER_TRANSACTION_CHANGE = *solvc::Transaction_SOLVER_TRANSACTION_CHANGE;
*SOLVER_TRANSACTION_UPGRADE = *solvc::Transaction_SOLVER_TRANSACTION_UPGRADE;
*SOLVER_TRANSACTION_UPGRADE = *solvc::Transaction_SOLVER_TRANSACTION_UPGRADE;
*SOLVER_TRANSACTION_OBSOLETES = *solvc::Transaction_SOLVER_TRANSACTION_OBSOLETES;
*SOLVER_TRANSACTION_OBSOLETES = *solvc::Transaction_SOLVER_TRANSACTION_OBSOLETES;
*SOLVER_TRANSACTION_MULTIINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_MULTIINSTALL;
*SOLVER_TRANSACTION_MULTIINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_MULTIINSTALL;
*SOLVER_TRANSACTION_MULTIREINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_MULTIREINSTALL;
*SOLVER_TRANSACTION_MULTIREINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_MULTIREINSTALL;
*SOLVER_TRANSACTION_MAXTYPE = *solvc::Transaction_SOLVER_TRANSACTION_MAXTYPE;
*SOLVER_TRANSACTION_MAXTYPE = *solvc::Transaction_SOLVER_TRANSACTION_MAXTYPE;
*SOLVER_TRANSACTION_SHOW_ACTIVE = *solvc::Transaction_SOLVER_TRANSACTION_SHOW_ACTIVE;
*SOLVER_TRANSACTION_SHOW_ACTIVE = *solvc::Transaction_SOLVER_TRANSACTION_SHOW_ACTIVE;
*SOLVER_TRANSACTION_SHOW_ALL = *solvc::Transaction_SOLVER_TRANSACTION_SHOW_ALL;
*SOLVER_TRANSACTION_SHOW_ALL = *solvc::Transaction_SOLVER_TRANSACTION_SHOW_ALL;
*SOLVER_TRANSACTION_SHOW_OBSOLETES = *solvc::Transaction_SOLVER_TRANSACTION_SHOW_OBSOLETES;
*SOLVER_TRANSACTION_SHOW_OBSOLETES = *solvc::Transaction_SOLVER_TRANSACTION_SHOW_OBSOLETES;
*SOLVER_TRANSACTION_SHOW_MULTIINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_SHOW_MULTIINSTALL;
*SOLVER_TRANSACTION_SHOW_MULTIINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_SHOW_MULTIINSTALL;
*SOLVER_TRANSACTION_CHANGE_IS_REINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_CHANGE_IS_REINSTALL;
*SOLVER_TRANSACTION_CHANGE_IS_REINSTALL = *solvc::Transaction_SOLVER_TRANSACTION_CHANGE_IS_REINSTALL;
*SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE = *solvc::Transaction_SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE;
*SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE = *solvc::Transaction_SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE;
*SOLVER_TRANSACTION_MERGE_VENDORCHANGES = *solvc::Transaction_SOLVER_TRANSACTION_MERGE_VENDORCHANGES;
*SOLVER_TRANSACTION_MERGE_VENDORCHANGES = *solvc::Transaction_SOLVER_TRANSACTION_MERGE_VENDORCHANGES;
*SOLVER_TRANSACTION_MERGE_ARCHCHANGES = *solvc::Transaction_SOLVER_TRANSACTION_MERGE_ARCHCHANGES;
*SOLVER_TRANSACTION_MERGE_ARCHCHANGES = *solvc::Transaction_SOLVER_TRANSACTION_MERGE_ARCHCHANGES;
*SOLVER_TRANSACTION_RPM_ONLY = *solvc::Transaction_SOLVER_TRANSACTION_RPM_ONLY;
*SOLVER_TRANSACTION_RPM_ONLY = *solvc::Transaction_SOLVER_TRANSACTION_RPM_ONLY;
*SOLVER_TRANSACTION_ARCHCHANGE = *solvc::Transaction_SOLVER_TRANSACTION_ARCHCHANGE;
*SOLVER_TRANSACTION_ARCHCHANGE = *solvc::Transaction_SOLVER_TRANSACTION_ARCHCHANGE;
*SOLVER_TRANSACTION_VENDORCHANGE = *solvc::Transaction_SOLVER_TRANSACTION_VENDORCHANGE;
*SOLVER_TRANSACTION_VENDORCHANGE = *solvc::Transaction_SOLVER_TRANSACTION_VENDORCHANGE;
*SOLVER_TRANSACTION_KEEP_ORDERDATA = *solvc::Transaction_SOLVER_TRANSACTION_KEEP_ORDERDATA;
*SOLVER_TRANSACTION_KEEP_ORDERDATA = *solvc::Transaction_SOLVER_TRANSACTION_KEEP_ORDERDATA;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_Transaction($self);
        delete $OWNER{$self};
    }
}

*isempty = *solvc::Transaction_isempty;
*othersolvable = *solvc::Transaction_othersolvable;
*allothersolvables = *solvc::Transaction_allothersolvables;
*classify = *solvc::Transaction_classify;
*newpackages = *solvc::Transaction_newpackages;
*keptpackages = *solvc::Transaction_keptpackages;
*newsolvables = *solvc::Transaction_newsolvables;
*keptsolvables = *solvc::Transaction_keptsolvables;
*steps = *solvc::Transaction_steps;
*steptype = *solvc::Transaction_steptype;
*calc_installsizechange = *solvc::Transaction_calc_installsizechange;
*order = *solvc::Transaction_order;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

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


############# Class : solv::TransactionClass ##############

package solv::TransactionClass;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( solv );
%OWNER = ();
%ITERATORS = ();
*swig_transaction_get = *solvc::TransactionClass_transaction_get;
*swig_transaction_set = *solvc::TransactionClass_transaction_set;
*swig_type_get = *solvc::TransactionClass_type_get;
*swig_type_set = *solvc::TransactionClass_type_set;
*swig_fromid_get = *solvc::TransactionClass_fromid_get;
*swig_fromid_set = *solvc::TransactionClass_fromid_set;
*swig_toid_get = *solvc::TransactionClass_toid_get;
*swig_toid_set = *solvc::TransactionClass_toid_set;
*swig_count_get = *solvc::TransactionClass_count_get;
*swig_count_set = *solvc::TransactionClass_count_set;
sub new {
    my $pkg = shift;
    my $self = solvc::new_TransactionClass(@_);
    bless $self, $pkg if defined($self);
}

*solvables = *solvc::TransactionClass_solvables;
*swig_fromstr_get = *solvc::TransactionClass_fromstr_get;
*swig_fromstr_set = *solvc::TransactionClass_fromstr_set;
*swig_tostr_get = *solvc::TransactionClass_tostr_get;
*swig_tostr_set = *solvc::TransactionClass_tostr_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        solvc::delete_TransactionClass($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;
}


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

package solv;

*ID_NULL = *solvc::ID_NULL;
*ID_EMPTY = *solvc::ID_EMPTY;
*SOLVABLE_NAME = *solvc::SOLVABLE_NAME;
*SOLVABLE_ARCH = *solvc::SOLVABLE_ARCH;
*SOLVABLE_EVR = *solvc::SOLVABLE_EVR;
*SOLVABLE_VENDOR = *solvc::SOLVABLE_VENDOR;
*SOLVABLE_PROVIDES = *solvc::SOLVABLE_PROVIDES;
*SOLVABLE_OBSOLETES = *solvc::SOLVABLE_OBSOLETES;
*SOLVABLE_CONFLICTS = *solvc::SOLVABLE_CONFLICTS;
*SOLVABLE_REQUIRES = *solvc::SOLVABLE_REQUIRES;
*SOLVABLE_RECOMMENDS = *solvc::SOLVABLE_RECOMMENDS;
*SOLVABLE_SUGGESTS = *solvc::SOLVABLE_SUGGESTS;
*SOLVABLE_SUPPLEMENTS = *solvc::SOLVABLE_SUPPLEMENTS;
*SOLVABLE_ENHANCES = *solvc::SOLVABLE_ENHANCES;
*RPM_RPMDBID = *solvc::RPM_RPMDBID;
*SOLVABLE_PREREQMARKER = *solvc::SOLVABLE_PREREQMARKER;
*SOLVABLE_FILEMARKER = *solvc::SOLVABLE_FILEMARKER;
*NAMESPACE_INSTALLED = *solvc::NAMESPACE_INSTALLED;
*NAMESPACE_MODALIAS = *solvc::NAMESPACE_MODALIAS;
*NAMESPACE_SPLITPROVIDES = *solvc::NAMESPACE_SPLITPROVIDES;
*NAMESPACE_LANGUAGE = *solvc::NAMESPACE_LANGUAGE;
*NAMESPACE_FILESYSTEM = *solvc::NAMESPACE_FILESYSTEM;
*NAMESPACE_OTHERPROVIDERS = *solvc::NAMESPACE_OTHERPROVIDERS;
*SYSTEM_SYSTEM = *solvc::SYSTEM_SYSTEM;
*ARCH_SRC = *solvc::ARCH_SRC;
*ARCH_NOSRC = *solvc::ARCH_NOSRC;
*ARCH_NOARCH = *solvc::ARCH_NOARCH;
*ARCH_ALL = *solvc::ARCH_ALL;
*ARCH_ANY = *solvc::ARCH_ANY;
*REPOSITORY_SOLVABLES = *solvc::REPOSITORY_SOLVABLES;
*REPOSITORY_DELTAINFO = *solvc::REPOSITORY_DELTAINFO;
*REPOSITORY_EXTERNAL = *solvc::REPOSITORY_EXTERNAL;
*REPOSITORY_KEYS = *solvc::REPOSITORY_KEYS;
*REPOSITORY_LOCATION = *solvc::REPOSITORY_LOCATION;
*REPOKEY_TYPE_VOID = *solvc::REPOKEY_TYPE_VOID;
*REPOKEY_TYPE_CONSTANT = *solvc::REPOKEY_TYPE_CONSTANT;
*REPOKEY_TYPE_CONSTANTID = *solvc::REPOKEY_TYPE_CONSTANTID;
*REPOKEY_TYPE_ID = *solvc::REPOKEY_TYPE_ID;
*REPOKEY_TYPE_NUM = *solvc::REPOKEY_TYPE_NUM;
*REPOKEY_TYPE_DIR = *solvc::REPOKEY_TYPE_DIR;
*REPOKEY_TYPE_STR = *solvc::REPOKEY_TYPE_STR;
*REPOKEY_TYPE_BINARY = *solvc::REPOKEY_TYPE_BINARY;
*REPOKEY_TYPE_IDARRAY = *solvc::REPOKEY_TYPE_IDARRAY;
*REPOKEY_TYPE_REL_IDARRAY = *solvc::REPOKEY_TYPE_REL_IDARRAY;
*REPOKEY_TYPE_DIRSTRARRAY = *solvc::REPOKEY_TYPE_DIRSTRARRAY;
*REPOKEY_TYPE_DIRNUMNUMARRAY = *solvc::REPOKEY_TYPE_DIRNUMNUMARRAY;
*REPOKEY_TYPE_MD5 = *solvc::REPOKEY_TYPE_MD5;
*REPOKEY_TYPE_SHA1 = *solvc::REPOKEY_TYPE_SHA1;
*REPOKEY_TYPE_SHA224 = *solvc::REPOKEY_TYPE_SHA224;
*REPOKEY_TYPE_SHA256 = *solvc::REPOKEY_TYPE_SHA256;
*REPOKEY_TYPE_SHA384 = *solvc::REPOKEY_TYPE_SHA384;
*REPOKEY_TYPE_SHA512 = *solvc::REPOKEY_TYPE_SHA512;
*REPOKEY_TYPE_FIXARRAY = *solvc::REPOKEY_TYPE_FIXARRAY;
*REPOKEY_TYPE_FLEXARRAY = *solvc::REPOKEY_TYPE_FLEXARRAY;
*REPOKEY_TYPE_DELETED = *solvc::REPOKEY_TYPE_DELETED;
*SOLVABLE_SUMMARY = *solvc::SOLVABLE_SUMMARY;
*SOLVABLE_DESCRIPTION = *solvc::SOLVABLE_DESCRIPTION;
*SOLVABLE_DISTRIBUTION = *solvc::SOLVABLE_DISTRIBUTION;
*SOLVABLE_AUTHORS = *solvc::SOLVABLE_AUTHORS;
*SOLVABLE_PACKAGER = *solvc::SOLVABLE_PACKAGER;
*SOLVABLE_GROUP = *solvc::SOLVABLE_GROUP;
*SOLVABLE_URL = *solvc::SOLVABLE_URL;
*SOLVABLE_KEYWORDS = *solvc::SOLVABLE_KEYWORDS;
*SOLVABLE_LICENSE = *solvc::SOLVABLE_LICENSE;
*SOLVABLE_BUILDTIME = *solvc::SOLVABLE_BUILDTIME;
*SOLVABLE_BUILDHOST = *solvc::SOLVABLE_BUILDHOST;
*SOLVABLE_EULA = *solvc::SOLVABLE_EULA;
*SOLVABLE_CPEID = *solvc::SOLVABLE_CPEID;
*SOLVABLE_MESSAGEINS = *solvc::SOLVABLE_MESSAGEINS;
*SOLVABLE_MESSAGEDEL = *solvc::SOLVABLE_MESSAGEDEL;
*SOLVABLE_INSTALLSIZE = *solvc::SOLVABLE_INSTALLSIZE;
*SOLVABLE_DISKUSAGE = *solvc::SOLVABLE_DISKUSAGE;
*SOLVABLE_FILELIST = *solvc::SOLVABLE_FILELIST;
*SOLVABLE_INSTALLTIME = *solvc::SOLVABLE_INSTALLTIME;
*SOLVABLE_MEDIADIR = *solvc::SOLVABLE_MEDIADIR;
*SOLVABLE_MEDIAFILE = *solvc::SOLVABLE_MEDIAFILE;
*SOLVABLE_MEDIANR = *solvc::SOLVABLE_MEDIANR;
*SOLVABLE_MEDIABASE = *solvc::SOLVABLE_MEDIABASE;
*SOLVABLE_DOWNLOADSIZE = *solvc::SOLVABLE_DOWNLOADSIZE;
*SOLVABLE_SOURCEARCH = *solvc::SOLVABLE_SOURCEARCH;
*SOLVABLE_SOURCENAME = *solvc::SOLVABLE_SOURCENAME;
*SOLVABLE_SOURCEEVR = *solvc::SOLVABLE_SOURCEEVR;
*SOLVABLE_ISVISIBLE = *solvc::SOLVABLE_ISVISIBLE;
*SOLVABLE_TRIGGERS = *solvc::SOLVABLE_TRIGGERS;
*SOLVABLE_CHECKSUM = *solvc::SOLVABLE_CHECKSUM;
*SOLVABLE_PKGID = *solvc::SOLVABLE_PKGID;
*SOLVABLE_HDRID = *solvc::SOLVABLE_HDRID;
*SOLVABLE_LEADSIGID = *solvc::SOLVABLE_LEADSIGID;
*SOLVABLE_PATCHCATEGORY = *solvc::SOLVABLE_PATCHCATEGORY;
*SOLVABLE_HEADEREND = *solvc::SOLVABLE_HEADEREND;
*SOLVABLE_CHANGELOG = *solvc::SOLVABLE_CHANGELOG;
*SOLVABLE_CHANGELOG_AUTHOR = *solvc::SOLVABLE_CHANGELOG_AUTHOR;
*SOLVABLE_CHANGELOG_TIME = *solvc::SOLVABLE_CHANGELOG_TIME;
*SOLVABLE_CHANGELOG_TEXT = *solvc::SOLVABLE_CHANGELOG_TEXT;
*SOLVABLE_INSTALLSTATUS = *solvc::SOLVABLE_INSTALLSTATUS;
*SOLVABLE_PREREQ_IGNOREINST = *solvc::SOLVABLE_PREREQ_IGNOREINST;
*SOLVABLE_CATEGORY = *solvc::SOLVABLE_CATEGORY;
*SOLVABLE_INCLUDES = *solvc::SOLVABLE_INCLUDES;
*SOLVABLE_EXTENDS = *solvc::SOLVABLE_EXTENDS;
*SOLVABLE_ICON = *solvc::SOLVABLE_ICON;
*SOLVABLE_ORDER = *solvc::SOLVABLE_ORDER;
*UPDATE_REBOOT = *solvc::UPDATE_REBOOT;
*UPDATE_RESTART = *solvc::UPDATE_RESTART;
*UPDATE_RELOGIN = *solvc::UPDATE_RELOGIN;
*UPDATE_MESSAGE = *solvc::UPDATE_MESSAGE;
*UPDATE_SEVERITY = *solvc::UPDATE_SEVERITY;
*UPDATE_RIGHTS = *solvc::UPDATE_RIGHTS;
*UPDATE_COLLECTION = *solvc::UPDATE_COLLECTION;
*UPDATE_COLLECTION_NAME = *solvc::UPDATE_COLLECTION_NAME;
*UPDATE_COLLECTION_EVR = *solvc::UPDATE_COLLECTION_EVR;
*UPDATE_COLLECTION_ARCH = *solvc::UPDATE_COLLECTION_ARCH;
*UPDATE_COLLECTION_FILENAME = *solvc::UPDATE_COLLECTION_FILENAME;
*UPDATE_COLLECTION_FLAGS = *solvc::UPDATE_COLLECTION_FLAGS;
*UPDATE_REFERENCE = *solvc::UPDATE_REFERENCE;
*UPDATE_REFERENCE_TYPE = *solvc::UPDATE_REFERENCE_TYPE;
*UPDATE_REFERENCE_HREF = *solvc::UPDATE_REFERENCE_HREF;
*UPDATE_REFERENCE_ID = *solvc::UPDATE_REFERENCE_ID;
*UPDATE_REFERENCE_TITLE = *solvc::UPDATE_REFERENCE_TITLE;
*PRODUCT_REFERENCEFILE = *solvc::PRODUCT_REFERENCEFILE;
*PRODUCT_SHORTLABEL = *solvc::PRODUCT_SHORTLABEL;
*PRODUCT_DISTPRODUCT = *solvc::PRODUCT_DISTPRODUCT;
*PRODUCT_DISTVERSION = *solvc::PRODUCT_DISTVERSION;
*PRODUCT_TYPE = *solvc::PRODUCT_TYPE;
*PRODUCT_URL = *solvc::PRODUCT_URL;
*PRODUCT_URL_TYPE = *solvc::PRODUCT_URL_TYPE;
*PRODUCT_FLAGS = *solvc::PRODUCT_FLAGS;
*PRODUCT_PRODUCTLINE = *solvc::PRODUCT_PRODUCTLINE;
*PRODUCT_REGISTER_TARGET = *solvc::PRODUCT_REGISTER_TARGET;
*PRODUCT_REGISTER_FLAVOR = *solvc::PRODUCT_REGISTER_FLAVOR;
*PRODUCT_REGISTER_RELEASE = *solvc::PRODUCT_REGISTER_RELEASE;
*PRODUCT_UPDATES_REPOID = *solvc::PRODUCT_UPDATES_REPOID;
*PRODUCT_UPDATES = *solvc::PRODUCT_UPDATES;
*PRODUCT_ENDOFLIFE = *solvc::PRODUCT_ENDOFLIFE;
*SUSETAGS_DATADIR = *solvc::SUSETAGS_DATADIR;
*SUSETAGS_DESCRDIR = *solvc::SUSETAGS_DESCRDIR;
*SUSETAGS_DEFAULTVENDOR = *solvc::SUSETAGS_DEFAULTVENDOR;
*SUSETAGS_FILE = *solvc::SUSETAGS_FILE;
*SUSETAGS_FILE_NAME = *solvc::SUSETAGS_FILE_NAME;
*SUSETAGS_FILE_TYPE = *solvc::SUSETAGS_FILE_TYPE;
*SUSETAGS_FILE_CHECKSUM = *solvc::SUSETAGS_FILE_CHECKSUM;
*SUSETAGS_SHARE_NAME = *solvc::SUSETAGS_SHARE_NAME;
*SUSETAGS_SHARE_EVR = *solvc::SUSETAGS_SHARE_EVR;
*SUSETAGS_SHARE_ARCH = *solvc::SUSETAGS_SHARE_ARCH;
*REPOSITORY_ADDEDFILEPROVIDES = *solvc::REPOSITORY_ADDEDFILEPROVIDES;
*REPOSITORY_RPMDBCOOKIE = *solvc::REPOSITORY_RPMDBCOOKIE;
*REPOSITORY_FILTEREDFILELIST = *solvc::REPOSITORY_FILTEREDFILELIST;
*REPOSITORY_TIMESTAMP = *solvc::REPOSITORY_TIMESTAMP;
*REPOSITORY_EXPIRE = *solvc::REPOSITORY_EXPIRE;
*REPOSITORY_UPDATES = *solvc::REPOSITORY_UPDATES;
*REPOSITORY_DISTROS = *solvc::REPOSITORY_DISTROS;
*REPOSITORY_PRODUCT_LABEL = *solvc::REPOSITORY_PRODUCT_LABEL;
*REPOSITORY_PRODUCT_CPEID = *solvc::REPOSITORY_PRODUCT_CPEID;
*REPOSITORY_REPOID = *solvc::REPOSITORY_REPOID;
*REPOSITORY_KEYWORDS = *solvc::REPOSITORY_KEYWORDS;
*REPOSITORY_REVISION = *solvc::REPOSITORY_REVISION;
*REPOSITORY_TOOLVERSION = *solvc::REPOSITORY_TOOLVERSION;
*DELTA_PACKAGE_NAME = *solvc::DELTA_PACKAGE_NAME;
*DELTA_PACKAGE_EVR = *solvc::DELTA_PACKAGE_EVR;
*DELTA_PACKAGE_ARCH = *solvc::DELTA_PACKAGE_ARCH;
*DELTA_LOCATION_DIR = *solvc::DELTA_LOCATION_DIR;
*DELTA_LOCATION_NAME = *solvc::DELTA_LOCATION_NAME;
*DELTA_LOCATION_EVR = *solvc::DELTA_LOCATION_EVR;
*DELTA_LOCATION_SUFFIX = *solvc::DELTA_LOCATION_SUFFIX;
*DELTA_DOWNLOADSIZE = *solvc::DELTA_DOWNLOADSIZE;
*DELTA_CHECKSUM = *solvc::DELTA_CHECKSUM;
*DELTA_BASE_EVR = *solvc::DELTA_BASE_EVR;
*DELTA_SEQ_NAME = *solvc::DELTA_SEQ_NAME;
*DELTA_SEQ_EVR = *solvc::DELTA_SEQ_EVR;
*DELTA_SEQ_NUM = *solvc::DELTA_SEQ_NUM;
*DELTA_LOCATION_BASE = *solvc::DELTA_LOCATION_BASE;
*REPOSITORY_REPOMD = *solvc::REPOSITORY_REPOMD;
*REPOSITORY_REPOMD_TYPE = *solvc::REPOSITORY_REPOMD_TYPE;
*REPOSITORY_REPOMD_LOCATION = *solvc::REPOSITORY_REPOMD_LOCATION;
*REPOSITORY_REPOMD_TIMESTAMP = *solvc::REPOSITORY_REPOMD_TIMESTAMP;
*REPOSITORY_REPOMD_CHECKSUM = *solvc::REPOSITORY_REPOMD_CHECKSUM;
*REPOSITORY_REPOMD_OPENCHECKSUM = *solvc::REPOSITORY_REPOMD_OPENCHECKSUM;
*REPOSITORY_REPOMD_SIZE = *solvc::REPOSITORY_REPOMD_SIZE;
*PUBKEY_KEYID = *solvc::PUBKEY_KEYID;
*PUBKEY_FINGERPRINT = *solvc::PUBKEY_FINGERPRINT;
*PUBKEY_EXPIRES = *solvc::PUBKEY_EXPIRES;
*PUBKEY_SIGNATURES = *solvc::PUBKEY_SIGNATURES;
*PUBKEY_DATA = *solvc::PUBKEY_DATA;
*PUBKEY_SUBKEYOF = *solvc::PUBKEY_SUBKEYOF;
*SIGNATURE_ISSUER = *solvc::SIGNATURE_ISSUER;
*SIGNATURE_TIME = *solvc::SIGNATURE_TIME;
*SIGNATURE_EXPIRES = *solvc::SIGNATURE_EXPIRES;
*SIGNATURE_DATA = *solvc::SIGNATURE_DATA;
*UPDATE_MODULE = *solvc::UPDATE_MODULE;
*UPDATE_MODULE_NAME = *solvc::UPDATE_MODULE_NAME;
*UPDATE_MODULE_STREAM = *solvc::UPDATE_MODULE_STREAM;
*UPDATE_MODULE_VERSION = *solvc::UPDATE_MODULE_VERSION;
*UPDATE_MODULE_CONTEXT = *solvc::UPDATE_MODULE_CONTEXT;
*UPDATE_MODULE_ARCH = *solvc::UPDATE_MODULE_ARCH;
*SOLVABLE_BUILDVERSION = *solvc::SOLVABLE_BUILDVERSION;
*SOLVABLE_BUILDFLAVOR = *solvc::SOLVABLE_BUILDFLAVOR;
*UPDATE_STATUS = *solvc::UPDATE_STATUS;
*LIBSOLV_SELF_DESTRUCT_PKG = *solvc::LIBSOLV_SELF_DESTRUCT_PKG;
*SOLVABLE_CONSTRAINS = *solvc::SOLVABLE_CONSTRAINS;
*SOLVABLE_TRACK_FEATURES = *solvc::SOLVABLE_TRACK_FEATURES;
*SOLVABLE_ISDEFAULT = *solvc::SOLVABLE_ISDEFAULT;
*SOLVABLE_LANGONLY = *solvc::SOLVABLE_LANGONLY;
*UPDATE_COLLECTIONLIST = *solvc::UPDATE_COLLECTIONLIST;
*SOLVABLE_MULTIARCH = *solvc::SOLVABLE_MULTIARCH;
*SOLVABLE_SIGNATUREDATA = *solvc::SOLVABLE_SIGNATUREDATA;
*SOLVABLE_ORDERWITHREQUIRES = *solvc::SOLVABLE_ORDERWITHREQUIRES;
*ID_NUM_INTERNAL = *solvc::ID_NUM_INTERNAL;
*SOLVID_META = *solvc::SOLVID_META;
*SOLVID_POS = *solvc::SOLVID_POS;
*REL_EQ = *solvc::REL_EQ;
*REL_GT = *solvc::REL_GT;
*REL_LT = *solvc::REL_LT;
*REL_AND = *solvc::REL_AND;
*REL_OR = *solvc::REL_OR;
*REL_WITH = *solvc::REL_WITH;
*REL_NAMESPACE = *solvc::REL_NAMESPACE;
*REL_ARCH = *solvc::REL_ARCH;
*REL_FILECONFLICT = *solvc::REL_FILECONFLICT;
*REL_COND = *solvc::REL_COND;
*REL_COMPAT = *solvc::REL_COMPAT;
*REL_KIND = *solvc::REL_KIND;
*REL_MULTIARCH = *solvc::REL_MULTIARCH;
*REL_ELSE = *solvc::REL_ELSE;
*REL_ERROR = *solvc::REL_ERROR;
*REL_WITHOUT = *solvc::REL_WITHOUT;
*REL_UNLESS = *solvc::REL_UNLESS;
*REL_CONDA = *solvc::REL_CONDA;

    sub solv::Dataiterator::FETCH {
      my $i = ${solv::Dataiterator::ITERATORS}{$_[0]};
      if ($i) {
        $_[1] == $i->[0] - 1 ? $i->[1] : undef;
      } else {
        $_[0]->__getitem__($_[1]);
      }
    }
    sub solv::Dataiterator::FETCHSIZE {
      my $i = ${solv::Dataiterator::ITERATORS}{$_[0]};
      if ($i) {
        ($i->[1] = $_[0]->__next__()) ? ++$i->[0]  : 0;
      } else {
        $_[0]->__len__();
      }
    }
  
    sub solv::Pool_solvable_iterator::FETCH {
      my $i = ${solv::Pool_solvable_iterator::ITERATORS}{$_[0]};
      if ($i) {
        $_[1] == $i->[0] - 1 ? $i->[1] : undef;
      } else {
        $_[0]->__getitem__($_[1]);
      }
    }
    sub solv::Pool_solvable_iterator::FETCHSIZE {
      my $i = ${solv::Pool_solvable_iterator::ITERATORS}{$_[0]};
      if ($i) {
        ($i->[1] = $_[0]->__next__()) ? ++$i->[0]  : 0;
      } else {
        $_[0]->__len__();
      }
    }
  
    sub solv::Pool_repo_iterator::FETCH {
      my $i = ${solv::Pool_repo_iterator::ITERATORS}{$_[0]};
      if ($i) {
        $_[1] == $i->[0] - 1 ? $i->[1] : undef;
      } else {
        $_[0]->__getitem__($_[1]);
      }
    }
    sub solv::Pool_repo_iterator::FETCHSIZE {
      my $i = ${solv::Pool_repo_iterator::ITERATORS}{$_[0]};
      if ($i) {
        ($i->[1] = $_[0]->__next__()) ? ++$i->[0]  : 0;
      } else {
        $_[0]->__len__();
      }
    }
  
    sub solv::Repo_solvable_iterator::FETCH {
      my $i = ${solv::Repo_solvable_iterator::ITERATORS}{$_[0]};
      if ($i) {
        $_[1] == $i->[0] - 1 ? $i->[1] : undef;
      } else {
        $_[0]->__getitem__($_[1]);
      }
    }
    sub solv::Repo_solvable_iterator::FETCHSIZE {
      my $i = ${solv::Repo_solvable_iterator::ITERATORS}{$_[0]};
      if ($i) {
        ($i->[1] = $_[0]->__next__()) ? ++$i->[0]  : 0;
      } else {
        $_[0]->__len__();
      }
    }
  
    *solv::Datamatch::str = *solvc::Datamatch_stringify;
  
    sub solv::Solver::describe_weakdep_decision {
      my ($self, $s) = @_;
      my $pool = $self->{'pool'};
      my @res;
      my @d = $self->describe_weakdep_decision_raw($s);
      push @res, [ splice(@d, 0, 3) ] while @d;
      return map { [ $_->[0], solv::XSolvable->new($pool, $_->[1]), solv::Dep->new($pool, $_->[2]) ] } @res;
    }
  
    undef *solv::Chksum::from_bin;
    *solv::Chksum::from_bin = sub {
      my $pkg = shift;
      my $self = solvc::Chksum_from_bin(@_);
      bless $self, $pkg if defined $self;
    };
  1;
