pub const URI_DEFS_CONFIG_H: u32 = 1;
pub const URI_ENABLE_ANSI: u32 = 1;
pub const URI_ENABLE_UNICODE: u32 = 1;
pub const URI_PASS_ANSI: u32 = 1;
pub const URI_H_ANSI: u32 = 1;
pub const URI_BASE_H: u32 = 1;
pub const URI_VER_MAJOR: u32 = 0;
pub const URI_VER_MINOR: u32 = 9;
pub const URI_VER_RELEASE: u32 = 5;
pub const URI_VER_SUFFIX_ANSI: &'static [u8; 1usize] = b"\0";
pub const URI_TRUE: u32 = 1;
pub const URI_FALSE: u32 = 0;
pub const URI_SUCCESS: u32 = 0;
pub const URI_ERROR_SYNTAX: u32 = 1;
pub const URI_ERROR_NULL: u32 = 2;
pub const URI_ERROR_MALLOC: u32 = 3;
pub const URI_ERROR_OUTPUT_TOO_LARGE: u32 = 4;
pub const URI_ERROR_NOT_IMPLEMENTED: u32 = 8;
pub const URI_ERROR_RANGE_INVALID: u32 = 9;
pub const URI_ERROR_MEMORY_MANAGER_INCOMPLETE: u32 = 10;
pub const URI_ERROR_TOSTRING_TOO_LONG: u32 = 4;
pub const URI_ERROR_ADDBASE_REL_BASE: u32 = 5;
pub const URI_ERROR_REMOVEBASE_REL_BASE: u32 = 6;
pub const URI_ERROR_REMOVEBASE_REL_SOURCE: u32 = 7;
pub const URI_ERROR_MEMORY_MANAGER_FAULTY: u32 = 11;
pub const URI_PASS_UNICODE: u32 = 1;
pub const URI_H_UNICODE: u32 = 1;
pub type UriBool = ::std::os::raw::c_int;
pub type size_t = ::std::os::raw::c_ulong;
#[doc = " Holds an IPv4 address."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct UriIp4Struct {
#[doc = "< Each octet in one byte"]
pub data: [::std::os::raw::c_uchar; 4usize],
}
#[test]
fn bindgen_test_layout_UriIp4Struct() {
assert_eq!(
::std::mem::size_of::<UriIp4Struct>(),
4usize,
concat!("Size of: ", stringify!(UriIp4Struct))
);
assert_eq!(
::std::mem::align_of::<UriIp4Struct>(),
1usize,
concat!("Alignment of ", stringify!(UriIp4Struct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriIp4Struct>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriIp4Struct),
"::",
stringify!(data)
)
);
}
#[doc = " Holds an IPv4 address."]
pub type UriIp4 = UriIp4Struct;
#[doc = " Holds an IPv6 address."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct UriIp6Struct {
#[doc = "< Each quad in two bytes"]
pub data: [::std::os::raw::c_uchar; 16usize],
}
#[test]
fn bindgen_test_layout_UriIp6Struct() {
assert_eq!(
::std::mem::size_of::<UriIp6Struct>(),
16usize,
concat!("Size of: ", stringify!(UriIp6Struct))
);
assert_eq!(
::std::mem::align_of::<UriIp6Struct>(),
1usize,
concat!("Alignment of ", stringify!(UriIp6Struct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriIp6Struct>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriIp6Struct),
"::",
stringify!(data)
)
);
}
#[doc = " Holds an IPv6 address."]
pub type UriIp6 = UriIp6Struct;
#[doc = " Function signature that custom malloc(3) functions must conform to"]
#[doc = ""]
#[doc = " @since 0.9.0"]
pub type UriFuncMalloc = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut UriMemoryManagerStruct,
arg2: size_t,
) -> *mut ::std::os::raw::c_void,
>;
#[doc = " Function signature that custom calloc(3) functions must conform to"]
#[doc = ""]
#[doc = " @since 0.9.0"]
pub type UriFuncCalloc = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut UriMemoryManagerStruct,
arg2: size_t,
arg3: size_t,
) -> *mut ::std::os::raw::c_void,
>;
#[doc = " Function signature that custom realloc(3) functions must conform to"]
#[doc = ""]
#[doc = " @since 0.9.0"]
pub type UriFuncRealloc = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut UriMemoryManagerStruct,
arg2: *mut ::std::os::raw::c_void,
arg3: size_t,
) -> *mut ::std::os::raw::c_void,
>;
#[doc = " Function signature that custom reallocarray(3) functions must conform to"]
#[doc = ""]
#[doc = " @since 0.9.0"]
pub type UriFuncReallocarray = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut UriMemoryManagerStruct,
arg2: *mut ::std::os::raw::c_void,
arg3: size_t,
arg4: size_t,
) -> *mut ::std::os::raw::c_void,
>;
#[doc = " Function signature that custom free(3) functions must conform to"]
#[doc = ""]
#[doc = " @since 0.9.0"]
pub type UriFuncFree = ::std::option::Option<
unsafe extern "C" fn(arg1: *mut UriMemoryManagerStruct, arg2: *mut ::std::os::raw::c_void),
>;
#[doc = " Class-like interface of custom memory managers"]
#[doc = ""]
#[doc = " @see uriCompleteMemoryManager"]
#[doc = " @see uriEmulateCalloc"]
#[doc = " @see uriEmulateReallocarray"]
#[doc = " @see uriTestMemoryManager"]
#[doc = " @since 0.9.0"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UriMemoryManagerStruct {
#[doc = "< Pointer to custom malloc(3)"]
pub malloc: UriFuncMalloc,
#[doc = "< Pointer to custom calloc(3); to emulate using malloc and memset see uriEmulateCalloc"]
pub calloc: UriFuncCalloc,
#[doc = "< Pointer to custom realloc(3)"]
pub realloc: UriFuncRealloc,
#[doc = "< Pointer to custom reallocarray(3); to emulate using realloc see uriEmulateReallocarray"]
pub reallocarray: UriFuncReallocarray,
#[doc = "< Pointer to custom free(3)"]
pub free: UriFuncFree,
#[doc = "< Pointer to data that the other function members need access to"]
pub userData: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_UriMemoryManagerStruct() {
assert_eq!(
::std::mem::size_of::<UriMemoryManagerStruct>(),
48usize,
concat!("Size of: ", stringify!(UriMemoryManagerStruct))
);
assert_eq!(
::std::mem::align_of::<UriMemoryManagerStruct>(),
8usize,
concat!("Alignment of ", stringify!(UriMemoryManagerStruct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriMemoryManagerStruct>())).malloc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriMemoryManagerStruct),
"::",
stringify!(malloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriMemoryManagerStruct>())).calloc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(UriMemoryManagerStruct),
"::",
stringify!(calloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriMemoryManagerStruct>())).realloc as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(UriMemoryManagerStruct),
"::",
stringify!(realloc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<UriMemoryManagerStruct>())).reallocarray as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(UriMemoryManagerStruct),
"::",
stringify!(reallocarray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriMemoryManagerStruct>())).free as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(UriMemoryManagerStruct),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriMemoryManagerStruct>())).userData as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(UriMemoryManagerStruct),
"::",
stringify!(userData)
)
);
}
impl Default for UriMemoryManagerStruct {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " Class-like interface of custom memory managers"]
#[doc = ""]
#[doc = " @see uriCompleteMemoryManager"]
#[doc = " @see uriEmulateCalloc"]
#[doc = " @see uriEmulateReallocarray"]
#[doc = " @see uriTestMemoryManager"]
#[doc = " @since 0.9.0"]
pub type UriMemoryManager = UriMemoryManagerStruct;
#[doc = "< Convert to Unix line breaks (\"\\\\x0a\")"]
pub const UriBreakConversionEnum_URI_BR_TO_LF: UriBreakConversionEnum = 0;
#[doc = "< Convert to Windows line breaks (\"\\\\x0d\\\\x0a\")"]
pub const UriBreakConversionEnum_URI_BR_TO_CRLF: UriBreakConversionEnum = 1;
#[doc = "< Convert to Macintosh line breaks (\"\\\\x0d\")"]
pub const UriBreakConversionEnum_URI_BR_TO_CR: UriBreakConversionEnum = 2;
#[doc = "< @copydoc UriBreakConversionEnum::URI_BR_TO_LF"]
pub const UriBreakConversionEnum_URI_BR_TO_UNIX: UriBreakConversionEnum = 0;
#[doc = "< @copydoc UriBreakConversionEnum::URI_BR_TO_CRLF"]
pub const UriBreakConversionEnum_URI_BR_TO_WINDOWS: UriBreakConversionEnum = 1;
#[doc = "< @copydoc UriBreakConversionEnum::URI_BR_TO_CR"]
pub const UriBreakConversionEnum_URI_BR_TO_MAC: UriBreakConversionEnum = 2;
#[doc = "< Copy line breaks unmodified"]
pub const UriBreakConversionEnum_URI_BR_DONT_TOUCH: UriBreakConversionEnum = 3;
#[doc = " Specifies a line break conversion mode."]
pub type UriBreakConversionEnum = ::std::os::raw::c_uint;
#[doc = " Specifies a line break conversion mode."]
pub use self::UriBreakConversionEnum as UriBreakConversion;
#[doc = "< Full RFC conformance"]
pub const UriResolutionOptionsEnum_URI_RESOLVE_STRICTLY: UriResolutionOptionsEnum = 0;
#[doc = "< Treat %URI to resolve with identical scheme as having no scheme"]
pub const UriResolutionOptionsEnum_URI_RESOLVE_IDENTICAL_SCHEME_COMPAT: UriResolutionOptionsEnum =
1;
#[doc = " Specifies how to resolve %URI references."]
pub type UriResolutionOptionsEnum = ::std::os::raw::c_uint;
#[doc = " Specifies how to resolve %URI references."]
pub use self::UriResolutionOptionsEnum as UriResolutionOptions;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UriTextRangeStructA {
#[doc = "< Pointer to first character"]
pub first: *const ::std::os::raw::c_char,
#[doc = "< Pointer to character after the last one still in"]
pub afterLast: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_UriTextRangeStructA() {
assert_eq!(
::std::mem::size_of::<UriTextRangeStructA>(),
16usize,
concat!("Size of: ", stringify!(UriTextRangeStructA))
);
assert_eq!(
::std::mem::align_of::<UriTextRangeStructA>(),
8usize,
concat!("Alignment of ", stringify!(UriTextRangeStructA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriTextRangeStructA>())).first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriTextRangeStructA),
"::",
stringify!(first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriTextRangeStructA>())).afterLast as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(UriTextRangeStructA),
"::",
stringify!(afterLast)
)
);
}
impl Default for UriTextRangeStructA {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " Specifies a range of characters within a string."]
#[doc = " The range includes all characters from <c>first</c>"]
#[doc = " to one before <c>afterLast</c>. So if both are"]
#[doc = " non-NULL the difference is the length of the text range."]
#[doc = ""]
#[doc = " @see UriUriA"]
#[doc = " @see UriPathSegmentA"]
#[doc = " @see UriHostDataA"]
#[doc = " @since 0.3.0"]
pub type UriTextRangeA = UriTextRangeStructA;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UriPathSegmentStructA {
#[doc = "< Path segment name"]
pub text: UriTextRangeA,
#[doc = "< Pointer to the next path segment in the list, can be NULL if last already"]
pub next: *mut UriPathSegmentStructA,
#[doc = "< Reserved to the parser"]
pub reserved: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_UriPathSegmentStructA() {
assert_eq!(
::std::mem::size_of::<UriPathSegmentStructA>(),
32usize,
concat!("Size of: ", stringify!(UriPathSegmentStructA))
);
assert_eq!(
::std::mem::align_of::<UriPathSegmentStructA>(),
8usize,
concat!("Alignment of ", stringify!(UriPathSegmentStructA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriPathSegmentStructA>())).text as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriPathSegmentStructA),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriPathSegmentStructA>())).next as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(UriPathSegmentStructA),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriPathSegmentStructA>())).reserved as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(UriPathSegmentStructA),
"::",
stringify!(reserved)
)
);
}
impl Default for UriPathSegmentStructA {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " Represents a path segment within a %URI path."]
#[doc = " More precisely it is a node in a linked"]
#[doc = " list of path segments."]
#[doc = ""]
#[doc = " @see UriUriA"]
#[doc = " @since 0.3.0"]
pub type UriPathSegmentA = UriPathSegmentStructA;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UriHostDataStructA {
#[doc = "< IPv4 address"]
pub ip4: *mut UriIp4,
#[doc = "< IPv6 address"]
pub ip6: *mut UriIp6,
#[doc = "< IPvFuture address"]
pub ipFuture: UriTextRangeA,
}
#[test]
fn bindgen_test_layout_UriHostDataStructA() {
assert_eq!(
::std::mem::size_of::<UriHostDataStructA>(),
32usize,
concat!("Size of: ", stringify!(UriHostDataStructA))
);
assert_eq!(
::std::mem::align_of::<UriHostDataStructA>(),
8usize,
concat!("Alignment of ", stringify!(UriHostDataStructA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriHostDataStructA>())).ip4 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriHostDataStructA),
"::",
stringify!(ip4)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriHostDataStructA>())).ip6 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(UriHostDataStructA),
"::",
stringify!(ip6)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriHostDataStructA>())).ipFuture as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(UriHostDataStructA),
"::",
stringify!(ipFuture)
)
);
}
impl Default for UriHostDataStructA {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " Holds structured host information."]
#[doc = " This is either a IPv4, IPv6, plain"]
#[doc = " text for IPvFuture or all zero for"]
#[doc = " a registered name."]
#[doc = ""]
#[doc = " @see UriUriA"]
#[doc = " @since 0.3.0"]
pub type UriHostDataA = UriHostDataStructA;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UriUriStructA {
#[doc = "< Scheme (e.g. \"http\")"]
pub scheme: UriTextRangeA,
#[doc = "< User info (e.g. \"user:pass\")"]
pub userInfo: UriTextRangeA,
#[doc = "< Host text (set for all hosts, excluding square brackets)"]
pub hostText: UriTextRangeA,
#[doc = "< Structured host type specific data"]
pub hostData: UriHostDataA,
#[doc = "< Port (e.g. \"80\")"]
pub portText: UriTextRangeA,
#[doc = "< Head of a linked list of path segments"]
pub pathHead: *mut UriPathSegmentA,
#[doc = "< Tail of the list behind pathHead"]
pub pathTail: *mut UriPathSegmentA,
#[doc = "< Query without leading \"?\""]
pub query: UriTextRangeA,
#[doc = "< Query without leading \"#\""]
pub fragment: UriTextRangeA,
#[doc = "< Absolute path flag, distincting \"a\" and \"/a\";"]
#[doc = "always <c>URI_FALSE</c> for URIs with host"]
pub absolutePath: UriBool,
#[doc = "< Memory owner flag"]
pub owner: UriBool,
#[doc = "< Reserved to the parser"]
pub reserved: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_UriUriStructA() {
assert_eq!(
::std::mem::size_of::<UriUriStructA>(),
160usize,
concat!("Size of: ", stringify!(UriUriStructA))
);
assert_eq!(
::std::mem::align_of::<UriUriStructA>(),
8usize,
concat!("Alignment of ", stringify!(UriUriStructA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).scheme as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(scheme)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).userInfo as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(userInfo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).hostText as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(hostText)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).hostData as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(hostData)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).portText as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(portText)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).pathHead as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(pathHead)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).pathTail as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(pathTail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).query as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(query)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).fragment as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(fragment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).absolutePath as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(absolutePath)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).owner as *const _ as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriUriStructA>())).reserved as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(UriUriStructA),
"::",
stringify!(reserved)
)
);
}
impl Default for UriUriStructA {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " Represents an RFC 3986 %URI."]
#[doc = " Missing components can be {NULL, NULL} ranges."]
#[doc = ""]
#[doc = " @see uriFreeUriMembersA"]
#[doc = " @see uriFreeUriMembersMmA"]
#[doc = " @see UriParserStateA"]
#[doc = " @since 0.3.0"]
pub type UriUriA = UriUriStructA;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UriParserStateStructA {
#[doc = "< Plug in the %URI structure to be filled while parsing here"]
pub uri: *mut UriUriA,
#[doc = "< Code identifying the error which occurred"]
pub errorCode: ::std::os::raw::c_int,
#[doc = "< Pointer to position in case of a syntax error"]
pub errorPos: *const ::std::os::raw::c_char,
#[doc = "< Reserved to the parser"]
pub reserved: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_UriParserStateStructA() {
assert_eq!(
::std::mem::size_of::<UriParserStateStructA>(),
32usize,
concat!("Size of: ", stringify!(UriParserStateStructA))
);
assert_eq!(
::std::mem::align_of::<UriParserStateStructA>(),
8usize,
concat!("Alignment of ", stringify!(UriParserStateStructA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriParserStateStructA>())).uri as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriParserStateStructA),
"::",
stringify!(uri)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriParserStateStructA>())).errorCode as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(UriParserStateStructA),
"::",
stringify!(errorCode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriParserStateStructA>())).errorPos as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(UriParserStateStructA),
"::",
stringify!(errorPos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriParserStateStructA>())).reserved as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(UriParserStateStructA),
"::",
stringify!(reserved)
)
);
}
impl Default for UriParserStateStructA {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " Represents a state of the %URI parser."]
#[doc = " Missing components can be NULL to reflect"]
#[doc = " a components absence."]
#[doc = ""]
#[doc = " @see uriFreeUriMembersA"]
#[doc = " @see uriFreeUriMembersMmA"]
#[doc = " @since 0.3.0"]
pub type UriParserStateA = UriParserStateStructA;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UriQueryListStructA {
#[doc = "< Key of the query element"]
pub key: *const ::std::os::raw::c_char,
#[doc = "< Value of the query element, can be NULL"]
pub value: *const ::std::os::raw::c_char,
#[doc = "< Pointer to the next key/value pair in the list, can be NULL if last already"]
pub next: *mut UriQueryListStructA,
}
#[test]
fn bindgen_test_layout_UriQueryListStructA() {
assert_eq!(
::std::mem::size_of::<UriQueryListStructA>(),
24usize,
concat!("Size of: ", stringify!(UriQueryListStructA))
);
assert_eq!(
::std::mem::align_of::<UriQueryListStructA>(),
8usize,
concat!("Alignment of ", stringify!(UriQueryListStructA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriQueryListStructA>())).key as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(UriQueryListStructA),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriQueryListStructA>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(UriQueryListStructA),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<UriQueryListStructA>())).next as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(UriQueryListStructA),
"::",
stringify!(next)
)
);
}
impl Default for UriQueryListStructA {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " Represents a query element."]
#[doc = " More precisely it is a node in a linked"]
#[doc = " list of query elements."]
#[doc = ""]
#[doc = " @since 0.7.0"]
pub type UriQueryListA = UriQueryListStructA;
extern "C" {
pub fn uriParseUriExA(
state: *mut UriParserStateA,
first: *const ::std::os::raw::c_char,
afterLast: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriParseUriA(
state: *mut UriParserStateA,
text: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriParseSingleUriA(
uri: *mut UriUriA,
text: *const ::std::os::raw::c_char,
errorPos: *mut *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriParseSingleUriExA(
uri: *mut UriUriA,
first: *const ::std::os::raw::c_char,
afterLast: *const ::std::os::raw::c_char,
errorPos: *mut *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriParseSingleUriExMmA(
uri: *mut UriUriA,
first: *const ::std::os::raw::c_char,
afterLast: *const ::std::os::raw::c_char,
errorPos: *mut *const ::std::os::raw::c_char,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriFreeUriMembersA(uri: *mut UriUriA);
}
extern "C" {
pub fn uriFreeUriMembersMmA(
uri: *mut UriUriA,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriEscapeExA(
inFirst: *const ::std::os::raw::c_char,
inAfterLast: *const ::std::os::raw::c_char,
out: *mut ::std::os::raw::c_char,
spaceToPlus: UriBool,
normalizeBreaks: UriBool,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn uriEscapeA(
in_: *const ::std::os::raw::c_char,
out: *mut ::std::os::raw::c_char,
spaceToPlus: UriBool,
normalizeBreaks: UriBool,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn uriUnescapeInPlaceExA(
inout: *mut ::std::os::raw::c_char,
plusToSpace: UriBool,
breakConversion: UriBreakConversion,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn uriUnescapeInPlaceA(inout: *mut ::std::os::raw::c_char)
-> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn uriAddBaseUriA(
absoluteDest: *mut UriUriA,
relativeSource: *const UriUriA,
absoluteBase: *const UriUriA,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriAddBaseUriExA(
absoluteDest: *mut UriUriA,
relativeSource: *const UriUriA,
absoluteBase: *const UriUriA,
options: UriResolutionOptions,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriAddBaseUriExMmA(
absoluteDest: *mut UriUriA,
relativeSource: *const UriUriA,
absoluteBase: *const UriUriA,
options: UriResolutionOptions,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriRemoveBaseUriA(
dest: *mut UriUriA,
absoluteSource: *const UriUriA,
absoluteBase: *const UriUriA,
domainRootMode: UriBool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriRemoveBaseUriMmA(
dest: *mut UriUriA,
absoluteSource: *const UriUriA,
absoluteBase: *const UriUriA,
domainRootMode: UriBool,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriEqualsUriA(a: *const UriUriA, b: *const UriUriA) -> UriBool;
}
extern "C" {
pub fn uriToStringCharsRequiredA(
uri: *const UriUriA,
charsRequired: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriToStringA(
dest: *mut ::std::os::raw::c_char,
uri: *const UriUriA,
maxChars: ::std::os::raw::c_int,
charsWritten: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriNormalizeSyntaxMaskRequiredA(uri: *const UriUriA) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn uriNormalizeSyntaxMaskRequiredExA(
uri: *const UriUriA,
outMask: *mut ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriNormalizeSyntaxExA(
uri: *mut UriUriA,
mask: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriNormalizeSyntaxExMmA(
uri: *mut UriUriA,
mask: ::std::os::raw::c_uint,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriNormalizeSyntaxA(uri: *mut UriUriA) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriUnixFilenameToUriStringA(
filename: *const ::std::os::raw::c_char,
uriString: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriWindowsFilenameToUriStringA(
filename: *const ::std::os::raw::c_char,
uriString: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriUriStringToUnixFilenameA(
uriString: *const ::std::os::raw::c_char,
filename: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriUriStringToWindowsFilenameA(
uriString: *const ::std::os::raw::c_char,
filename: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriComposeQueryCharsRequiredA(
queryList: *const UriQueryListA,
charsRequired: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriComposeQueryCharsRequiredExA(
queryList: *const UriQueryListA,
charsRequired: *mut ::std::os::raw::c_int,
spaceToPlus: UriBool,
normalizeBreaks: UriBool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriComposeQueryA(
dest: *mut ::std::os::raw::c_char,
queryList: *const UriQueryListA,
maxChars: ::std::os::raw::c_int,
charsWritten: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriComposeQueryExA(
dest: *mut ::std::os::raw::c_char,
queryList: *const UriQueryListA,
maxChars: ::std::os::raw::c_int,
charsWritten: *mut ::std::os::raw::c_int,
spaceToPlus: UriBool,
normalizeBreaks: UriBool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriComposeQueryMallocA(
dest: *mut *mut ::std::os::raw::c_char,
queryList: *const UriQueryListA,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriComposeQueryMallocExA(
dest: *mut *mut ::std::os::raw::c_char,
queryList: *const UriQueryListA,
spaceToPlus: UriBool,
normalizeBreaks: UriBool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriComposeQueryMallocExMmA(
dest: *mut *mut ::std::os::raw::c_char,
queryList: *const UriQueryListA,
spaceToPlus: UriBool,
normalizeBreaks: UriBool,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriDissectQueryMallocA(
dest: *mut *mut UriQueryListA,
itemCount: *mut ::std::os::raw::c_int,
first: *const ::std::os::raw::c_char,
afterLast: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriDissectQueryMallocExA(
dest: *mut *mut UriQueryListA,
itemCount: *mut ::std::os::raw::c_int,
first: *const ::std::os::raw::c_char,
afterLast: *const ::std::os::raw::c_char,
plusToSpace: UriBool,
breakConversion: UriBreakConversion,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriDissectQueryMallocExMmA(
dest: *mut *mut UriQueryListA,
itemCount: *mut ::std::os::raw::c_int,
first: *const ::std::os::raw::c_char,
afterLast: *const ::std::os::raw::c_char,
plusToSpace: UriBool,
breakConversion: UriBreakConversion,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriFreeQueryListA(queryList: *mut UriQueryListA);
}
extern "C" {
pub fn uriFreeQueryListMmA(
queryList: *mut UriQueryListA,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriMakeOwnerA(uri: *mut UriUriA) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uriMakeOwnerMmA(
uri: *mut UriUriA,
memory: *mut UriMemoryManager,
) -> ::std::os::raw::c_int;
}