pub type Stringpool = s_Stringpool;
pub type Pool = s_Pool;
pub type Id = ::std::os::raw::c_int;
pub type Offset = ::std::os::raw::c_uint;
pub type size_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: size_t,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
pub type Hashval = ::std::os::raw::c_uint;
pub type Hashtable = *mut Id;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Reldep {
pub name: Id,
pub evr: Id,
pub flags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_s_Reldep() {
assert_eq!(
::std::mem::size_of::<s_Reldep>(),
12usize,
concat!("Size of: ", stringify!(s_Reldep))
);
assert_eq!(
::std::mem::align_of::<s_Reldep>(),
4usize,
concat!("Alignment of ", stringify!(s_Reldep))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Reldep>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Reldep),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Reldep>())).evr as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(s_Reldep),
"::",
stringify!(evr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Reldep>())).flags as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Reldep),
"::",
stringify!(flags)
)
);
}
pub type Reldep = s_Reldep;
extern "C" {
pub fn pool_str2id(
pool: *mut Pool,
arg1: *const ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn pool_strn2id(
pool: *mut Pool,
arg1: *const ::std::os::raw::c_char,
arg2: ::std::os::raw::c_uint,
arg3: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn pool_rel2id(
pool: *mut Pool,
arg1: Id,
arg2: Id,
arg3: ::std::os::raw::c_int,
arg4: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn pool_id2str(pool: *const Pool, arg1: Id) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_id2rel(pool: *const Pool, arg1: Id) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_id2evr(pool: *const Pool, arg1: Id) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_dep2str(pool: *mut Pool, arg1: Id) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_shrink_strings(pool: *mut Pool);
}
extern "C" {
pub fn pool_shrink_rels(pool: *mut Pool);
}
extern "C" {
pub fn pool_freeidhashes(pool: *mut Pool);
}
extern "C" {
pub fn pool_resize_rels_hash(pool: *mut Pool, numnew: ::std::os::raw::c_int);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Queue {
pub elements: *mut Id,
pub count: ::std::os::raw::c_int,
pub alloc: *mut Id,
pub left: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_s_Queue() {
assert_eq!(
::std::mem::size_of::<s_Queue>(),
32usize,
concat!("Size of: ", stringify!(s_Queue))
);
assert_eq!(
::std::mem::align_of::<s_Queue>(),
8usize,
concat!("Alignment of ", stringify!(s_Queue))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Queue>())).elements as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Queue),
"::",
stringify!(elements)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Queue>())).count as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Queue),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Queue>())).alloc as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Queue),
"::",
stringify!(alloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Queue>())).left as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_Queue),
"::",
stringify!(left)
)
);
}
pub type Queue = s_Queue;
extern "C" {
pub fn queue_alloc_one(q: *mut Queue);
}
extern "C" {
pub fn queue_alloc_one_head(q: *mut Queue);
}
extern "C" {
pub fn queue_init(q: *mut Queue);
}
extern "C" {
pub fn queue_init_buffer(q: *mut Queue, buf: *mut Id, size: ::std::os::raw::c_int);
}
extern "C" {
pub fn queue_init_clone(target: *mut Queue, source: *const Queue);
}
extern "C" {
pub fn queue_free(q: *mut Queue);
}
extern "C" {
pub fn queue_insert(q: *mut Queue, pos: ::std::os::raw::c_int, id: Id);
}
extern "C" {
pub fn queue_insert2(q: *mut Queue, pos: ::std::os::raw::c_int, id1: Id, id2: Id);
}
extern "C" {
pub fn queue_insertn(
q: *mut Queue,
pos: ::std::os::raw::c_int,
n: ::std::os::raw::c_int,
elements: *const Id,
);
}
extern "C" {
pub fn queue_delete(q: *mut Queue, pos: ::std::os::raw::c_int);
}
extern "C" {
pub fn queue_delete2(q: *mut Queue, pos: ::std::os::raw::c_int);
}
extern "C" {
pub fn queue_deleten(q: *mut Queue, pos: ::std::os::raw::c_int, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn queue_prealloc(q: *mut Queue, n: ::std::os::raw::c_int);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Map {
pub map: *mut ::std::os::raw::c_uchar,
pub size: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_s_Map() {
assert_eq!(
::std::mem::size_of::<s_Map>(),
16usize,
concat!("Size of: ", stringify!(s_Map))
);
assert_eq!(
::std::mem::align_of::<s_Map>(),
8usize,
concat!("Alignment of ", stringify!(s_Map))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Map>())).map as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Map),
"::",
stringify!(map)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Map>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Map),
"::",
stringify!(size)
)
);
}
pub type Map = s_Map;
extern "C" {
pub fn map_init(m: *mut Map, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn map_init_clone(target: *mut Map, source: *const Map);
}
extern "C" {
pub fn map_grow(m: *mut Map, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn map_free(m: *mut Map);
}
extern "C" {
pub fn map_and(t: *mut Map, s: *const Map);
}
extern "C" {
pub fn map_or(t: *mut Map, s: *const Map);
}
extern "C" {
pub fn map_subtract(t: *mut Map, s: *const Map);
}
extern "C" {
pub fn map_invertall(m: *mut Map);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Solvable {
pub name: Id,
pub arch: Id,
pub evr: Id,
pub vendor: Id,
pub repo: *mut s_Repo,
pub provides: Offset,
pub obsoletes: Offset,
pub conflicts: Offset,
pub requires: Offset,
pub recommends: Offset,
pub suggests: Offset,
pub supplements: Offset,
pub enhances: Offset,
}
#[test]
fn bindgen_test_layout_s_Solvable() {
assert_eq!(
::std::mem::size_of::<s_Solvable>(),
56usize,
concat!("Size of: ", stringify!(s_Solvable))
);
assert_eq!(
::std::mem::align_of::<s_Solvable>(),
8usize,
concat!("Alignment of ", stringify!(s_Solvable))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).arch as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(arch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).evr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(evr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).vendor as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(vendor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).repo as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(repo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).provides as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(provides)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).obsoletes as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(obsoletes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).conflicts as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(conflicts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).requires as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(requires)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).recommends as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(recommends)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).suggests as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(suggests)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).supplements as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(supplements)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solvable>())).enhances as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(s_Solvable),
"::",
stringify!(enhances)
)
);
}
pub type Solvable = s_Solvable;
extern "C" {
pub fn solvable_lookup_type(s: *mut Solvable, keyname: Id) -> Id;
}
extern "C" {
pub fn solvable_lookup_id(s: *mut Solvable, keyname: Id) -> Id;
}
extern "C" {
pub fn solvable_lookup_num(
s: *mut Solvable,
keyname: Id,
notfound: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn solvable_lookup_sizek(
s: *mut Solvable,
keyname: Id,
notfound: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn solvable_lookup_str(s: *mut Solvable, keyname: Id) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solvable_lookup_str_poollang(
s: *mut Solvable,
keyname: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solvable_lookup_str_lang(
s: *mut Solvable,
keyname: Id,
lang: *const ::std::os::raw::c_char,
usebase: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solvable_lookup_bool(s: *mut Solvable, keyname: Id) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_lookup_void(s: *mut Solvable, keyname: Id) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_get_location(
s: *mut Solvable,
medianrp: *mut ::std::os::raw::c_uint,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solvable_lookup_location(
s: *mut Solvable,
medianrp: *mut ::std::os::raw::c_uint,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solvable_lookup_sourcepkg(s: *mut Solvable) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solvable_lookup_bin_checksum(
s: *mut Solvable,
keyname: Id,
typep: *mut Id,
) -> *const ::std::os::raw::c_uchar;
}
extern "C" {
pub fn solvable_lookup_checksum(
s: *mut Solvable,
keyname: Id,
typep: *mut Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solvable_lookup_idarray(
s: *mut Solvable,
keyname: Id,
q: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_lookup_deparray(
s: *mut Solvable,
keyname: Id,
q: *mut Queue,
marker: Id,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_lookup_count(s: *mut Solvable, keyname: Id) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn solvable_set_id(s: *mut Solvable, keyname: Id, id: Id);
}
extern "C" {
pub fn solvable_set_num(s: *mut Solvable, keyname: Id, num: ::std::os::raw::c_ulonglong);
}
extern "C" {
pub fn solvable_set_str(s: *mut Solvable, keyname: Id, str_: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn solvable_set_poolstr(s: *mut Solvable, keyname: Id, str_: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn solvable_add_poolstr_array(
s: *mut Solvable,
keyname: Id,
str_: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn solvable_add_idarray(s: *mut Solvable, keyname: Id, id: Id);
}
extern "C" {
pub fn solvable_add_deparray(s: *mut Solvable, keyname: Id, dep: Id, marker: Id);
}
extern "C" {
pub fn solvable_set_idarray(s: *mut Solvable, keyname: Id, q: *mut Queue);
}
extern "C" {
pub fn solvable_set_deparray(s: *mut Solvable, keyname: Id, q: *mut Queue, marker: Id);
}
extern "C" {
pub fn solvable_unset(s: *mut Solvable, keyname: Id);
}
extern "C" {
pub fn solvable_identical(s1: *mut Solvable, s2: *mut Solvable) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_selfprovidedep(s: *mut Solvable) -> Id;
}
extern "C" {
pub fn solvable_matchesdep(
s: *mut Solvable,
keyname: Id,
dep: Id,
marker: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_matchessolvable(
s: *mut Solvable,
keyname: Id,
solvid: Id,
depq: *mut Queue,
marker: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_matchessolvable_int(
s: *mut Solvable,
keyname: Id,
marker: ::std::os::raw::c_int,
solvid: Id,
solvidmap: *mut Map,
depq: *mut Queue,
missc: *mut Map,
reloff: ::std::os::raw::c_int,
outdepq: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_is_irrelevant_patch(
s: *mut Solvable,
installedmap: *mut Map,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_trivial_installable_map(
s: *mut Solvable,
installedmap: *mut Map,
conflictsmap: *mut Map,
multiversionmap: *mut Map,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_trivial_installable_queue(
s: *mut Solvable,
installed: *mut Queue,
multiversionmap: *mut Map,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solvable_trivial_installable_repo(
s: *mut Solvable,
installed: *mut s_Repo,
multiversionmap: *mut Map,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Stringpool {
pub strings: *mut Offset,
pub nstrings: ::std::os::raw::c_int,
pub stringspace: *mut ::std::os::raw::c_char,
pub sstrings: Offset,
pub stringhashtbl: Hashtable,
pub stringhashmask: Hashval,
}
#[test]
fn bindgen_test_layout_s_Stringpool() {
assert_eq!(
::std::mem::size_of::<s_Stringpool>(),
48usize,
concat!("Size of: ", stringify!(s_Stringpool))
);
assert_eq!(
::std::mem::align_of::<s_Stringpool>(),
8usize,
concat!("Alignment of ", stringify!(s_Stringpool))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Stringpool>())).strings as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Stringpool),
"::",
stringify!(strings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Stringpool>())).nstrings as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Stringpool),
"::",
stringify!(nstrings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Stringpool>())).stringspace as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Stringpool),
"::",
stringify!(stringspace)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Stringpool>())).sstrings as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_Stringpool),
"::",
stringify!(sstrings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Stringpool>())).stringhashtbl as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(s_Stringpool),
"::",
stringify!(stringhashtbl)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Stringpool>())).stringhashmask as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(s_Stringpool),
"::",
stringify!(stringhashmask)
)
);
}
extern "C" {
pub fn stringpool_init(ss: *mut Stringpool, strs: *mut *const ::std::os::raw::c_char);
}
extern "C" {
pub fn stringpool_init_empty(ss: *mut Stringpool);
}
extern "C" {
pub fn stringpool_clone(ss: *mut Stringpool, from: *mut Stringpool);
}
extern "C" {
pub fn stringpool_free(ss: *mut Stringpool);
}
extern "C" {
pub fn stringpool_freehash(ss: *mut Stringpool);
}
extern "C" {
pub fn stringpool_resize_hash(ss: *mut Stringpool, numnew: ::std::os::raw::c_int);
}
extern "C" {
pub fn stringpool_str2id(
ss: *mut Stringpool,
str_: *const ::std::os::raw::c_char,
create: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn stringpool_strn2id(
ss: *mut Stringpool,
str_: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_uint,
create: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn stringpool_shrink(ss: *mut Stringpool);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Datapos {
pub repo: *mut s_Repo,
pub solvid: Id,
pub repodataid: Id,
pub schema: Id,
pub dp: Id,
}
#[test]
fn bindgen_test_layout_s_Datapos() {
assert_eq!(
::std::mem::size_of::<s_Datapos>(),
24usize,
concat!("Size of: ", stringify!(s_Datapos))
);
assert_eq!(
::std::mem::align_of::<s_Datapos>(),
8usize,
concat!("Alignment of ", stringify!(s_Datapos))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datapos>())).repo as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Datapos),
"::",
stringify!(repo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datapos>())).solvid as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Datapos),
"::",
stringify!(solvid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datapos>())).repodataid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(s_Datapos),
"::",
stringify!(repodataid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datapos>())).schema as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Datapos),
"::",
stringify!(schema)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datapos>())).dp as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(s_Datapos),
"::",
stringify!(dp)
)
);
}
pub type Datapos = s_Datapos;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Pool {
pub appdata: *mut ::std::os::raw::c_void,
pub ss: s_Stringpool,
pub rels: *mut Reldep,
pub nrels: ::std::os::raw::c_int,
pub repos: *mut *mut s_Repo,
pub nrepos: ::std::os::raw::c_int,
pub urepos: ::std::os::raw::c_int,
pub installed: *mut s_Repo,
pub solvables: *mut Solvable,
pub nsolvables: ::std::os::raw::c_int,
pub languages: *mut *const ::std::os::raw::c_char,
pub nlanguages: ::std::os::raw::c_int,
pub disttype: ::std::os::raw::c_int,
pub id2arch: *mut Id,
pub id2color: *mut ::std::os::raw::c_uchar,
pub lastarch: Id,
pub vendormap: Queue,
pub vendorclasses: *mut *const ::std::os::raw::c_char,
pub whatprovides: *mut Offset,
pub whatprovides_rel: *mut Offset,
pub whatprovidesdata: *mut Id,
pub whatprovidesdataoff: Offset,
pub whatprovidesdataleft: ::std::os::raw::c_int,
pub considered: *mut Map,
pub nscallback: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut s_Pool,
data: *mut ::std::os::raw::c_void,
name: Id,
evr: Id,
) -> Id,
>,
pub nscallbackdata: *mut ::std::os::raw::c_void,
pub debugmask: ::std::os::raw::c_int,
pub debugcallback: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut s_Pool,
data: *mut ::std::os::raw::c_void,
type_: ::std::os::raw::c_int,
str_: *const ::std::os::raw::c_char,
),
>,
pub debugcallbackdata: *mut ::std::os::raw::c_void,
pub loadcallback: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut s_Pool,
arg2: *mut s_Repodata,
arg3: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
pub loadcallbackdata: *mut ::std::os::raw::c_void,
pub pos: Datapos,
pub pooljobs: Queue,
}
#[test]
fn bindgen_test_layout_s_Pool() {
assert_eq!(
::std::mem::size_of::<s_Pool>(),
344usize,
concat!("Size of: ", stringify!(s_Pool))
);
assert_eq!(
::std::mem::align_of::<s_Pool>(),
8usize,
concat!("Alignment of ", stringify!(s_Pool))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).appdata as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(appdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).ss as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(ss)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).rels as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(rels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).nrels as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(nrels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).repos as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(repos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).nrepos as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(nrepos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).urepos as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(urepos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).installed as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(installed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).solvables as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(solvables)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).nsolvables as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(nsolvables)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).languages as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(languages)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).nlanguages as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(nlanguages)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).disttype as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(disttype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).id2arch as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(id2arch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).id2color as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(id2color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).lastarch as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(lastarch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).vendormap as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(vendormap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).vendorclasses as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(vendorclasses)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).whatprovides as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(whatprovides)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).whatprovides_rel as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(whatprovides_rel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).whatprovidesdata as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(whatprovidesdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).whatprovidesdataoff as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(whatprovidesdataoff)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).whatprovidesdataleft as *const _ as usize },
220usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(whatprovidesdataleft)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).considered as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(considered)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).nscallback as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(nscallback)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).nscallbackdata as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(nscallbackdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).debugmask as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(debugmask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).debugcallback as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(debugcallback)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).debugcallbackdata as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(debugcallbackdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).loadcallback as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(loadcallback)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).loadcallbackdata as *const _ as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(loadcallbackdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).pos as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Pool>())).pooljobs as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(s_Pool),
"::",
stringify!(pooljobs)
)
);
}
extern "C" {
pub fn pool_create() -> *mut Pool;
}
extern "C" {
pub fn pool_free(pool: *mut Pool);
}
extern "C" {
pub fn pool_freeallrepos(pool: *mut Pool, reuseids: ::std::os::raw::c_int);
}
extern "C" {
pub fn pool_setdebuglevel(pool: *mut Pool, level: ::std::os::raw::c_int);
}
extern "C" {
pub fn pool_setdisttype(
pool: *mut Pool,
disttype: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_set_flag(
pool: *mut Pool,
flag: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_get_flag(pool: *mut Pool, flag: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_debug(
pool: *mut Pool,
type_: ::std::os::raw::c_int,
format: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn pool_setdebugcallback(
pool: *mut Pool,
debugcallback: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut s_Pool,
data: *mut ::std::os::raw::c_void,
type_: ::std::os::raw::c_int,
str_: *const ::std::os::raw::c_char,
),
>,
debugcallbackdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn pool_setdebugmask(pool: *mut Pool, mask: ::std::os::raw::c_int);
}
extern "C" {
pub fn pool_setloadcallback(
pool: *mut Pool,
cb: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut s_Pool,
arg2: *mut s_Repodata,
arg3: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
loadcbdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn pool_setnamespacecallback(
pool: *mut Pool,
cb: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut s_Pool,
arg2: *mut ::std::os::raw::c_void,
arg3: Id,
arg4: Id,
) -> Id,
>,
nscbdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn pool_flush_namespaceproviders(pool: *mut Pool, ns: Id, evr: Id);
}
extern "C" {
pub fn pool_set_custom_vendorcheck(
pool: *mut Pool,
vendorcheck: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut s_Pool,
arg2: *mut Solvable,
arg3: *mut Solvable,
) -> ::std::os::raw::c_int,
>,
);
}
extern "C" {
pub fn pool_alloctmpspace(
pool: *mut Pool,
len: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_freetmpspace(pool: *mut Pool, space: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn pool_tmpjoin(
pool: *mut Pool,
str1: *const ::std::os::raw::c_char,
str2: *const ::std::os::raw::c_char,
str3: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_tmpappend(
pool: *mut Pool,
str1: *const ::std::os::raw::c_char,
str2: *const ::std::os::raw::c_char,
str3: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_bin2hex(
pool: *mut Pool,
buf: *const ::std::os::raw::c_uchar,
len: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_set_installed(pool: *mut Pool, repo: *mut s_Repo);
}
extern "C" {
pub fn pool_error(
pool: *mut Pool,
ret: ::std::os::raw::c_int,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_errstr(pool: *mut Pool) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_set_rootdir(pool: *mut Pool, rootdir: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn pool_get_rootdir(pool: *mut Pool) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_prepend_rootdir(
pool: *mut Pool,
dir: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_prepend_rootdir_tmp(
pool: *mut Pool,
dir: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Solvable management"]
pub fn pool_add_solvable(pool: *mut Pool) -> Id;
}
extern "C" {
pub fn pool_add_solvable_block(pool: *mut Pool, count: ::std::os::raw::c_int) -> Id;
}
extern "C" {
pub fn pool_free_solvable_block(
pool: *mut Pool,
start: Id,
count: ::std::os::raw::c_int,
reuseids: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn pool_solvable2str(pool: *mut Pool, s: *mut Solvable) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_set_languages(
pool: *mut Pool,
languages: *mut *const ::std::os::raw::c_char,
nlanguages: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn pool_id2langid(
pool: *mut Pool,
id: Id,
lang: *const ::std::os::raw::c_char,
create: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn pool_intersect_evrs(
pool: *mut Pool,
pflags: ::std::os::raw::c_int,
pevr: Id,
flags: ::std::os::raw::c_int,
evr: Id,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_match_dep(pool: *mut Pool, d1: Id, d2: Id) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_match_nevr_rel(pool: *mut Pool, s: *mut Solvable, d: Id) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Prepares a pool for solving"]
pub fn pool_createwhatprovides(pool: *mut Pool);
}
extern "C" {
pub fn pool_addfileprovides(pool: *mut Pool);
}
extern "C" {
pub fn pool_addfileprovides_queue(pool: *mut Pool, idq: *mut Queue, idqinst: *mut Queue);
}
extern "C" {
pub fn pool_freewhatprovides(pool: *mut Pool);
}
extern "C" {
pub fn pool_queuetowhatprovides(pool: *mut Pool, q: *mut Queue) -> Id;
}
extern "C" {
pub fn pool_ids2whatprovides(pool: *mut Pool, ids: *mut Id, count: ::std::os::raw::c_int)
-> Id;
}
extern "C" {
pub fn pool_searchlazywhatprovidesq(pool: *mut Pool, d: Id) -> Id;
}
extern "C" {
pub fn pool_addrelproviders(pool: *mut Pool, d: Id) -> Id;
}
extern "C" {
pub fn pool_whatmatchesdep(
pool: *mut Pool,
keyname: Id,
dep: Id,
q: *mut Queue,
marker: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn pool_whatcontainsdep(
pool: *mut Pool,
keyname: Id,
dep: Id,
q: *mut Queue,
marker: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn pool_whatmatchessolvable(
pool: *mut Pool,
keyname: Id,
solvid: Id,
q: *mut Queue,
marker: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn pool_set_whatprovides(pool: *mut Pool, id: Id, providers: Id);
}
extern "C" {
pub fn pool_search(
pool: *mut Pool,
p: Id,
key: Id,
match_: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
callback: ::std::option::Option<
unsafe extern "C" fn(
cbdata: *mut ::std::os::raw::c_void,
s: *mut Solvable,
data: *mut s_Repodata,
key: *mut s_Repokey,
kv: *mut s_KeyValue,
) -> ::std::os::raw::c_int,
>,
cbdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn pool_clear_pos(pool: *mut Pool);
}
extern "C" {
pub fn pool_lookup_str(
pool: *mut Pool,
entry: Id,
keyname: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_lookup_id(pool: *mut Pool, entry: Id, keyname: Id) -> Id;
}
extern "C" {
pub fn pool_lookup_num(
pool: *mut Pool,
entry: Id,
keyname: Id,
notfound: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn pool_lookup_void(pool: *mut Pool, entry: Id, keyname: Id) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_lookup_bin_checksum(
pool: *mut Pool,
entry: Id,
keyname: Id,
typep: *mut Id,
) -> *const ::std::os::raw::c_uchar;
}
extern "C" {
pub fn pool_lookup_idarray(
pool: *mut Pool,
entry: Id,
keyname: Id,
q: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_lookup_checksum(
pool: *mut Pool,
entry: Id,
keyname: Id,
typep: *mut Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_lookup_deltalocation(
pool: *mut Pool,
entry: Id,
medianrp: *mut ::std::os::raw::c_uint,
) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_DUChanges {
pub path: *const ::std::os::raw::c_char,
pub kbytes: ::std::os::raw::c_longlong,
pub files: ::std::os::raw::c_longlong,
pub flags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_s_DUChanges() {
assert_eq!(
::std::mem::size_of::<s_DUChanges>(),
32usize,
concat!("Size of: ", stringify!(s_DUChanges))
);
assert_eq!(
::std::mem::align_of::<s_DUChanges>(),
8usize,
concat!("Alignment of ", stringify!(s_DUChanges))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_DUChanges>())).path as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_DUChanges),
"::",
stringify!(path)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_DUChanges>())).kbytes as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_DUChanges),
"::",
stringify!(kbytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_DUChanges>())).files as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_DUChanges),
"::",
stringify!(files)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_DUChanges>())).flags as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_DUChanges),
"::",
stringify!(flags)
)
);
}
pub type DUChanges = s_DUChanges;
extern "C" {
pub fn pool_create_state_maps(
pool: *mut Pool,
installed: *mut Queue,
installedmap: *mut Map,
conflictsmap: *mut Map,
);
}
extern "C" {
pub fn pool_calc_duchanges(
pool: *mut Pool,
installedmap: *mut Map,
mps: *mut DUChanges,
nmps: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn pool_calc_installsizechange(
pool: *mut Pool,
installedmap: *mut Map,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn pool_add_fileconflicts_deps(pool: *mut Pool, conflicts: *mut Queue);
}
extern "C" {
pub fn pool_trivial_installable_multiversionmap(
pool: *mut Pool,
installedmap: *mut Map,
pkgs: *mut Queue,
res: *mut Queue,
multiversionmap: *mut Map,
);
}
extern "C" {
pub fn pool_trivial_installable(
pool: *mut Pool,
installedmap: *mut Map,
pkgs: *mut Queue,
res: *mut Queue,
);
}
extern "C" {
pub fn pool_setarch(arg1: *mut Pool, arg2: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn pool_setarchpolicy(arg1: *mut Pool, arg2: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn pool_arch2color_slow(pool: *mut Pool, arch: Id) -> ::std::os::raw::c_uchar;
}
extern "C" {
#[doc = " malloc"]
#[doc = " exits with error message on error"]
pub fn solv_malloc(arg1: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn solv_malloc2(arg1: size_t, arg2: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn solv_calloc(arg1: size_t, arg2: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn solv_realloc(
arg1: *mut ::std::os::raw::c_void,
arg2: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn solv_realloc2(
arg1: *mut ::std::os::raw::c_void,
arg2: size_t,
arg3: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn solv_extend_realloc(
arg1: *mut ::std::os::raw::c_void,
arg2: size_t,
arg3: size_t,
arg4: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn solv_free(arg1: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn solv_strdup(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn solv_oom(arg1: size_t, arg2: size_t);
}
extern "C" {
pub fn solv_timems(subtract: ::std::os::raw::c_uint) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn solv_setcloexec(
fd: ::std::os::raw::c_int,
state: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solv_sort(
base: *mut ::std::os::raw::c_void,
nmemb: size_t,
size: size_t,
compar: ::std::option::Option<
unsafe extern "C" fn(
arg1: *const ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
arg3: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
compard: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn solv_dupjoin(
str1: *const ::std::os::raw::c_char,
str2: *const ::std::os::raw::c_char,
str3: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn solv_dupappend(
str1: *const ::std::os::raw::c_char,
str2: *const ::std::os::raw::c_char,
str3: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn solv_hex2bin(
strp: *mut *const ::std::os::raw::c_char,
buf: *mut ::std::os::raw::c_uchar,
bufl: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solv_bin2hex(
buf: *const ::std::os::raw::c_uchar,
l: ::std::os::raw::c_int,
str_: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn solv_validutf8(buf: *const ::std::os::raw::c_char) -> size_t;
}
extern "C" {
pub fn solv_latin1toutf8(buf: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn solv_replacebadutf8(
buf: *const ::std::os::raw::c_char,
replchar: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Dirpool {
pub dirs: *mut Id,
pub ndirs: ::std::os::raw::c_int,
pub dirtraverse: *mut Id,
}
#[test]
fn bindgen_test_layout_s_Dirpool() {
assert_eq!(
::std::mem::size_of::<s_Dirpool>(),
24usize,
concat!("Size of: ", stringify!(s_Dirpool))
);
assert_eq!(
::std::mem::align_of::<s_Dirpool>(),
8usize,
concat!("Alignment of ", stringify!(s_Dirpool))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dirpool>())).dirs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Dirpool),
"::",
stringify!(dirs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dirpool>())).ndirs as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Dirpool),
"::",
stringify!(ndirs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dirpool>())).dirtraverse as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Dirpool),
"::",
stringify!(dirtraverse)
)
);
}
pub type Dirpool = s_Dirpool;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Repokey {
pub name: Id,
pub type_: Id,
pub size: ::std::os::raw::c_uint,
pub storage: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_s_Repokey() {
assert_eq!(
::std::mem::size_of::<s_Repokey>(),
16usize,
concat!("Size of: ", stringify!(s_Repokey))
);
assert_eq!(
::std::mem::align_of::<s_Repokey>(),
4usize,
concat!("Alignment of ", stringify!(s_Repokey))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repokey>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Repokey),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repokey>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(s_Repokey),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repokey>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Repokey),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repokey>())).storage as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(s_Repokey),
"::",
stringify!(storage)
)
);
}
pub type Repokey = s_Repokey;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Repodata {
pub repodataid: Id,
pub repo: *mut s_Repo,
pub state: ::std::os::raw::c_int,
pub loadcallback: ::std::option::Option<unsafe extern "C" fn(arg1: *mut s_Repodata)>,
pub start: ::std::os::raw::c_int,
pub end: ::std::os::raw::c_int,
pub keys: *mut Repokey,
pub nkeys: ::std::os::raw::c_int,
pub keybits: [::std::os::raw::c_uchar; 32usize],
pub schemata: *mut Id,
pub nschemata: ::std::os::raw::c_int,
pub schemadata: *mut Id,
pub spool: Stringpool,
pub localpool: ::std::os::raw::c_int,
pub dirpool: Dirpool,
}
#[test]
fn bindgen_test_layout_s_Repodata() {
assert_eq!(
::std::mem::size_of::<s_Repodata>(),
192usize,
concat!("Size of: ", stringify!(s_Repodata))
);
assert_eq!(
::std::mem::align_of::<s_Repodata>(),
8usize,
concat!("Alignment of ", stringify!(s_Repodata))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).repodataid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(repodataid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).repo as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(repo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).state as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).loadcallback as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(loadcallback)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).start as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).end as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).keys as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(keys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).nkeys as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(nkeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).keybits as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(keybits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).schemata as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(schemata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).nschemata as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(nschemata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).schemadata as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(schemadata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).spool as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(spool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).localpool as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(localpool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repodata>())).dirpool as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(s_Repodata),
"::",
stringify!(dirpool)
)
);
}
pub type Repodata = s_Repodata;
extern "C" {
pub fn repodata_initdata(
data: *mut Repodata,
repo: *mut s_Repo,
localpool: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn repodata_freedata(data: *mut Repodata);
}
extern "C" {
pub fn repodata_free(data: *mut Repodata);
}
extern "C" {
pub fn repodata_empty(data: *mut Repodata, localpool: ::std::os::raw::c_int);
}
extern "C" {
pub fn repodata_load(data: *mut Repodata);
}
extern "C" {
pub fn repodata_key2id(
data: *mut Repodata,
key: *mut Repokey,
create: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn repodata_schema2id(
data: *mut Repodata,
schema: *mut Id,
create: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn repodata_free_schemahash(data: *mut Repodata);
}
extern "C" {
pub fn repodata_search(
data: *mut Repodata,
solvid: Id,
keyname: Id,
flags: ::std::os::raw::c_int,
callback: ::std::option::Option<
unsafe extern "C" fn(
cbdata: *mut ::std::os::raw::c_void,
s: *mut Solvable,
data: *mut Repodata,
key: *mut Repokey,
kv: *mut s_KeyValue,
) -> ::std::os::raw::c_int,
>,
cbdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn repodata_search_keyskip(
data: *mut Repodata,
solvid: Id,
keyname: Id,
flags: ::std::os::raw::c_int,
keyskip: *mut Id,
callback: ::std::option::Option<
unsafe extern "C" fn(
cbdata: *mut ::std::os::raw::c_void,
s: *mut Solvable,
data: *mut Repodata,
key: *mut Repokey,
kv: *mut s_KeyValue,
) -> ::std::os::raw::c_int,
>,
cbdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn repodata_search_arrayelement(
data: *mut Repodata,
solvid: Id,
keyname: Id,
flags: ::std::os::raw::c_int,
kv: *mut s_KeyValue,
callback: ::std::option::Option<
unsafe extern "C" fn(
cbdata: *mut ::std::os::raw::c_void,
s: *mut Solvable,
data: *mut Repodata,
key: *mut Repokey,
kv: *mut s_KeyValue,
) -> ::std::os::raw::c_int,
>,
cbdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn repodata_stringify(
pool: *mut Pool,
data: *mut Repodata,
key: *mut Repokey,
kv: *mut s_KeyValue,
flags: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn repodata_set_filelisttype(data: *mut Repodata, filelisttype: ::std::os::raw::c_int);
}
extern "C" {
pub fn repodata_filelistfilter_matches(
data: *mut Repodata,
str_: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repodata_free_filelistfilter(data: *mut Repodata);
}
extern "C" {
pub fn repodata_lookup_type(data: *mut Repodata, solvid: Id, keyname: Id) -> Id;
}
extern "C" {
pub fn repodata_lookup_id(data: *mut Repodata, solvid: Id, keyname: Id) -> Id;
}
extern "C" {
pub fn repodata_lookup_str(
data: *mut Repodata,
solvid: Id,
keyname: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn repodata_lookup_num(
data: *mut Repodata,
solvid: Id,
keyname: Id,
notfound: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn repodata_lookup_void(
data: *mut Repodata,
solvid: Id,
keyname: Id,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repodata_lookup_bin_checksum(
data: *mut Repodata,
solvid: Id,
keyname: Id,
typep: *mut Id,
) -> *const ::std::os::raw::c_uchar;
}
extern "C" {
pub fn repodata_lookup_idarray(
data: *mut Repodata,
solvid: Id,
keyname: Id,
q: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repodata_lookup_binary(
data: *mut Repodata,
solvid: Id,
keyname: Id,
lenp: *mut ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void;
}
extern "C" {
pub fn repodata_lookup_count(
data: *mut Repodata,
solvid: Id,
keyname: Id,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn repodata_lookup_packed_dirstrarray(
data: *mut Repodata,
solvid: Id,
keyname: Id,
) -> *const ::std::os::raw::c_uchar;
}
extern "C" {
pub fn repodata_fill_keyskip(data: *mut Repodata, solvid: Id, keyskip: *mut Id) -> *mut Id;
}
extern "C" {
pub fn repodata_extend(data: *mut Repodata, p: Id);
}
extern "C" {
pub fn repodata_extend_block(data: *mut Repodata, p: Id, num: ::std::os::raw::c_int);
}
extern "C" {
pub fn repodata_shrink(data: *mut Repodata, end: ::std::os::raw::c_int);
}
extern "C" {
pub fn repodata_internalize(data: *mut Repodata);
}
extern "C" {
pub fn repodata_new_handle(data: *mut Repodata) -> Id;
}
extern "C" {
pub fn repodata_set_void(data: *mut Repodata, solvid: Id, keyname: Id);
}
extern "C" {
pub fn repodata_set_num(
data: *mut Repodata,
solvid: Id,
keyname: Id,
num: ::std::os::raw::c_ulonglong,
);
}
extern "C" {
pub fn repodata_set_id(data: *mut Repodata, solvid: Id, keyname: Id, id: Id);
}
extern "C" {
pub fn repodata_set_str(
data: *mut Repodata,
solvid: Id,
keyname: Id,
str_: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repodata_set_binary(
data: *mut Repodata,
solvid: Id,
keyname: Id,
buf: *mut ::std::os::raw::c_void,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn repodata_set_poolstr(
data: *mut Repodata,
solvid: Id,
keyname: Id,
str_: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repodata_set_constant(
data: *mut Repodata,
solvid: Id,
keyname: Id,
constant: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn repodata_set_constantid(data: *mut Repodata, solvid: Id, keyname: Id, id: Id);
}
extern "C" {
pub fn repodata_set_bin_checksum(
data: *mut Repodata,
solvid: Id,
keyname: Id,
type_: Id,
buf: *const ::std::os::raw::c_uchar,
);
}
extern "C" {
pub fn repodata_set_checksum(
data: *mut Repodata,
solvid: Id,
keyname: Id,
type_: Id,
str_: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repodata_set_idarray(data: *mut Repodata, solvid: Id, keyname: Id, q: *mut Queue);
}
extern "C" {
pub fn repodata_add_dirnumnum(
data: *mut Repodata,
solvid: Id,
keyname: Id,
dir: Id,
num: Id,
num2: Id,
);
}
extern "C" {
pub fn repodata_add_dirstr(
data: *mut Repodata,
solvid: Id,
keyname: Id,
dir: Id,
str_: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repodata_free_dircache(data: *mut Repodata);
}
extern "C" {
pub fn repodata_add_idarray(data: *mut Repodata, solvid: Id, keyname: Id, id: Id);
}
extern "C" {
pub fn repodata_add_poolstr_array(
data: *mut Repodata,
solvid: Id,
keyname: Id,
str_: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repodata_add_fixarray(data: *mut Repodata, solvid: Id, keyname: Id, ghandle: Id);
}
extern "C" {
pub fn repodata_add_flexarray(data: *mut Repodata, solvid: Id, keyname: Id, ghandle: Id);
}
extern "C" {
pub fn repodata_set_kv(
data: *mut Repodata,
solvid: Id,
keyname: Id,
keytype: Id,
kv: *mut s_KeyValue,
);
}
extern "C" {
pub fn repodata_unset(data: *mut Repodata, solvid: Id, keyname: Id);
}
extern "C" {
pub fn repodata_unset_uninternalized(data: *mut Repodata, solvid: Id, keyname: Id);
}
extern "C" {
pub fn repodata_merge_attrs(data: *mut Repodata, dest: Id, src: Id);
}
extern "C" {
pub fn repodata_merge_some_attrs(
data: *mut Repodata,
dest: Id,
src: Id,
keyidmap: *mut Map,
overwrite: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn repodata_swap_attrs(data: *mut Repodata, dest: Id, src: Id);
}
extern "C" {
pub fn repodata_create_stubs(data: *mut Repodata) -> *mut Repodata;
}
extern "C" {
pub fn repodata_disable_paging(data: *mut Repodata);
}
extern "C" {
pub fn repodata_globalize_id(data: *mut Repodata, id: Id, create: ::std::os::raw::c_int) -> Id;
}
extern "C" {
pub fn repodata_localize_id(data: *mut Repodata, id: Id, create: ::std::os::raw::c_int) -> Id;
}
extern "C" {
pub fn repodata_translate_id(
data: *mut Repodata,
fromdata: *mut Repodata,
id: Id,
create: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn repodata_translate_dir_slow(
data: *mut Repodata,
fromdata: *mut Repodata,
dir: Id,
create: ::std::os::raw::c_int,
cache: *mut Id,
) -> Id;
}
extern "C" {
pub fn repodata_str2dir(
data: *mut Repodata,
dir: *const ::std::os::raw::c_char,
create: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn repodata_dir2str(
data: *mut Repodata,
did: Id,
suf: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn repodata_chk2str(
data: *mut Repodata,
type_: Id,
buf: *const ::std::os::raw::c_uchar,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn repodata_set_location(
data: *mut Repodata,
solvid: Id,
medianr: ::std::os::raw::c_int,
dir: *const ::std::os::raw::c_char,
file: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repodata_set_deltalocation(
data: *mut Repodata,
handle: Id,
medianr: ::std::os::raw::c_int,
dir: *const ::std::os::raw::c_char,
file: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repodata_set_sourcepkg(
data: *mut Repodata,
solvid: Id,
sourcepkg: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repodata_lookup_kv_uninternalized(
data: *mut Repodata,
solvid: Id,
keyname: Id,
kv: *mut s_KeyValue,
) -> *mut Repokey;
}
extern "C" {
pub fn repodata_search_uninternalized(
data: *mut Repodata,
solvid: Id,
keyname: Id,
flags: ::std::os::raw::c_int,
callback: ::std::option::Option<
unsafe extern "C" fn(
cbdata: *mut ::std::os::raw::c_void,
s: *mut Solvable,
data: *mut Repodata,
key: *mut Repokey,
kv: *mut s_KeyValue,
) -> ::std::os::raw::c_int,
>,
cbdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn repodata_memused(data: *mut Repodata) -> ::std::os::raw::c_uint;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_KeyValue {
pub id: Id,
pub str_: *const ::std::os::raw::c_char,
pub num: ::std::os::raw::c_uint,
pub num2: ::std::os::raw::c_uint,
pub entry: ::std::os::raw::c_int,
pub eof: ::std::os::raw::c_int,
pub parent: *mut s_KeyValue,
}
#[test]
fn bindgen_test_layout_s_KeyValue() {
assert_eq!(
::std::mem::size_of::<s_KeyValue>(),
40usize,
concat!("Size of: ", stringify!(s_KeyValue))
);
assert_eq!(
::std::mem::align_of::<s_KeyValue>(),
8usize,
concat!("Alignment of ", stringify!(s_KeyValue))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_KeyValue>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_KeyValue),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_KeyValue>())).str_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_KeyValue),
"::",
stringify!(str_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_KeyValue>())).num as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_KeyValue),
"::",
stringify!(num)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_KeyValue>())).num2 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(s_KeyValue),
"::",
stringify!(num2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_KeyValue>())).entry as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_KeyValue),
"::",
stringify!(entry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_KeyValue>())).eof as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(s_KeyValue),
"::",
stringify!(eof)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_KeyValue>())).parent as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(s_KeyValue),
"::",
stringify!(parent)
)
);
}
pub type KeyValue = s_KeyValue;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Datamatcher {
pub flags: ::std::os::raw::c_int,
pub match_: *const ::std::os::raw::c_char,
pub matchdata: *mut ::std::os::raw::c_void,
pub error: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_s_Datamatcher() {
assert_eq!(
::std::mem::size_of::<s_Datamatcher>(),
32usize,
concat!("Size of: ", stringify!(s_Datamatcher))
);
assert_eq!(
::std::mem::align_of::<s_Datamatcher>(),
8usize,
concat!("Alignment of ", stringify!(s_Datamatcher))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datamatcher>())).flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Datamatcher),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datamatcher>())).match_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Datamatcher),
"::",
stringify!(match_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datamatcher>())).matchdata as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Datamatcher),
"::",
stringify!(matchdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Datamatcher>())).error as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_Datamatcher),
"::",
stringify!(error)
)
);
}
pub type Datamatcher = s_Datamatcher;
extern "C" {
pub fn datamatcher_init(
ma: *mut Datamatcher,
match_: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn datamatcher_free(ma: *mut Datamatcher);
}
extern "C" {
pub fn datamatcher_match(
ma: *mut Datamatcher,
str_: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn datamatcher_checkbasename(
ma: *mut Datamatcher,
str_: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Dataiterator {
pub state: ::std::os::raw::c_int,
pub flags: ::std::os::raw::c_int,
pub pool: *mut Pool,
pub repo: *mut s_Repo,
pub data: *mut s_Repodata,
pub dp: *mut ::std::os::raw::c_uchar,
pub ddp: *mut ::std::os::raw::c_uchar,
pub idp: *mut Id,
pub keyp: *mut Id,
pub key: *mut s_Repokey,
pub kv: KeyValue,
pub matcher: Datamatcher,
pub keyname: Id,
pub repodataid: Id,
pub solvid: Id,
pub repoid: Id,
pub keynames: [Id; 4usize],
pub nkeynames: ::std::os::raw::c_int,
pub rootlevel: ::std::os::raw::c_int,
pub parents: [s_Dataiterator_di_parent; 3usize],
pub nparents: ::std::os::raw::c_int,
pub vert_ddp: *mut ::std::os::raw::c_uchar,
pub vert_off: Id,
pub vert_len: Id,
pub vert_storestate: Id,
pub dupstr: *mut ::std::os::raw::c_char,
pub dupstrn: ::std::os::raw::c_int,
pub keyskip: *mut Id,
pub oldkeyskip: *mut Id,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Dataiterator_di_parent {
pub kv: KeyValue,
pub dp: *mut ::std::os::raw::c_uchar,
pub keyp: *mut Id,
}
#[test]
fn bindgen_test_layout_s_Dataiterator_di_parent() {
assert_eq!(
::std::mem::size_of::<s_Dataiterator_di_parent>(),
56usize,
concat!("Size of: ", stringify!(s_Dataiterator_di_parent))
);
assert_eq!(
::std::mem::align_of::<s_Dataiterator_di_parent>(),
8usize,
concat!("Alignment of ", stringify!(s_Dataiterator_di_parent))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator_di_parent>())).kv as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator_di_parent),
"::",
stringify!(kv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator_di_parent>())).dp as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator_di_parent),
"::",
stringify!(dp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator_di_parent>())).keyp as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator_di_parent),
"::",
stringify!(keyp)
)
);
}
#[test]
fn bindgen_test_layout_s_Dataiterator() {
assert_eq!(
::std::mem::size_of::<s_Dataiterator>(),
416usize,
concat!("Size of: ", stringify!(s_Dataiterator))
);
assert_eq!(
::std::mem::align_of::<s_Dataiterator>(),
8usize,
concat!("Alignment of ", stringify!(s_Dataiterator))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).state as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).pool as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(pool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).repo as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(repo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).data as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).dp as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(dp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).ddp as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(ddp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).idp as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(idp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).keyp as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(keyp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).key as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).kv as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(kv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).matcher as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(matcher)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).keyname as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(keyname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).repodataid as *const _ as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(repodataid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).solvid as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(solvid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).repoid as *const _ as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(repoid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).keynames as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(keynames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).nkeynames as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(nkeynames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).rootlevel as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(rootlevel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).parents as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(parents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).nparents as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(nparents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).vert_ddp as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(vert_ddp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).vert_off as *const _ as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(vert_off)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).vert_len as *const _ as usize },
372usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(vert_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).vert_storestate as *const _ as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(vert_storestate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).dupstr as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(dupstr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).dupstrn as *const _ as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(dupstrn)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).keyskip as *const _ as usize },
400usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(keyskip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Dataiterator>())).oldkeyskip as *const _ as usize },
408usize,
concat!(
"Offset of field: ",
stringify!(s_Dataiterator),
"::",
stringify!(oldkeyskip)
)
);
}
pub type Dataiterator = s_Dataiterator;
extern "C" {
pub fn dataiterator_init(
di: *mut Dataiterator,
pool: *mut Pool,
repo: *mut s_Repo,
p: Id,
keyname: Id,
match_: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dataiterator_init_clone(di: *mut Dataiterator, from: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_set_search(di: *mut Dataiterator, repo: *mut s_Repo, p: Id);
}
extern "C" {
pub fn dataiterator_set_keyname(di: *mut Dataiterator, keyname: Id);
}
extern "C" {
pub fn dataiterator_set_match(
di: *mut Dataiterator,
match_: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dataiterator_prepend_keyname(di: *mut Dataiterator, keyname: Id);
}
extern "C" {
pub fn dataiterator_free(di: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_step(di: *mut Dataiterator) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dataiterator_setpos(di: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_setpos_parent(di: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_match(di: *mut Dataiterator, ma: *mut Datamatcher)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn dataiterator_skip_attribute(di: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_skip_solvable(di: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_skip_repo(di: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_jump_to_solvid(di: *mut Dataiterator, solvid: Id);
}
extern "C" {
pub fn dataiterator_jump_to_repo(di: *mut Dataiterator, repo: *mut s_Repo);
}
extern "C" {
pub fn dataiterator_entersub(di: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_clonepos(di: *mut Dataiterator, from: *mut Dataiterator);
}
extern "C" {
pub fn dataiterator_seek(di: *mut Dataiterator, whence: ::std::os::raw::c_int);
}
extern "C" {
pub fn dataiterator_strdup(di: *mut Dataiterator);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Repo {
pub name: *const ::std::os::raw::c_char,
pub repoid: Id,
pub appdata: *mut ::std::os::raw::c_void,
pub pool: *mut Pool,
pub start: ::std::os::raw::c_int,
pub end: ::std::os::raw::c_int,
pub nsolvables: ::std::os::raw::c_int,
pub disabled: ::std::os::raw::c_int,
pub priority: ::std::os::raw::c_int,
pub subpriority: ::std::os::raw::c_int,
pub idarraydata: *mut Id,
pub idarraysize: ::std::os::raw::c_int,
pub nrepodata: ::std::os::raw::c_int,
pub rpmdbid: *mut Id,
}
#[test]
fn bindgen_test_layout_s_Repo() {
assert_eq!(
::std::mem::size_of::<s_Repo>(),
80usize,
concat!("Size of: ", stringify!(s_Repo))
);
assert_eq!(
::std::mem::align_of::<s_Repo>(),
8usize,
concat!("Alignment of ", stringify!(s_Repo))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).repoid as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(repoid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).appdata as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(appdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).pool as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(pool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).start as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).end as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).nsolvables as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(nsolvables)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).disabled as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(disabled)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).priority as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(priority)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).subpriority as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(subpriority)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).idarraydata as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(idarraydata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).idarraysize as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(idarraysize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).nrepodata as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(nrepodata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repo>())).rpmdbid as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(s_Repo),
"::",
stringify!(rpmdbid)
)
);
}
pub type Repo = s_Repo;
extern "C" {
pub fn repo_create(pool: *mut Pool, name: *const ::std::os::raw::c_char) -> *mut Repo;
}
extern "C" {
pub fn repo_free(repo: *mut Repo, reuseids: ::std::os::raw::c_int);
}
extern "C" {
pub fn repo_empty(repo: *mut Repo, reuseids: ::std::os::raw::c_int);
}
extern "C" {
pub fn repo_freedata(repo: *mut Repo);
}
extern "C" {
pub fn repo_add_solvable(repo: *mut Repo) -> Id;
}
extern "C" {
pub fn repo_add_solvable_block(repo: *mut Repo, count: ::std::os::raw::c_int) -> Id;
}
extern "C" {
pub fn repo_free_solvable(repo: *mut Repo, p: Id, reuseids: ::std::os::raw::c_int);
}
extern "C" {
pub fn repo_free_solvable_block(
repo: *mut Repo,
start: Id,
count: ::std::os::raw::c_int,
reuseids: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn repo_sidedata_create(repo: *mut Repo, size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn repo_sidedata_extend(
repo: *mut Repo,
b: *mut ::std::os::raw::c_void,
size: size_t,
p: Id,
count: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn repo_add_solvable_block_before(
repo: *mut Repo,
count: ::std::os::raw::c_int,
beforerepo: *mut Repo,
) -> Id;
}
extern "C" {
pub fn repo_addid(repo: *mut Repo, olddeps: Offset, id: Id) -> Offset;
}
extern "C" {
pub fn repo_addid_dep(repo: *mut Repo, olddeps: Offset, id: Id, marker: Id) -> Offset;
}
extern "C" {
pub fn repo_reserve_ids(repo: *mut Repo, olddeps: Offset, num: ::std::os::raw::c_int)
-> Offset;
}
extern "C" {
pub fn repo_add_repodata(repo: *mut Repo, flags: ::std::os::raw::c_int) -> *mut Repodata;
}
extern "C" {
pub fn repo_id2repodata(repo: *mut Repo, id: Id) -> *mut Repodata;
}
extern "C" {
pub fn repo_last_repodata(repo: *mut Repo) -> *mut Repodata;
}
extern "C" {
pub fn repo_search(
repo: *mut Repo,
p: Id,
key: Id,
match_: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
callback: ::std::option::Option<
unsafe extern "C" fn(
cbdata: *mut ::std::os::raw::c_void,
s: *mut Solvable,
data: *mut Repodata,
key: *mut Repokey,
kv: *mut KeyValue,
) -> ::std::os::raw::c_int,
>,
cbdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn repo_lookup_repodata(repo: *mut Repo, entry: Id, keyname: Id) -> *mut Repodata;
}
extern "C" {
pub fn repo_lookup_repodata_opt(repo: *mut Repo, entry: Id, keyname: Id) -> *mut Repodata;
}
extern "C" {
pub fn repo_lookup_filelist_repodata(
repo: *mut Repo,
entry: Id,
matcher: *mut Datamatcher,
) -> *mut Repodata;
}
extern "C" {
pub fn repo_lookup_type(repo: *mut Repo, entry: Id, keyname: Id) -> Id;
}
extern "C" {
pub fn repo_lookup_str(
repo: *mut Repo,
entry: Id,
keyname: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn repo_lookup_num(
repo: *mut Repo,
entry: Id,
keyname: Id,
notfound: ::std::os::raw::c_ulonglong,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn repo_lookup_id(repo: *mut Repo, entry: Id, keyname: Id) -> Id;
}
extern "C" {
pub fn repo_lookup_idarray(
repo: *mut Repo,
entry: Id,
keyname: Id,
q: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_lookup_deparray(
repo: *mut Repo,
entry: Id,
keyname: Id,
q: *mut Queue,
marker: Id,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_lookup_void(repo: *mut Repo, entry: Id, keyname: Id) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_lookup_checksum(
repo: *mut Repo,
entry: Id,
keyname: Id,
typep: *mut Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn repo_lookup_bin_checksum(
repo: *mut Repo,
entry: Id,
keyname: Id,
typep: *mut Id,
) -> *const ::std::os::raw::c_uchar;
}
extern "C" {
pub fn repo_lookup_binary(
repo: *mut Repo,
entry: Id,
keyname: Id,
lenp: *mut ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void;
}
extern "C" {
pub fn repo_lookup_count(repo: *mut Repo, entry: Id, keyname: Id) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn solv_depmarker(keyname: Id, marker: Id) -> Id;
}
extern "C" {
pub fn repo_set_id(repo: *mut Repo, p: Id, keyname: Id, id: Id);
}
extern "C" {
pub fn repo_set_num(repo: *mut Repo, p: Id, keyname: Id, num: ::std::os::raw::c_ulonglong);
}
extern "C" {
pub fn repo_set_str(repo: *mut Repo, p: Id, keyname: Id, str_: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn repo_set_poolstr(
repo: *mut Repo,
p: Id,
keyname: Id,
str_: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repo_add_poolstr_array(
repo: *mut Repo,
p: Id,
keyname: Id,
str_: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn repo_add_idarray(repo: *mut Repo, p: Id, keyname: Id, id: Id);
}
extern "C" {
pub fn repo_add_deparray(repo: *mut Repo, p: Id, keyname: Id, dep: Id, marker: Id);
}
extern "C" {
pub fn repo_set_idarray(repo: *mut Repo, p: Id, keyname: Id, q: *mut Queue);
}
extern "C" {
pub fn repo_set_deparray(repo: *mut Repo, p: Id, keyname: Id, q: *mut Queue, marker: Id);
}
extern "C" {
pub fn repo_unset(repo: *mut Repo, p: Id, keyname: Id);
}
extern "C" {
pub fn repo_internalize(repo: *mut Repo);
}
extern "C" {
pub fn repo_disable_paging(repo: *mut Repo);
}
extern "C" {
pub fn repo_create_keyskip(repo: *mut Repo, entry: Id, oldkeyskip: *mut *mut Id) -> *mut Id;
}
extern "C" {
pub fn repo_fix_supplements(
repo: *mut Repo,
provides: Offset,
supplements: Offset,
freshens: Offset,
) -> Offset;
}
extern "C" {
pub fn repo_fix_conflicts(repo: *mut Repo, conflicts: Offset) -> Offset;
}
extern "C" {
pub fn repo_rewrite_suse_deps(s: *mut Solvable, freshens: Offset);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Transaction {
pub pool: *mut s_Pool,
pub steps: Queue,
}
#[test]
fn bindgen_test_layout_s_Transaction() {
assert_eq!(
::std::mem::size_of::<s_Transaction>(),
40usize,
concat!("Size of: ", stringify!(s_Transaction))
);
assert_eq!(
::std::mem::align_of::<s_Transaction>(),
8usize,
concat!("Alignment of ", stringify!(s_Transaction))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Transaction>())).pool as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Transaction),
"::",
stringify!(pool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Transaction>())).steps as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Transaction),
"::",
stringify!(steps)
)
);
}
pub type Transaction = s_Transaction;
extern "C" {
pub fn transaction_create(pool: *mut s_Pool) -> *mut Transaction;
}
extern "C" {
pub fn transaction_create_decisionq(
pool: *mut s_Pool,
decisionq: *mut Queue,
multiversionmap: *mut Map,
) -> *mut Transaction;
}
extern "C" {
pub fn transaction_create_clone(srctrans: *mut Transaction) -> *mut Transaction;
}
extern "C" {
pub fn transaction_free(trans: *mut Transaction);
}
extern "C" {
pub fn transaction_obs_pkg(trans: *mut Transaction, p: Id) -> Id;
}
extern "C" {
pub fn transaction_all_obs_pkgs(trans: *mut Transaction, p: Id, pkgs: *mut Queue);
}
extern "C" {
pub fn transaction_type(trans: *mut Transaction, p: Id, mode: ::std::os::raw::c_int) -> Id;
}
extern "C" {
pub fn transaction_classify(
trans: *mut Transaction,
mode: ::std::os::raw::c_int,
classes: *mut Queue,
);
}
extern "C" {
pub fn transaction_classify_pkgs(
trans: *mut Transaction,
mode: ::std::os::raw::c_int,
type_: Id,
from: Id,
to: Id,
pkgs: *mut Queue,
);
}
extern "C" {
pub fn transaction_installedresult(
trans: *mut Transaction,
installedq: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn transaction_calc_installsizechange(
trans: *mut Transaction,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn transaction_calc_duchanges(
trans: *mut Transaction,
mps: *mut s_DUChanges,
nmps: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn transaction_order(trans: *mut Transaction, flags: ::std::os::raw::c_int);
}
extern "C" {
pub fn transaction_order_add_choices(
trans: *mut Transaction,
chosen: Id,
choices: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn transaction_add_obsoleted(trans: *mut Transaction);
}
extern "C" {
pub fn transaction_check_order(trans: *mut Transaction);
}
extern "C" {
pub fn transaction_order_get_cycleids(
trans: *mut Transaction,
q: *mut Queue,
minseverity: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn transaction_order_get_cycle(
trans: *mut Transaction,
cid: Id,
q: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn transaction_free_orderdata(trans: *mut Transaction);
}
extern "C" {
pub fn transaction_clone_orderdata(trans: *mut Transaction, srctrans: *mut Transaction);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Rule {
pub p: Id,
pub d: Id,
pub w1: Id,
pub w2: Id,
pub n1: Id,
pub n2: Id,
}
#[test]
fn bindgen_test_layout_s_Rule() {
assert_eq!(
::std::mem::size_of::<s_Rule>(),
24usize,
concat!("Size of: ", stringify!(s_Rule))
);
assert_eq!(
::std::mem::align_of::<s_Rule>(),
4usize,
concat!("Alignment of ", stringify!(s_Rule))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Rule>())).p as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(s_Rule), "::", stringify!(p))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Rule>())).d as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(s_Rule), "::", stringify!(d))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Rule>())).w1 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Rule),
"::",
stringify!(w1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Rule>())).w2 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(s_Rule),
"::",
stringify!(w2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Rule>())).n1 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Rule),
"::",
stringify!(n1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Rule>())).n2 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(s_Rule),
"::",
stringify!(n2)
)
);
}
pub type Rule = s_Rule;
pub const SolverRuleinfo_SOLVER_RULE_UNKNOWN: SolverRuleinfo = 0;
pub const SolverRuleinfo_SOLVER_RULE_PKG: SolverRuleinfo = 256;
pub const SolverRuleinfo_SOLVER_RULE_PKG_NOT_INSTALLABLE: SolverRuleinfo = 257;
pub const SolverRuleinfo_SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP: SolverRuleinfo = 258;
pub const SolverRuleinfo_SOLVER_RULE_PKG_REQUIRES: SolverRuleinfo = 259;
pub const SolverRuleinfo_SOLVER_RULE_PKG_SELF_CONFLICT: SolverRuleinfo = 260;
pub const SolverRuleinfo_SOLVER_RULE_PKG_CONFLICTS: SolverRuleinfo = 261;
pub const SolverRuleinfo_SOLVER_RULE_PKG_SAME_NAME: SolverRuleinfo = 262;
pub const SolverRuleinfo_SOLVER_RULE_PKG_OBSOLETES: SolverRuleinfo = 263;
pub const SolverRuleinfo_SOLVER_RULE_PKG_IMPLICIT_OBSOLETES: SolverRuleinfo = 264;
pub const SolverRuleinfo_SOLVER_RULE_PKG_INSTALLED_OBSOLETES: SolverRuleinfo = 265;
pub const SolverRuleinfo_SOLVER_RULE_PKG_RECOMMENDS: SolverRuleinfo = 266;
pub const SolverRuleinfo_SOLVER_RULE_PKG_CONSTRAINS: SolverRuleinfo = 267;
pub const SolverRuleinfo_SOLVER_RULE_UPDATE: SolverRuleinfo = 512;
pub const SolverRuleinfo_SOLVER_RULE_FEATURE: SolverRuleinfo = 768;
pub const SolverRuleinfo_SOLVER_RULE_JOB: SolverRuleinfo = 1024;
pub const SolverRuleinfo_SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP: SolverRuleinfo = 1025;
pub const SolverRuleinfo_SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM: SolverRuleinfo = 1026;
pub const SolverRuleinfo_SOLVER_RULE_JOB_UNKNOWN_PACKAGE: SolverRuleinfo = 1027;
pub const SolverRuleinfo_SOLVER_RULE_JOB_UNSUPPORTED: SolverRuleinfo = 1028;
pub const SolverRuleinfo_SOLVER_RULE_DISTUPGRADE: SolverRuleinfo = 1280;
pub const SolverRuleinfo_SOLVER_RULE_INFARCH: SolverRuleinfo = 1536;
pub const SolverRuleinfo_SOLVER_RULE_CHOICE: SolverRuleinfo = 1792;
pub const SolverRuleinfo_SOLVER_RULE_LEARNT: SolverRuleinfo = 2048;
pub const SolverRuleinfo_SOLVER_RULE_BEST: SolverRuleinfo = 2304;
pub const SolverRuleinfo_SOLVER_RULE_YUMOBS: SolverRuleinfo = 2560;
pub const SolverRuleinfo_SOLVER_RULE_RECOMMENDS: SolverRuleinfo = 2816;
pub const SolverRuleinfo_SOLVER_RULE_BLACK: SolverRuleinfo = 3072;
pub type SolverRuleinfo = ::std::os::raw::c_uint;
extern "C" {
pub fn solver_addrule(solv: *mut s_Solver, p: Id, p2: Id, d: Id) -> *mut Rule;
}
extern "C" {
pub fn solver_unifyrules(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_rulecmp(
solv: *mut s_Solver,
r1: *mut Rule,
r2: *mut Rule,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_shrinkrules(solv: *mut s_Solver, nrules: ::std::os::raw::c_int);
}
extern "C" {
pub fn solver_addpkgrulesforsolvable(solv: *mut s_Solver, s: *mut Solvable, m: *mut Map);
}
extern "C" {
pub fn solver_addpkgrulesforweak(solv: *mut s_Solver, m: *mut Map);
}
extern "C" {
pub fn solver_addpkgrulesforlinked(solv: *mut s_Solver, m: *mut Map);
}
extern "C" {
pub fn solver_addpkgrulesforupdaters(
solv: *mut s_Solver,
s: *mut Solvable,
m: *mut Map,
allow_all: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn solver_addfeaturerule(solv: *mut s_Solver, s: *mut Solvable);
}
extern "C" {
pub fn solver_addupdaterule(solv: *mut s_Solver, s: *mut Solvable);
}
extern "C" {
pub fn solver_addinfarchrules(solv: *mut s_Solver, addedmap: *mut Map);
}
extern "C" {
pub fn solver_createdupmaps(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_freedupmaps(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_addduprules(solv: *mut s_Solver, addedmap: *mut Map);
}
extern "C" {
pub fn solver_addchoicerules(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_disablechoicerules(solv: *mut s_Solver, r: *mut Rule);
}
extern "C" {
pub fn solver_addbestrules(
solv: *mut s_Solver,
havebestinstalljobs: ::std::os::raw::c_int,
haslockjob: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn solver_addyumobsrules(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_addblackrules(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_addrecommendsrules(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_disablepolicyrules(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_reenablepolicyrules(solv: *mut s_Solver, jobidx: ::std::os::raw::c_int);
}
extern "C" {
pub fn solver_reenablepolicyrules_cleandeps(solv: *mut s_Solver, pkg: Id);
}
extern "C" {
pub fn solver_allruleinfos(
solv: *mut s_Solver,
rid: Id,
rq: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_ruleinfo(
solv: *mut s_Solver,
rid: Id,
fromp: *mut Id,
top: *mut Id,
depp: *mut Id,
) -> SolverRuleinfo;
}
extern "C" {
pub fn solver_ruleclass(solv: *mut s_Solver, rid: Id) -> SolverRuleinfo;
}
extern "C" {
pub fn solver_ruleliterals(solv: *mut s_Solver, rid: Id, q: *mut Queue);
}
extern "C" {
pub fn solver_rule2jobidx(solv: *mut s_Solver, rid: Id) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_rule2job(solv: *mut s_Solver, rid: Id, whatp: *mut Id) -> Id;
}
extern "C" {
pub fn solver_rule2solvable(solv: *mut s_Solver, rid: Id) -> Id;
}
extern "C" {
pub fn solver_rule2rules(
solv: *mut s_Solver,
rid: Id,
q: *mut Queue,
recursive: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn solver_rule2pkgrule(solv: *mut s_Solver, rid: Id) -> Id;
}
extern "C" {
pub fn solver_breakorphans(solv: *mut s_Solver);
}
extern "C" {
pub fn solver_check_brokenorphanrules(solv: *mut s_Solver, dq: *mut Queue);
}
extern "C" {
pub fn solver_recordproblem(solv: *mut s_Solver, rid: Id);
}
extern "C" {
pub fn solver_fixproblem(solv: *mut s_Solver, rid: Id);
}
extern "C" {
pub fn solver_autouninstall(solv: *mut s_Solver, start: ::std::os::raw::c_int) -> Id;
}
extern "C" {
pub fn solver_disableproblemset(solv: *mut s_Solver, start: ::std::os::raw::c_int);
}
extern "C" {
pub fn solver_prepare_solutions(solv: *mut s_Solver) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_problem_count(solv: *mut s_Solver) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn solver_next_problem(solv: *mut s_Solver, problem: Id) -> Id;
}
extern "C" {
pub fn solver_solution_count(solv: *mut s_Solver, problem: Id) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn solver_next_solution(solv: *mut s_Solver, problem: Id, solution: Id) -> Id;
}
extern "C" {
pub fn solver_solutionelement_count(
solv: *mut s_Solver,
problem: Id,
solution: Id,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn solver_solutionelement_internalid(solv: *mut s_Solver, problem: Id, solution: Id) -> Id;
}
extern "C" {
pub fn solver_solutionelement_extrajobflags(
solv: *mut s_Solver,
problem: Id,
solution: Id,
) -> Id;
}
extern "C" {
pub fn solver_next_solutionelement(
solv: *mut s_Solver,
problem: Id,
solution: Id,
element: Id,
p: *mut Id,
rp: *mut Id,
) -> Id;
}
extern "C" {
pub fn solver_take_solutionelement(
solv: *mut s_Solver,
p: Id,
rp: Id,
extrajobflags: Id,
job: *mut Queue,
);
}
extern "C" {
pub fn solver_take_solution(solv: *mut s_Solver, problem: Id, solution: Id, job: *mut Queue);
}
extern "C" {
pub fn solver_findproblemrule(solv: *mut s_Solver, problem: Id) -> Id;
}
extern "C" {
pub fn solver_findallproblemrules(solv: *mut s_Solver, problem: Id, rules: *mut Queue);
}
extern "C" {
pub fn solver_problemruleinfo2str(
solv: *mut s_Solver,
type_: SolverRuleinfo,
source: Id,
target: Id,
dep: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solver_problem2str(solv: *mut s_Solver, problem: Id) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solver_solutionelement2str(
solv: *mut s_Solver,
p: Id,
rp: Id,
) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Solver {
pub pool: *mut Pool,
pub job: Queue,
pub solution_callback: ::std::option::Option<
unsafe extern "C" fn(
solv: *mut s_Solver,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
pub solution_callback_data: *mut ::std::os::raw::c_void,
pub pooljobcnt: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_s_Solver() {
assert_eq!(
::std::mem::size_of::<s_Solver>(),
64usize,
concat!("Size of: ", stringify!(s_Solver))
);
assert_eq!(
::std::mem::align_of::<s_Solver>(),
8usize,
concat!("Alignment of ", stringify!(s_Solver))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solver>())).pool as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Solver),
"::",
stringify!(pool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solver>())).job as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Solver),
"::",
stringify!(job)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solver>())).solution_callback as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(s_Solver),
"::",
stringify!(solution_callback)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solver>())).solution_callback_data as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(s_Solver),
"::",
stringify!(solution_callback_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Solver>())).pooljobcnt as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(s_Solver),
"::",
stringify!(pooljobcnt)
)
);
}
pub type Solver = s_Solver;
extern "C" {
pub fn solver_create(pool: *mut Pool) -> *mut Solver;
}
extern "C" {
pub fn solver_free(solv: *mut Solver);
}
extern "C" {
pub fn solver_solve(solv: *mut Solver, job: *mut Queue) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_create_transaction(solv: *mut Solver) -> *mut Transaction;
}
extern "C" {
pub fn solver_set_flag(
solv: *mut Solver,
flag: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_get_flag(solv: *mut Solver, flag: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_get_decisionlevel(solv: *mut Solver, p: Id) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_get_decisionqueue(solv: *mut Solver, decisionq: *mut Queue);
}
extern "C" {
pub fn solver_get_lastdecisionblocklevel(solv: *mut Solver) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_get_decisionblock(
solv: *mut Solver,
level: ::std::os::raw::c_int,
decisionq: *mut Queue,
);
}
extern "C" {
pub fn solver_get_orphaned(solv: *mut Solver, orphanedq: *mut Queue);
}
extern "C" {
pub fn solver_get_recommendations(
solv: *mut Solver,
recommendationsq: *mut Queue,
suggestionsq: *mut Queue,
noselected: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn solver_get_unneeded(
solv: *mut Solver,
unneededq: *mut Queue,
filtered: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn solver_get_userinstalled(solv: *mut Solver, q: *mut Queue, flags: ::std::os::raw::c_int);
}
extern "C" {
pub fn pool_add_userinstalled_jobs(
pool: *mut Pool,
q: *mut Queue,
job: *mut Queue,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn solver_get_cleandeps(solv: *mut Solver, cleandepsq: *mut Queue);
}
extern "C" {
pub fn solver_describe_decision(
solv: *mut Solver,
p: Id,
infop: *mut Id,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_describe_weakdep_decision(solv: *mut Solver, p: Id, whyq: *mut Queue);
}
extern "C" {
pub fn solver_alternatives_count(solv: *mut Solver) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_get_alternative(
solv: *mut Solver,
alternative: Id,
idp: *mut Id,
fromp: *mut Id,
chosenp: *mut Id,
choices: *mut Queue,
levelp: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_calculate_multiversionmap(
pool: *mut Pool,
job: *mut Queue,
multiversionmap: *mut Map,
);
}
extern "C" {
pub fn solver_calculate_noobsmap(pool: *mut Pool, job: *mut Queue, multiversionmap: *mut Map);
}
extern "C" {
pub fn solver_create_state_maps(
solv: *mut Solver,
installedmap: *mut Map,
conflictsmap: *mut Map,
);
}
extern "C" {
pub fn solver_calc_duchanges(
solv: *mut Solver,
mps: *mut DUChanges,
nmps: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn solver_calc_installsizechange(solv: *mut Solver) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pool_job2solvables(pool: *mut Pool, pkgs: *mut Queue, how: Id, what: Id);
}
extern "C" {
pub fn pool_isemptyupdatejob(pool: *mut Pool, how: Id, what: Id) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn solver_select2str(
pool: *mut Pool,
select: Id,
what: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn pool_job2str(
pool: *mut Pool,
how: Id,
what: Id,
flagmask: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solver_alternative2str(
solv: *mut Solver,
type_: ::std::os::raw::c_int,
id: Id,
from: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn solver_trivial_installable(solv: *mut Solver, pkgs: *mut Queue, res: *mut Queue);
}
extern "C" {
pub fn solver_printruleelement(
solv: *mut Solver,
type_: ::std::os::raw::c_int,
r: *mut Rule,
v: Id,
);
}
extern "C" {
pub fn solver_printrule(solv: *mut Solver, type_: ::std::os::raw::c_int, r: *mut Rule);
}
extern "C" {
pub fn solver_printruleclass(solv: *mut Solver, type_: ::std::os::raw::c_int, r: *mut Rule);
}
extern "C" {
pub fn solver_printproblem(solv: *mut Solver, v: Id);
}
extern "C" {
pub fn solver_printwatches(solv: *mut Solver, type_: ::std::os::raw::c_int);
}
extern "C" {
pub fn solver_printdecisionq(solv: *mut Solver, type_: ::std::os::raw::c_int);
}
extern "C" {
pub fn solver_printdecisions(solv: *mut Solver);
}
extern "C" {
pub fn solver_printproblemruleinfo(solv: *mut Solver, rule: Id);
}
extern "C" {
pub fn solver_printprobleminfo(solv: *mut Solver, problem: Id);
}
extern "C" {
pub fn solver_printcompleteprobleminfo(solv: *mut Solver, problem: Id);
}
extern "C" {
pub fn solver_printsolution(solv: *mut Solver, problem: Id, solution: Id);
}
extern "C" {
pub fn solver_printallsolutions(solv: *mut Solver);
}
extern "C" {
pub fn transaction_print(trans: *mut Transaction);
}
extern "C" {
pub fn solver_printtrivial(solv: *mut Solver);
}
extern "C" {
pub fn selection_make(
pool: *mut Pool,
selection: *mut Queue,
name: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn selection_make_matchdeps(
pool: *mut Pool,
selection: *mut Queue,
name: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
keyname: ::std::os::raw::c_int,
marker: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn selection_make_matchdepid(
pool: *mut Pool,
selection: *mut Queue,
dep: Id,
flags: ::std::os::raw::c_int,
keyname: ::std::os::raw::c_int,
marker: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn selection_make_matchsolvable(
pool: *mut Pool,
selection: *mut Queue,
solvid: Id,
flags: ::std::os::raw::c_int,
keyname: ::std::os::raw::c_int,
marker: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn selection_make_matchsolvablelist(
pool: *mut Pool,
selection: *mut Queue,
solvidq: *mut Queue,
flags: ::std::os::raw::c_int,
keyname: ::std::os::raw::c_int,
marker: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn selection_filter(pool: *mut Pool, sel1: *mut Queue, sel2: *mut Queue);
}
extern "C" {
pub fn selection_add(pool: *mut Pool, sel1: *mut Queue, sel2: *mut Queue);
}
extern "C" {
pub fn selection_subtract(pool: *mut Pool, sel1: *mut Queue, sel2: *mut Queue);
}
extern "C" {
pub fn selection_solvables(pool: *mut Pool, selection: *mut Queue, pkgs: *mut Queue);
}
extern "C" {
pub fn pool_selection2str(
pool: *mut Pool,
selection: *mut Queue,
flagmask: Id,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn repo_add_solv(
repo: *mut Repo,
fp: *mut FILE,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_Repowriter {
pub repo: *mut Repo,
pub flags: ::std::os::raw::c_int,
pub repodatastart: ::std::os::raw::c_int,
pub repodataend: ::std::os::raw::c_int,
pub solvablestart: ::std::os::raw::c_int,
pub solvableend: ::std::os::raw::c_int,
pub keyfilter: ::std::option::Option<
unsafe extern "C" fn(
repo: *mut Repo,
key: *mut Repokey,
kfdata: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
pub kfdata: *mut ::std::os::raw::c_void,
pub keyq: *mut Queue,
}
#[test]
fn bindgen_test_layout_s_Repowriter() {
assert_eq!(
::std::mem::size_of::<s_Repowriter>(),
56usize,
concat!("Size of: ", stringify!(s_Repowriter))
);
assert_eq!(
::std::mem::align_of::<s_Repowriter>(),
8usize,
concat!("Alignment of ", stringify!(s_Repowriter))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).repo as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(repo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).flags as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).repodatastart as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(repodatastart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).repodataend as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(repodataend)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).solvablestart as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(solvablestart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).solvableend as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(solvableend)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).keyfilter as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(keyfilter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).kfdata as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(kfdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<s_Repowriter>())).keyq as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(s_Repowriter),
"::",
stringify!(keyq)
)
);
}
pub type Repowriter = s_Repowriter;
extern "C" {
pub fn repowriter_create(repo: *mut Repo) -> *mut Repowriter;
}
extern "C" {
pub fn repowriter_free(writer: *mut Repowriter) -> *mut Repowriter;
}
extern "C" {
pub fn repowriter_set_flags(writer: *mut Repowriter, flags: ::std::os::raw::c_int);
}
extern "C" {
pub fn repowriter_set_keyfilter(
writer: *mut Repowriter,
keyfilter: ::std::option::Option<
unsafe extern "C" fn(
repo: *mut Repo,
key: *mut Repokey,
kfdata: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
kfdata: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn repowriter_set_keyqueue(writer: *mut Repowriter, keyq: *mut Queue);
}
extern "C" {
pub fn repowriter_set_repodatarange(
writer: *mut Repowriter,
repodatastart: ::std::os::raw::c_int,
repodataend: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn repowriter_set_solvablerange(
writer: *mut Repowriter,
solvablestart: ::std::os::raw::c_int,
solvableend: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn repowriter_write(writer: *mut Repowriter, fp: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_write(repo: *mut Repo, fp: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repodata_write(data: *mut Repodata, fp: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_write_stdkeyfilter(
repo: *mut Repo,
key: *mut Repokey,
kfdata: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_write_filtered(
repo: *mut Repo,
fp: *mut FILE,
keyfilter: ::std::option::Option<
unsafe extern "C" fn(
repo: *mut Repo,
key: *mut Repokey,
kfdata: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
kfdata: *mut ::std::os::raw::c_void,
keyq: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repodata_write_filtered(
data: *mut Repodata,
fp: *mut FILE,
keyfilter: ::std::option::Option<
unsafe extern "C" fn(
repo: *mut Repo,
key: *mut Repokey,
kfdata: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
kfdata: *mut ::std::os::raw::c_void,
keyq: *mut Queue,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_add_debpackages(
repo: *mut Repo,
fp: *mut FILE,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_add_debdb(repo: *mut Repo, flags: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn repo_add_deb(
repo: *mut Repo,
deb: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
) -> Id;
}
extern "C" {
pub fn pool_deb_get_autoinstalled(
pool: *mut Pool,
fp: *mut FILE,
q: *mut Queue,
flags: ::std::os::raw::c_int,
);
}