#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
pub const __GNUC_VA_LIST: u32 = 1;
pub const _STDINT_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 29;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_TYPES_H: u32 = 1;
pub const __TIMESIZE: u32 = 64;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: i32 = -1;
pub const UINT_FAST32_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const _STDIO_H: u32 = 1;
pub const _____fpos_t_defined: u32 = 1;
pub const ____mbstate_t_defined: u32 = 1;
pub const _____fpos64_t_defined: u32 = 1;
pub const ____FILE_defined: u32 = 1;
pub const __FILE_defined: u32 = 1;
pub const __struct_FILE_defined: u32 = 1;
pub const _IO_EOF_SEEN: u32 = 16;
pub const _IO_ERR_SEEN: u32 = 32;
pub const _IO_USER_LOCK: u32 = 32768;
pub const _IOFBF: u32 = 0;
pub const _IOLBF: u32 = 1;
pub const _IONBF: u32 = 2;
pub const BUFSIZ: u32 = 8192;
pub const EOF: i32 = -1;
pub const SEEK_SET: u32 = 0;
pub const SEEK_CUR: u32 = 1;
pub const SEEK_END: u32 = 2;
pub const P_tmpdir: &'static [u8; 5usize] = b"/tmp\0";
pub const _BITS_STDIO_LIM_H: u32 = 1;
pub const L_tmpnam: u32 = 20;
pub const TMP_MAX: u32 = 238328;
pub const FILENAME_MAX: u32 = 4096;
pub const L_ctermid: u32 = 9;
pub const FOPEN_MAX: u32 = 16;
pub const LV2_CORE_URI: &'static [u8; 29usize] = b"http://lv2plug.in/ns/lv2core\0";
pub const LV2_CORE_PREFIX: &'static [u8; 30usize] = b"http://lv2plug.in/ns/lv2core#\0";
pub const LV2_CORE__AllpassPlugin: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#AllpassPlugin\0";
pub const LV2_CORE__AmplifierPlugin: &'static [u8; 45usize] =
b"http://lv2plug.in/ns/lv2core#AmplifierPlugin\0";
pub const LV2_CORE__AnalyserPlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#AnalyserPlugin\0";
pub const LV2_CORE__AudioPort: &'static [u8; 39usize] = b"http://lv2plug.in/ns/lv2core#AudioPort\0";
pub const LV2_CORE__BandpassPlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#BandpassPlugin\0";
pub const LV2_CORE__CVPort: &'static [u8; 36usize] = b"http://lv2plug.in/ns/lv2core#CVPort\0";
pub const LV2_CORE__ChorusPlugin: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#ChorusPlugin\0";
pub const LV2_CORE__CombPlugin: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/lv2core#CombPlugin\0";
pub const LV2_CORE__CompressorPlugin: &'static [u8; 46usize] =
b"http://lv2plug.in/ns/lv2core#CompressorPlugin\0";
pub const LV2_CORE__ConstantPlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#ConstantPlugin\0";
pub const LV2_CORE__ControlPort: &'static [u8; 41usize] =
b"http://lv2plug.in/ns/lv2core#ControlPort\0";
pub const LV2_CORE__ConverterPlugin: &'static [u8; 45usize] =
b"http://lv2plug.in/ns/lv2core#ConverterPlugin\0";
pub const LV2_CORE__DelayPlugin: &'static [u8; 41usize] =
b"http://lv2plug.in/ns/lv2core#DelayPlugin\0";
pub const LV2_CORE__DistortionPlugin: &'static [u8; 46usize] =
b"http://lv2plug.in/ns/lv2core#DistortionPlugin\0";
pub const LV2_CORE__DynamicsPlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#DynamicsPlugin\0";
pub const LV2_CORE__EQPlugin: &'static [u8; 38usize] = b"http://lv2plug.in/ns/lv2core#EQPlugin\0";
pub const LV2_CORE__EnvelopePlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#EnvelopePlugin\0";
pub const LV2_CORE__ExpanderPlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#ExpanderPlugin\0";
pub const LV2_CORE__ExtensionData: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#ExtensionData\0";
pub const LV2_CORE__Feature: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#Feature\0";
pub const LV2_CORE__FilterPlugin: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#FilterPlugin\0";
pub const LV2_CORE__FlangerPlugin: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#FlangerPlugin\0";
pub const LV2_CORE__FunctionPlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#FunctionPlugin\0";
pub const LV2_CORE__GatePlugin: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/lv2core#GatePlugin\0";
pub const LV2_CORE__GeneratorPlugin: &'static [u8; 45usize] =
b"http://lv2plug.in/ns/lv2core#GeneratorPlugin\0";
pub const LV2_CORE__HighpassPlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#HighpassPlugin\0";
pub const LV2_CORE__InputPort: &'static [u8; 39usize] = b"http://lv2plug.in/ns/lv2core#InputPort\0";
pub const LV2_CORE__InstrumentPlugin: &'static [u8; 46usize] =
b"http://lv2plug.in/ns/lv2core#InstrumentPlugin\0";
pub const LV2_CORE__LimiterPlugin: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#LimiterPlugin\0";
pub const LV2_CORE__LowpassPlugin: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#LowpassPlugin\0";
pub const LV2_CORE__MixerPlugin: &'static [u8; 41usize] =
b"http://lv2plug.in/ns/lv2core#MixerPlugin\0";
pub const LV2_CORE__ModulatorPlugin: &'static [u8; 45usize] =
b"http://lv2plug.in/ns/lv2core#ModulatorPlugin\0";
pub const LV2_CORE__MultiEQPlugin: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#MultiEQPlugin\0";
pub const LV2_CORE__OscillatorPlugin: &'static [u8; 46usize] =
b"http://lv2plug.in/ns/lv2core#OscillatorPlugin\0";
pub const LV2_CORE__OutputPort: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/lv2core#OutputPort\0";
pub const LV2_CORE__ParaEQPlugin: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#ParaEQPlugin\0";
pub const LV2_CORE__PhaserPlugin: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#PhaserPlugin\0";
pub const LV2_CORE__PitchPlugin: &'static [u8; 41usize] =
b"http://lv2plug.in/ns/lv2core#PitchPlugin\0";
pub const LV2_CORE__Plugin: &'static [u8; 36usize] = b"http://lv2plug.in/ns/lv2core#Plugin\0";
pub const LV2_CORE__PluginBase: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/lv2core#PluginBase\0";
pub const LV2_CORE__Point: &'static [u8; 35usize] = b"http://lv2plug.in/ns/lv2core#Point\0";
pub const LV2_CORE__Port: &'static [u8; 34usize] = b"http://lv2plug.in/ns/lv2core#Port\0";
pub const LV2_CORE__PortProperty: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#PortProperty\0";
pub const LV2_CORE__Resource: &'static [u8; 38usize] = b"http://lv2plug.in/ns/lv2core#Resource\0";
pub const LV2_CORE__ReverbPlugin: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#ReverbPlugin\0";
pub const LV2_CORE__ScalePoint: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/lv2core#ScalePoint\0";
pub const LV2_CORE__SimulatorPlugin: &'static [u8; 45usize] =
b"http://lv2plug.in/ns/lv2core#SimulatorPlugin\0";
pub const LV2_CORE__SpatialPlugin: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#SpatialPlugin\0";
pub const LV2_CORE__Specification: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#Specification\0";
pub const LV2_CORE__SpectralPlugin: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#SpectralPlugin\0";
pub const LV2_CORE__UtilityPlugin: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#UtilityPlugin\0";
pub const LV2_CORE__WaveshaperPlugin: &'static [u8; 46usize] =
b"http://lv2plug.in/ns/lv2core#WaveshaperPlugin\0";
pub const LV2_CORE__appliesTo: &'static [u8; 39usize] = b"http://lv2plug.in/ns/lv2core#appliesTo\0";
pub const LV2_CORE__binary: &'static [u8; 36usize] = b"http://lv2plug.in/ns/lv2core#binary\0";
pub const LV2_CORE__connectionOptional: &'static [u8; 48usize] =
b"http://lv2plug.in/ns/lv2core#connectionOptional\0";
pub const LV2_CORE__control: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#control\0";
pub const LV2_CORE__default: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#default\0";
pub const LV2_CORE__designation: &'static [u8; 41usize] =
b"http://lv2plug.in/ns/lv2core#designation\0";
pub const LV2_CORE__documentation: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#documentation\0";
pub const LV2_CORE__enumeration: &'static [u8; 41usize] =
b"http://lv2plug.in/ns/lv2core#enumeration\0";
pub const LV2_CORE__extensionData: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#extensionData\0";
pub const LV2_CORE__freeWheeling: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#freeWheeling\0";
pub const LV2_CORE__hardRTCapable: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#hardRTCapable\0";
pub const LV2_CORE__inPlaceBroken: &'static [u8; 43usize] =
b"http://lv2plug.in/ns/lv2core#inPlaceBroken\0";
pub const LV2_CORE__index: &'static [u8; 35usize] = b"http://lv2plug.in/ns/lv2core#index\0";
pub const LV2_CORE__integer: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#integer\0";
pub const LV2_CORE__isLive: &'static [u8; 36usize] = b"http://lv2plug.in/ns/lv2core#isLive\0";
pub const LV2_CORE__latency: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#latency\0";
pub const LV2_CORE__maximum: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#maximum\0";
pub const LV2_CORE__microVersion: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#microVersion\0";
pub const LV2_CORE__minimum: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#minimum\0";
pub const LV2_CORE__minorVersion: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#minorVersion\0";
pub const LV2_CORE__name: &'static [u8; 34usize] = b"http://lv2plug.in/ns/lv2core#name\0";
pub const LV2_CORE__optionalFeature: &'static [u8; 45usize] =
b"http://lv2plug.in/ns/lv2core#optionalFeature\0";
pub const LV2_CORE__port: &'static [u8; 34usize] = b"http://lv2plug.in/ns/lv2core#port\0";
pub const LV2_CORE__portProperty: &'static [u8; 42usize] =
b"http://lv2plug.in/ns/lv2core#portProperty\0";
pub const LV2_CORE__project: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#project\0";
pub const LV2_CORE__prototype: &'static [u8; 39usize] = b"http://lv2plug.in/ns/lv2core#prototype\0";
pub const LV2_CORE__reportsLatency: &'static [u8; 44usize] =
b"http://lv2plug.in/ns/lv2core#reportsLatency\0";
pub const LV2_CORE__requiredFeature: &'static [u8; 45usize] =
b"http://lv2plug.in/ns/lv2core#requiredFeature\0";
pub const LV2_CORE__sampleRate: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/lv2core#sampleRate\0";
pub const LV2_CORE__scalePoint: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/lv2core#scalePoint\0";
pub const LV2_CORE__symbol: &'static [u8; 36usize] = b"http://lv2plug.in/ns/lv2core#symbol\0";
pub const LV2_CORE__toggled: &'static [u8; 37usize] = b"http://lv2plug.in/ns/lv2core#toggled\0";
pub const LV2_URID_URI: &'static [u8; 30usize] = b"http://lv2plug.in/ns/ext/urid\0";
pub const LV2_URID_PREFIX: &'static [u8; 31usize] = b"http://lv2plug.in/ns/ext/urid#\0";
pub const LV2_URID__map: &'static [u8; 34usize] = b"http://lv2plug.in/ns/ext/urid#map\0";
pub const LV2_URID__unmap: &'static [u8; 36usize] = b"http://lv2plug.in/ns/ext/urid#unmap\0";
pub const LV2_URID_MAP_URI: &'static [u8; 34usize] = b"http://lv2plug.in/ns/ext/urid#map\0";
pub const LV2_URID_UNMAP_URI: &'static [u8; 36usize] = b"http://lv2plug.in/ns/ext/urid#unmap\0";
pub const true_: u32 = 1;
pub const false_: u32 = 0;
pub const __bool_true_false_are_defined: u32 = 1;
pub const LILV_NS_DOAP: &'static [u8; 30usize] = b"http://usefulinc.com/ns/doap#\0";
pub const LILV_NS_FOAF: &'static [u8; 27usize] = b"http://xmlns.com/foaf/0.1/\0";
pub const LILV_NS_LILV: &'static [u8; 29usize] = b"http://drobilla.net/ns/lilv#\0";
pub const LILV_NS_LV2: &'static [u8; 30usize] = b"http://lv2plug.in/ns/lv2core#\0";
pub const LILV_NS_OWL: &'static [u8; 31usize] = b"http://www.w3.org/2002/07/owl#\0";
pub const LILV_NS_RDF: &'static [u8; 44usize] = b"http://www.w3.org/1999/02/22-rdf-syntax-ns#\0";
pub const LILV_NS_RDFS: &'static [u8; 38usize] = b"http://www.w3.org/2000/01/rdf-schema#\0";
pub const LILV_NS_XSD: &'static [u8; 34usize] = b"http://www.w3.org/2001/XMLSchema#\0";
pub const LILV_URI_ATOM_PORT: &'static [u8; 39usize] = b"http://lv2plug.in/ns/ext/atom#AtomPort\0";
pub const LILV_URI_AUDIO_PORT: &'static [u8; 39usize] = b"http://lv2plug.in/ns/lv2core#AudioPort\0";
pub const LILV_URI_CONTROL_PORT: &'static [u8; 41usize] =
b"http://lv2plug.in/ns/lv2core#ControlPort\0";
pub const LILV_URI_CV_PORT: &'static [u8; 36usize] = b"http://lv2plug.in/ns/lv2core#CVPort\0";
pub const LILV_URI_EVENT_PORT: &'static [u8; 41usize] =
b"http://lv2plug.in/ns/ext/event#EventPort\0";
pub const LILV_URI_INPUT_PORT: &'static [u8; 39usize] = b"http://lv2plug.in/ns/lv2core#InputPort\0";
pub const LILV_URI_MIDI_EVENT: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/ext/midi#MidiEvent\0";
pub const LILV_URI_OUTPUT_PORT: &'static [u8; 40usize] =
b"http://lv2plug.in/ns/lv2core#OutputPort\0";
pub const LILV_URI_PORT: &'static [u8; 34usize] = b"http://lv2plug.in/ns/lv2core#Port\0";
pub const LILV_OPTION_FILTER_LANG: &'static [u8; 40usize] =
b"http://drobilla.net/ns/lilv#filter-lang\0";
pub const LILV_OPTION_DYN_MANIFEST: &'static [u8; 41usize] =
b"http://drobilla.net/ns/lilv#dyn-manifest\0";
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
pub type wchar_t = ::std::os::raw::c_int;
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct max_align_t {
pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
pub __bindgen_padding_0: u64,
pub __clang_max_align_nonce2: u128,
}
#[test]
fn bindgen_test_layout_max_align_t() {
assert_eq!(
::std::mem::size_of::<max_align_t>(),
32usize,
concat!("Size of: ", stringify!(max_align_t))
);
assert_eq!(
::std::mem::align_of::<max_align_t>(),
16usize,
concat!("Alignment of ", stringify!(max_align_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<max_align_t>())).__clang_max_align_nonce1 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(max_align_t),
"::",
stringify!(__clang_max_align_nonce1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<max_align_t>())).__clang_max_align_nonce2 as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(max_align_t),
"::",
stringify!(__clang_max_align_nonce2)
)
);
}
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_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 __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_long;
pub type int_fast32_t = ::std::os::raw::c_long;
pub type int_fast64_t = ::std::os::raw::c_long;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_ulong;
pub type uint_fast32_t = ::std::os::raw::c_ulong;
pub type uint_fast64_t = ::std::os::raw::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __mbstate_t {
pub __count: ::std::os::raw::c_int,
pub __value: __mbstate_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t__bindgen_ty_1 {
pub __wch: ::std::os::raw::c_uint,
pub __wchb: [::std::os::raw::c_char; 4usize],
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wch as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wchb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wchb)
)
);
}
#[test]
fn bindgen_test_layout___mbstate_t() {
assert_eq!(
::std::mem::size_of::<__mbstate_t>(),
8usize,
concat!("Size of: ", stringify!(__mbstate_t))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t>(),
4usize,
concat!("Alignment of ", stringify!(__mbstate_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__value as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__value)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos_t {
pub __pos: __off_t,
pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos_t() {
assert_eq!(
::std::mem::size_of::<_G_fpos_t>(),
16usize,
concat!("Size of: ", stringify!(_G_fpos_t))
);
assert_eq!(
::std::mem::align_of::<_G_fpos_t>(),
8usize,
concat!("Alignment of ", stringify!(_G_fpos_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__state as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos_t),
"::",
stringify!(__state)
)
);
}
pub type __fpos_t = _G_fpos_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos64_t {
pub __pos: __off64_t,
pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos64_t() {
assert_eq!(
::std::mem::size_of::<_G_fpos64_t>(),
16usize,
concat!("Size of: ", stringify!(_G_fpos64_t))
);
assert_eq!(
::std::mem::align_of::<_G_fpos64_t>(),
8usize,
concat!("Alignment of ", stringify!(_G_fpos64_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos64_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__state as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos64_t),
"::",
stringify!(__state)
)
);
}
pub type __fpos64_t = _G_fpos64_t;
pub type __FILE = _IO_FILE;
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: usize,
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 off_t = __off_t;
pub type fpos_t = __fpos_t;
extern "C" {
pub static mut stdin: *mut FILE;
}
extern "C" {
pub static mut stdout: *mut FILE;
}
extern "C" {
pub static mut stderr: *mut FILE;
}
extern "C" {
pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rename(
__old: *const ::std::os::raw::c_char,
__new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn renameat(
__oldfd: ::std::os::raw::c_int,
__old: *const ::std::os::raw::c_char,
__newfd: ::std::os::raw::c_int,
__new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn tmpfile() -> *mut FILE;
}
extern "C" {
pub fn tmpnam(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tempnam(
__dir: *const ::std::os::raw::c_char,
__pfx: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fopen(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn freopen(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
__stream: *mut FILE,
) -> *mut FILE;
}
extern "C" {
pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
-> *mut FILE;
}
extern "C" {
pub fn fmemopen(
__s: *mut ::std::os::raw::c_void,
__len: usize,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn open_memstream(
__bufloc: *mut *mut ::std::os::raw::c_char,
__sizeloc: *mut usize,
) -> *mut FILE;
}
extern "C" {
pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn setvbuf(
__stream: *mut FILE,
__buf: *mut ::std::os::raw::c_char,
__modes: ::std::os::raw::c_int,
__n: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: usize);
}
extern "C" {
pub fn setlinebuf(__stream: *mut FILE);
}
extern "C" {
pub fn fprintf(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sprintf(
__s: *mut ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vfprintf(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vprintf(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsprintf(
__s: *mut ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn snprintf(
__s: *mut ::std::os::raw::c_char,
__maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsnprintf(
__s: *mut ::std::os::raw::c_char,
__maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vdprintf(
__fd: ::std::os::raw::c_int,
__fmt: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dprintf(
__fd: ::std::os::raw::c_int,
__fmt: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fscanf(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sscanf(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_fscanf"]
pub fn fscanf1(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_scanf"]
pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_sscanf"]
pub fn sscanf1(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vfscanf(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vscanf(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsscanf(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vfscanf"]
pub fn vfscanf1(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vscanf"]
pub fn vscanf1(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vsscanf"]
pub fn vsscanf1(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar_unlocked() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgets(
__s: *mut ::std::os::raw::c_char,
__n: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut usize,
__delimiter: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut usize,
__delimiter: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn getline(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut usize,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fread(
__ptr: *mut ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong,
__stream: *mut FILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn fwrite(
__ptr: *const ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong,
__s: *mut FILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn fread_unlocked(
__ptr: *mut ::std::os::raw::c_void,
__size: usize,
__n: usize,
__stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn fwrite_unlocked(
__ptr: *const ::std::os::raw::c_void,
__size: usize,
__n: usize,
__stream: *mut FILE,
) -> usize;
}
extern "C" {
pub fn fseek(
__stream: *mut FILE,
__off: ::std::os::raw::c_long,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn rewind(__stream: *mut FILE);
}
extern "C" {
pub fn fseeko(
__stream: *mut FILE,
__off: __off_t,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftello(__stream: *mut FILE) -> __off_t;
}
extern "C" {
pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearerr(__stream: *mut FILE);
}
extern "C" {
pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearerr_unlocked(__stream: *mut FILE);
}
extern "C" {
pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn perror(__s: *const ::std::os::raw::c_char);
}
extern "C" {
pub static mut sys_nerr: ::std::os::raw::c_int;
}
extern "C" {
pub static mut sys_errlist: [*const ::std::os::raw::c_char; 0usize];
}
extern "C" {
pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn popen(
__command: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn flockfile(__stream: *mut FILE);
}
extern "C" {
pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn funlockfile(__stream: *mut FILE);
}
extern "C" {
pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
pub type LV2_Handle = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LV2_Feature {
pub URI: *const ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__LV2_Feature() {
assert_eq!(
::std::mem::size_of::<_LV2_Feature>(),
16usize,
concat!("Size of: ", stringify!(_LV2_Feature))
);
assert_eq!(
::std::mem::align_of::<_LV2_Feature>(),
8usize,
concat!("Alignment of ", stringify!(_LV2_Feature))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Feature>())).URI as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Feature),
"::",
stringify!(URI)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Feature>())).data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Feature),
"::",
stringify!(data)
)
);
}
pub type LV2_Feature = _LV2_Feature;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LV2_Descriptor {
pub URI: *const ::std::os::raw::c_char,
pub instantiate: ::std::option::Option<
unsafe extern "C" fn(
descriptor: *const _LV2_Descriptor,
sample_rate: f64,
bundle_path: *const ::std::os::raw::c_char,
features: *const *const LV2_Feature,
) -> LV2_Handle,
>,
pub connect_port: ::std::option::Option<
unsafe extern "C" fn(
instance: LV2_Handle,
port: u32,
data_location: *mut ::std::os::raw::c_void,
),
>,
pub activate: ::std::option::Option<unsafe extern "C" fn(instance: LV2_Handle)>,
pub run: ::std::option::Option<unsafe extern "C" fn(instance: LV2_Handle, sample_count: u32)>,
pub deactivate: ::std::option::Option<unsafe extern "C" fn(instance: LV2_Handle)>,
pub cleanup: ::std::option::Option<unsafe extern "C" fn(instance: LV2_Handle)>,
pub extension_data: ::std::option::Option<
unsafe extern "C" fn(uri: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_void,
>,
}
#[test]
fn bindgen_test_layout__LV2_Descriptor() {
assert_eq!(
::std::mem::size_of::<_LV2_Descriptor>(),
64usize,
concat!("Size of: ", stringify!(_LV2_Descriptor))
);
assert_eq!(
::std::mem::align_of::<_LV2_Descriptor>(),
8usize,
concat!("Alignment of ", stringify!(_LV2_Descriptor))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Descriptor>())).URI as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Descriptor),
"::",
stringify!(URI)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Descriptor>())).instantiate as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Descriptor),
"::",
stringify!(instantiate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Descriptor>())).connect_port as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Descriptor),
"::",
stringify!(connect_port)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Descriptor>())).activate as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Descriptor),
"::",
stringify!(activate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Descriptor>())).run as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Descriptor),
"::",
stringify!(run)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Descriptor>())).deactivate as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Descriptor),
"::",
stringify!(deactivate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Descriptor>())).cleanup as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Descriptor),
"::",
stringify!(cleanup)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_Descriptor>())).extension_data as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_LV2_Descriptor),
"::",
stringify!(extension_data)
)
);
}
pub type LV2_Descriptor = _LV2_Descriptor;
extern "C" {
pub fn lv2_descriptor(index: u32) -> *const LV2_Descriptor;
}
pub type LV2_Descriptor_Function =
::std::option::Option<unsafe extern "C" fn(index: u32) -> *const LV2_Descriptor>;
pub type LV2_Lib_Handle = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LV2_Lib_Descriptor {
pub handle: LV2_Lib_Handle,
pub size: u32,
pub cleanup: ::std::option::Option<unsafe extern "C" fn(handle: LV2_Lib_Handle)>,
pub get_plugin: ::std::option::Option<
unsafe extern "C" fn(handle: LV2_Lib_Handle, index: u32) -> *const LV2_Descriptor,
>,
}
#[test]
fn bindgen_test_layout_LV2_Lib_Descriptor() {
assert_eq!(
::std::mem::size_of::<LV2_Lib_Descriptor>(),
32usize,
concat!("Size of: ", stringify!(LV2_Lib_Descriptor))
);
assert_eq!(
::std::mem::align_of::<LV2_Lib_Descriptor>(),
8usize,
concat!("Alignment of ", stringify!(LV2_Lib_Descriptor))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<LV2_Lib_Descriptor>())).handle as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(LV2_Lib_Descriptor),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<LV2_Lib_Descriptor>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(LV2_Lib_Descriptor),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<LV2_Lib_Descriptor>())).cleanup as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(LV2_Lib_Descriptor),
"::",
stringify!(cleanup)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<LV2_Lib_Descriptor>())).get_plugin as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(LV2_Lib_Descriptor),
"::",
stringify!(get_plugin)
)
);
}
extern "C" {
pub fn lv2_lib_descriptor(
bundle_path: *const ::std::os::raw::c_char,
features: *const *const LV2_Feature,
) -> *const LV2_Lib_Descriptor;
}
pub type LV2_Lib_Descriptor_Function = ::std::option::Option<
unsafe extern "C" fn(
bundle_path: *const ::std::os::raw::c_char,
features: *const *const LV2_Feature,
) -> *const LV2_Lib_Descriptor,
>;
pub type LV2_URID_Map_Handle = *mut ::std::os::raw::c_void;
pub type LV2_URID_Unmap_Handle = *mut ::std::os::raw::c_void;
pub type LV2_URID = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LV2_URID_Map {
pub handle: LV2_URID_Map_Handle,
pub map: ::std::option::Option<
unsafe extern "C" fn(
handle: LV2_URID_Map_Handle,
uri: *const ::std::os::raw::c_char,
) -> LV2_URID,
>,
}
#[test]
fn bindgen_test_layout__LV2_URID_Map() {
assert_eq!(
::std::mem::size_of::<_LV2_URID_Map>(),
16usize,
concat!("Size of: ", stringify!(_LV2_URID_Map))
);
assert_eq!(
::std::mem::align_of::<_LV2_URID_Map>(),
8usize,
concat!("Alignment of ", stringify!(_LV2_URID_Map))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_URID_Map>())).handle as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LV2_URID_Map),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_URID_Map>())).map as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_LV2_URID_Map),
"::",
stringify!(map)
)
);
}
pub type LV2_URID_Map = _LV2_URID_Map;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LV2_URID_Unmap {
pub handle: LV2_URID_Unmap_Handle,
pub unmap: ::std::option::Option<
unsafe extern "C" fn(
handle: LV2_URID_Unmap_Handle,
urid: LV2_URID,
) -> *const ::std::os::raw::c_char,
>,
}
#[test]
fn bindgen_test_layout__LV2_URID_Unmap() {
assert_eq!(
::std::mem::size_of::<_LV2_URID_Unmap>(),
16usize,
concat!("Size of: ", stringify!(_LV2_URID_Unmap))
);
assert_eq!(
::std::mem::align_of::<_LV2_URID_Unmap>(),
8usize,
concat!("Alignment of ", stringify!(_LV2_URID_Unmap))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_URID_Unmap>())).handle as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_LV2_URID_Unmap),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_LV2_URID_Unmap>())).unmap as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_LV2_URID_Unmap),
"::",
stringify!(unmap)
)
);
}
pub type LV2_URID_Unmap = _LV2_URID_Unmap;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvPluginImpl {
_unused: [u8; 0],
}
pub type LilvPlugin = LilvPluginImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvPluginClassImpl {
_unused: [u8; 0],
}
pub type LilvPluginClass = LilvPluginClassImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvPortImpl {
_unused: [u8; 0],
}
pub type LilvPort = LilvPortImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvScalePointImpl {
_unused: [u8; 0],
}
pub type LilvScalePoint = LilvScalePointImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvUIImpl {
_unused: [u8; 0],
}
pub type LilvUI = LilvUIImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvNodeImpl {
_unused: [u8; 0],
}
pub type LilvNode = LilvNodeImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvWorldImpl {
_unused: [u8; 0],
}
pub type LilvWorld = LilvWorldImpl;
pub type LilvInstance = LilvInstanceImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvStateImpl {
_unused: [u8; 0],
}
pub type LilvState = LilvStateImpl;
pub type LilvIter = ::std::os::raw::c_void;
pub type LilvPluginClasses = ::std::os::raw::c_void;
pub type LilvPlugins = ::std::os::raw::c_void;
pub type LilvScalePoints = ::std::os::raw::c_void;
pub type LilvUIs = ::std::os::raw::c_void;
pub type LilvNodes = ::std::os::raw::c_void;
extern "C" {
#[doc = "Free memory allocated by Lilv."]
#[doc = ""]
#[doc = "This function exists because some systems require memory allocated by a"]
#[doc = "library to be freed by code in the same library. It is otherwise equivalent"]
#[doc = "to the standard C free() function."]
pub fn lilv_free(ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
#[doc = "Convert a file URI string to a local path string."]
#[doc = "For example, \"file://foo/bar/baz.ttl\" returns \"/foo/bar/baz.ttl\"."]
#[doc = "Return value is shared and must not be deleted by caller."]
#[doc = "This function does not handle escaping correctly and should not be used for"]
#[doc = "general file URIs. Use lilv_file_uri_parse() instead."]
#[doc = "@return `uri` converted to a path, or NULL on failure (URI is not local)."]
pub fn lilv_uri_to_path(uri: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Convert a file URI string to a local path string."]
#[doc = "For example, \"file://foo/bar%20one/baz.ttl\" returns \"/foo/bar one/baz.ttl\"."]
#[doc = "Return value must be freed by caller with lilv_free()."]
#[doc = "@param uri The file URI to parse."]
#[doc = "@param hostname If non-NULL, set to the hostname in the URI, if any."]
#[doc = "@return `uri` converted to a path, or NULL on failure (URI is not local)."]
pub fn lilv_file_uri_parse(
uri: *const ::std::os::raw::c_char,
hostname: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Create a new URI value."]
#[doc = "Returned value must be freed by caller with lilv_node_free()."]
pub fn lilv_new_uri(world: *mut LilvWorld, uri: *const ::std::os::raw::c_char)
-> *mut LilvNode;
}
extern "C" {
#[doc = "Create a new file URI value."]
#[doc = "@param world The world."]
#[doc = "@param host Host name, or NULL."]
#[doc = "@param path Path on host."]
#[doc = "@return A new node that must be freed by caller."]
#[doc = ""]
#[doc = "Relative paths are resolved against the current working directory. Note"]
#[doc = "that this may yield unexpected results if `host` is another machine."]
pub fn lilv_new_file_uri(
world: *mut LilvWorld,
host: *const ::std::os::raw::c_char,
path: *const ::std::os::raw::c_char,
) -> *mut LilvNode;
}
extern "C" {
#[doc = "Create a new string value (with no language)."]
#[doc = "Returned value must be freed by caller with lilv_node_free()."]
pub fn lilv_new_string(
world: *mut LilvWorld,
str: *const ::std::os::raw::c_char,
) -> *mut LilvNode;
}
extern "C" {
#[doc = "Create a new integer value."]
#[doc = "Returned value must be freed by caller with lilv_node_free()."]
pub fn lilv_new_int(world: *mut LilvWorld, val: ::std::os::raw::c_int) -> *mut LilvNode;
}
extern "C" {
#[doc = "Create a new floating point value."]
#[doc = "Returned value must be freed by caller with lilv_node_free()."]
pub fn lilv_new_float(world: *mut LilvWorld, val: f32) -> *mut LilvNode;
}
extern "C" {
#[doc = "Create a new boolean value."]
#[doc = "Returned value must be freed by caller with lilv_node_free()."]
pub fn lilv_new_bool(world: *mut LilvWorld, val: bool) -> *mut LilvNode;
}
extern "C" {
#[doc = "Free a LilvNode."]
#[doc = "It is safe to call this function on NULL."]
pub fn lilv_node_free(val: *mut LilvNode);
}
extern "C" {
#[doc = "Duplicate a LilvNode."]
pub fn lilv_node_duplicate(val: *const LilvNode) -> *mut LilvNode;
}
extern "C" {
#[doc = "Return whether two values are equivalent."]
pub fn lilv_node_equals(value: *const LilvNode, other: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return this value as a Turtle/SPARQL token."]
#[doc = "Returned value must be freed by caller with lilv_free()."]
#[doc = "<table>"]
#[doc = "<caption>Example Turtle Tokens</caption>"]
#[doc = "<tr><th>URI</th><td><http://example.org/foo ></td></tr>"]
#[doc = "<tr><th>QName</th><td>doap:name</td></tr>"]
#[doc = "<tr><th>String</th><td>\"this is a string\"</td></tr>"]
#[doc = "<tr><th>Float</th><td>1.0</td></tr>"]
#[doc = "<tr><th>Integer</th><td>1</td></tr>"]
#[doc = "<tr><th>Boolean</th><td>true</td></tr>"]
#[doc = "</table>"]
pub fn lilv_node_get_turtle_token(value: *const LilvNode) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Return whether the value is a URI (resource)."]
pub fn lilv_node_is_uri(value: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return this value as a URI string, e.g. \"http://example.org/foo\"."]
#[doc = "Valid to call only if `lilv_node_is_uri(value)` returns true."]
#[doc = "Returned value is owned by `value` and must not be freed by caller."]
pub fn lilv_node_as_uri(value: *const LilvNode) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Return whether the value is a blank node (resource with no URI)."]
pub fn lilv_node_is_blank(value: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return this value as a blank node identifier, e.g. \"genid03\"."]
#[doc = "Valid to call only if `lilv_node_is_blank(value)` returns true."]
#[doc = "Returned value is owned by `value` and must not be freed by caller."]
pub fn lilv_node_as_blank(value: *const LilvNode) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Return whether this value is a literal (i.e. not a URI)."]
#[doc = "Returns true if `value` is a string or numeric value."]
pub fn lilv_node_is_literal(value: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return whether this value is a string literal."]
#[doc = "Returns true if `value` is a string value (and not numeric)."]
pub fn lilv_node_is_string(value: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return `value` as a string."]
pub fn lilv_node_as_string(value: *const LilvNode) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Return the path of a file URI node."]
#[doc = "Returns NULL if `value` is not a file URI."]
#[doc = "Returned value must be freed by caller with lilv_free()."]
pub fn lilv_node_get_path(
value: *const LilvNode,
hostname: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Return whether this value is a decimal literal."]
pub fn lilv_node_is_float(value: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return `value` as a float."]
#[doc = "Valid to call only if `lilv_node_is_float(value)` or"]
#[doc = "`lilv_node_is_int(value)` returns true."]
pub fn lilv_node_as_float(value: *const LilvNode) -> f32;
}
extern "C" {
#[doc = "Return whether this value is an integer literal."]
pub fn lilv_node_is_int(value: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return `value` as an integer."]
#[doc = "Valid to call only if `lilv_node_is_int(value)` returns true."]
pub fn lilv_node_as_int(value: *const LilvNode) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = "Return whether this value is a boolean."]
pub fn lilv_node_is_bool(value: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return `value` as a bool."]
#[doc = "Valid to call only if `lilv_node_is_bool(value)` returns true."]
pub fn lilv_node_as_bool(value: *const LilvNode) -> bool;
}
extern "C" {
pub fn lilv_plugin_classes_free(collection: *mut LilvPluginClasses);
}
extern "C" {
pub fn lilv_plugin_classes_size(collection: *const LilvPluginClasses)
-> ::std::os::raw::c_uint;
}
extern "C" {
pub fn lilv_plugin_classes_begin(collection: *const LilvPluginClasses) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_plugin_classes_get(
collection: *const LilvPluginClasses,
i: *mut LilvIter,
) -> *const LilvPluginClass;
}
extern "C" {
pub fn lilv_plugin_classes_next(
collection: *const LilvPluginClasses,
i: *mut LilvIter,
) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_plugin_classes_is_end(
collection: *const LilvPluginClasses,
i: *mut LilvIter,
) -> bool;
}
extern "C" {
#[doc = "Get a plugin class from `classes` by URI."]
#[doc = "Return value is shared (stored in `classes`) and must not be freed or"]
#[doc = "modified by the caller in any way."]
#[doc = "@return NULL if no plugin class with `uri` is found in `classes`."]
pub fn lilv_plugin_classes_get_by_uri(
classes: *const LilvPluginClasses,
uri: *const LilvNode,
) -> *const LilvPluginClass;
}
extern "C" {
pub fn lilv_scale_points_free(collection: *mut LilvScalePoints);
}
extern "C" {
pub fn lilv_scale_points_size(collection: *const LilvScalePoints) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn lilv_scale_points_begin(collection: *const LilvScalePoints) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_scale_points_get(
collection: *const LilvScalePoints,
i: *mut LilvIter,
) -> *const LilvScalePoint;
}
extern "C" {
pub fn lilv_scale_points_next(
collection: *const LilvScalePoints,
i: *mut LilvIter,
) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_scale_points_is_end(collection: *const LilvScalePoints, i: *mut LilvIter) -> bool;
}
extern "C" {
pub fn lilv_uis_free(collection: *mut LilvUIs);
}
extern "C" {
pub fn lilv_uis_size(collection: *const LilvUIs) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn lilv_uis_begin(collection: *const LilvUIs) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_uis_get(collection: *const LilvUIs, i: *mut LilvIter) -> *const LilvUI;
}
extern "C" {
pub fn lilv_uis_next(collection: *const LilvUIs, i: *mut LilvIter) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_uis_is_end(collection: *const LilvUIs, i: *mut LilvIter) -> bool;
}
extern "C" {
#[doc = "Get a UI from `uis` by URI."]
#[doc = "Return value is shared (stored in `uis`) and must not be freed or"]
#[doc = "modified by the caller in any way."]
#[doc = "@return NULL if no UI with `uri` is found in `list`."]
pub fn lilv_uis_get_by_uri(uis: *const LilvUIs, uri: *const LilvNode) -> *const LilvUI;
}
extern "C" {
pub fn lilv_nodes_free(collection: *mut LilvNodes);
}
extern "C" {
pub fn lilv_nodes_size(collection: *const LilvNodes) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn lilv_nodes_begin(collection: *const LilvNodes) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_nodes_get(collection: *const LilvNodes, i: *mut LilvIter) -> *const LilvNode;
}
extern "C" {
pub fn lilv_nodes_next(collection: *const LilvNodes, i: *mut LilvIter) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_nodes_is_end(collection: *const LilvNodes, i: *mut LilvIter) -> bool;
}
extern "C" {
pub fn lilv_nodes_get_first(collection: *const LilvNodes) -> *mut LilvNode;
}
extern "C" {
#[doc = "Return whether `values` contains `value`."]
pub fn lilv_nodes_contains(nodes: *const LilvNodes, value: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Return a new LilvNodes that contains all nodes from both `a` and `b`."]
pub fn lilv_nodes_merge(a: *const LilvNodes, b: *const LilvNodes) -> *mut LilvNodes;
}
extern "C" {
pub fn lilv_plugins_size(collection: *const LilvPlugins) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn lilv_plugins_begin(collection: *const LilvPlugins) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_plugins_get(collection: *const LilvPlugins, i: *mut LilvIter) -> *const LilvPlugin;
}
extern "C" {
pub fn lilv_plugins_next(collection: *const LilvPlugins, i: *mut LilvIter) -> *mut LilvIter;
}
extern "C" {
pub fn lilv_plugins_is_end(collection: *const LilvPlugins, i: *mut LilvIter) -> bool;
}
extern "C" {
#[doc = "Get a plugin from `plugins` by URI."]
#[doc = "Return value is shared (stored in `plugins`) and must not be freed or"]
#[doc = "modified by the caller in any way."]
#[doc = "@return NULL if no plugin with `uri` is found in `plugins`."]
pub fn lilv_plugins_get_by_uri(
plugins: *const LilvPlugins,
uri: *const LilvNode,
) -> *const LilvPlugin;
}
extern "C" {
#[doc = "Initialize a new, empty world."]
#[doc = "If initialization fails, NULL is returned."]
pub fn lilv_world_new() -> *mut LilvWorld;
}
extern "C" {
#[doc = "Set an option option for `world`."]
#[doc = ""]
#[doc = "Currently recognized options:"]
#[doc = "@ref LILV_OPTION_FILTER_LANG"]
#[doc = "@ref LILV_OPTION_DYN_MANIFEST"]
pub fn lilv_world_set_option(
world: *mut LilvWorld,
uri: *const ::std::os::raw::c_char,
value: *const LilvNode,
);
}
extern "C" {
#[doc = "Destroy the world, mwahaha."]
#[doc = "It is safe to call this function on NULL."]
#[doc = "Note that destroying `world` will destroy all the objects it contains"]
#[doc = "(e.g. instances of LilvPlugin). Do not destroy the world until you are"]
#[doc = "finished with all objects that came from it."]
pub fn lilv_world_free(world: *mut LilvWorld);
}
extern "C" {
#[doc = "Load all installed LV2 bundles on the system."]
#[doc = "This is the recommended way for hosts to load LV2 data. It implements the"]
#[doc = "established/standard best practice for discovering all LV2 data on the"]
#[doc = "system. The environment variable LV2_PATH may be used to control where"]
#[doc = "this function will look for bundles."]
#[doc = ""]
#[doc = "Hosts should use this function rather than explicitly load bundles, except"]
#[doc = "in special circumstances (e.g. development utilities, or hosts that ship"]
#[doc = "with special plugin bundles which are installed to a known location)."]
pub fn lilv_world_load_all(world: *mut LilvWorld);
}
extern "C" {
#[doc = "Load a specific bundle."]
#[doc = "`bundle_uri` must be a fully qualified URI to the bundle directory,"]
#[doc = "with the trailing slash, eg. file:///usr/lib/lv2/foo.lv2/"]
#[doc = ""]
#[doc = "Normal hosts should not need this function (use lilv_world_load_all())."]
#[doc = ""]
#[doc = "Hosts MUST NOT attach any long-term significance to bundle paths"]
#[doc = "(e.g. in save files), since there are no guarantees they will remain"]
#[doc = "unchanged between (or even during) program invocations. Plugins (among"]
#[doc = "other things) MUST be identified by URIs (not paths) in save files."]
pub fn lilv_world_load_bundle(world: *mut LilvWorld, bundle_uri: *const LilvNode);
}
extern "C" {
#[doc = "Load all specifications from currently loaded bundles."]
#[doc = ""]
#[doc = "This is for hosts that explicitly load specific bundles, its use is not"]
#[doc = "necessary when using lilv_world_load_all(). This function parses the"]
#[doc = "specifications and adds them to the model."]
pub fn lilv_world_load_specifications(world: *mut LilvWorld);
}
extern "C" {
#[doc = "Load all plugin classes from currently loaded specifications."]
#[doc = ""]
#[doc = "Must be called after lilv_world_load_specifications(). This is for hosts"]
#[doc = "that explicitly load specific bundles, its use is not necessary when using"]
#[doc = "lilv_world_load_all()."]
pub fn lilv_world_load_plugin_classes(world: *mut LilvWorld);
}
extern "C" {
#[doc = "Unload a specific bundle."]
#[doc = ""]
#[doc = "This unloads statements loaded by lilv_world_load_bundle(). Note that this"]
#[doc = "is not necessarily all information loaded from the bundle. If any resources"]
#[doc = "have been separately loaded with lilv_world_load_resource(), they must be"]
#[doc = "separately unloaded with lilv_world_unload_resource()."]
pub fn lilv_world_unload_bundle(
world: *mut LilvWorld,
bundle_uri: *const LilvNode,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = "Load all the data associated with the given `resource`."]
#[doc = "@param world The world."]
#[doc = "@param resource Must be a subject (i.e. a URI or a blank node)."]
#[doc = "@return The number of files parsed, or -1 on error"]
#[doc = ""]
#[doc = "All accessible data files linked to `resource` with rdfs:seeAlso will be"]
#[doc = "loaded into the world model."]
pub fn lilv_world_load_resource(
world: *mut LilvWorld,
resource: *const LilvNode,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = "Unload all the data associated with the given `resource`."]
#[doc = "@param world The world."]
#[doc = "@param resource Must be a subject (i.e. a URI or a blank node)."]
#[doc = ""]
#[doc = "This unloads all data loaded by a previous call to"]
#[doc = "lilv_world_load_resource() with the given `resource`."]
pub fn lilv_world_unload_resource(
world: *mut LilvWorld,
resource: *const LilvNode,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = "Get the parent of all other plugin classes, lv2:Plugin."]
pub fn lilv_world_get_plugin_class(world: *const LilvWorld) -> *const LilvPluginClass;
}
extern "C" {
#[doc = "Return a list of all found plugin classes."]
#[doc = "Returned list is owned by world and must not be freed by the caller."]
pub fn lilv_world_get_plugin_classes(world: *const LilvWorld) -> *const LilvPluginClasses;
}
extern "C" {
#[doc = "Return a list of all found plugins."]
#[doc = "The returned list contains just enough references to query"]
#[doc = "or instantiate plugins. The data for a particular plugin will not be"]
#[doc = "loaded into memory until a call to an lilv_plugin_* function results in"]
#[doc = "a query (at which time the data is cached with the LilvPlugin so future"]
#[doc = "queries are very fast)."]
#[doc = ""]
#[doc = "The returned list and the plugins it contains are owned by `world`"]
#[doc = "and must not be freed by caller."]
pub fn lilv_world_get_all_plugins(world: *const LilvWorld) -> *const LilvPlugins;
}
extern "C" {
#[doc = "Find nodes matching a triple pattern."]
#[doc = "Either `subject` or `object` may be NULL (i.e. a wildcard), but not both."]
#[doc = "@return All matches for the wildcard field, or NULL."]
pub fn lilv_world_find_nodes(
world: *mut LilvWorld,
subject: *const LilvNode,
predicate: *const LilvNode,
object: *const LilvNode,
) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Find a single node that matches a pattern."]
#[doc = "Exactly one of `subject`, `predicate`, `object` must be NULL."]
#[doc = "This function is equivalent to"]
#[doc = "lilv_nodes_get_first(lilv_world_find_nodes(...)) but simplifies the common"]
#[doc = "case of only wanting a single value."]
#[doc = "@return the first matching node, or NULL if no matches are found."]
pub fn lilv_world_get(
world: *mut LilvWorld,
subject: *const LilvNode,
predicate: *const LilvNode,
object: *const LilvNode,
) -> *mut LilvNode;
}
extern "C" {
#[doc = "Return true iff a statement matching a certain pattern exists."]
#[doc = ""]
#[doc = "This is useful for checking if particular statement exists without having to"]
#[doc = "bother with collections and memory management."]
#[doc = ""]
#[doc = "@param world The world."]
#[doc = "@param subject Subject of statement, or NULL for anything."]
#[doc = "@param predicate Predicate (key) of statement, or NULL for anything."]
#[doc = "@param object Object (value) of statement, or NULL for anything."]
pub fn lilv_world_ask(
world: *mut LilvWorld,
subject: *const LilvNode,
predicate: *const LilvNode,
object: *const LilvNode,
) -> bool;
}
extern "C" {
#[doc = "Get an LV2 symbol for some subject."]
#[doc = ""]
#[doc = "This will return the lv2:symbol property of the subject if it is given"]
#[doc = "explicitly, and otherwise will attempt to derive a symbol from the URI."]
#[doc = "@return A string node that is a valid LV2 symbol, or NULL on error."]
pub fn lilv_world_get_symbol(world: *mut LilvWorld, subject: *const LilvNode) -> *mut LilvNode;
}
extern "C" {
#[doc = "Check if `plugin` is valid."]
#[doc = "This is not a rigorous validator, but can be used to reject some malformed"]
#[doc = "plugins that could cause bugs (e.g. plugins with missing required fields)."]
#[doc = ""]
#[doc = "Note that normal hosts do NOT need to use this - lilv does not"]
#[doc = "load invalid plugins into plugin lists. This is included for plugin"]
#[doc = "testing utilities, etc."]
#[doc = "@return true iff `plugin` is valid."]
pub fn lilv_plugin_verify(plugin: *const LilvPlugin) -> bool;
}
extern "C" {
#[doc = "Get the URI of `plugin`."]
#[doc = "Any serialization that refers to plugins should refer to them by this."]
#[doc = "Hosts SHOULD NOT save any filesystem paths, plugin indexes, etc. in saved"]
#[doc = "files; save only the URI."]
#[doc = ""]
#[doc = "The URI is a globally unique identifier for one specific plugin. Two"]
#[doc = "plugins with the same URI are compatible in port signature, and should"]
#[doc = "be guaranteed to work in a compatible and consistent way. If a plugin"]
#[doc = "is upgraded in an incompatible way (eg if it has different ports), it"]
#[doc = "MUST have a different URI than it\'s predecessor."]
#[doc = ""]
#[doc = "@return A shared URI value which must not be modified or freed."]
pub fn lilv_plugin_get_uri(plugin: *const LilvPlugin) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the (resolvable) URI of the plugin\'s \"main\" bundle."]
#[doc = "This returns the URI of the bundle where the plugin itself was found. Note"]
#[doc = "that the data for a plugin may be spread over many bundles, that is,"]
#[doc = "lilv_plugin_get_data_uris() may return URIs which are not within this"]
#[doc = "bundle."]
#[doc = ""]
#[doc = "Typical hosts should not need to use this function."]
#[doc = "Note this always returns a fully qualified URI. If you want a local"]
#[doc = "filesystem path, use lilv_file_uri_parse()."]
#[doc = "@return a shared string which must not be modified or freed."]
pub fn lilv_plugin_get_bundle_uri(plugin: *const LilvPlugin) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the (resolvable) URIs of the RDF data files that define a plugin."]
#[doc = "Typical hosts should not need to use this function."]
#[doc = "Note this always returns fully qualified URIs. If you want local"]
#[doc = "filesystem paths, use lilv_file_uri_parse()."]
#[doc = "@return a list of complete URLs eg. \"file:///foo/ABundle.lv2/aplug.ttl\","]
#[doc = "which is shared and must not be modified or freed."]
pub fn lilv_plugin_get_data_uris(plugin: *const LilvPlugin) -> *const LilvNodes;
}
extern "C" {
#[doc = "Get the (resolvable) URI of the shared library for `plugin`."]
#[doc = "Note this always returns a fully qualified URI. If you want a local"]
#[doc = "filesystem path, use lilv_file_uri_parse()."]
#[doc = "@return a shared string which must not be modified or freed."]
pub fn lilv_plugin_get_library_uri(plugin: *const LilvPlugin) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the name of `plugin`."]
#[doc = "This returns the name (doap:name) of the plugin. The name may be"]
#[doc = "translated according to the current locale, this value MUST NOT be used"]
#[doc = "as a plugin identifier (use the URI for that)."]
#[doc = "Returned value must be freed by the caller."]
pub fn lilv_plugin_get_name(plugin: *const LilvPlugin) -> *mut LilvNode;
}
extern "C" {
#[doc = "Get the class this plugin belongs to (e.g. Filters)."]
pub fn lilv_plugin_get_class(plugin: *const LilvPlugin) -> *const LilvPluginClass;
}
extern "C" {
#[doc = "Get a value associated with the plugin in a plugin\'s data files."]
#[doc = "`predicate` must be either a URI or a QName."]
#[doc = ""]
#[doc = "Returns the ?object of all triples found of the form:"]
#[doc = ""]
#[doc = "<code><plugin-uri> predicate ?object</code>"]
#[doc = ""]
#[doc = "May return NULL if the property was not found, or if object(s) is not"]
#[doc = "sensibly represented as a LilvNodes (e.g. blank nodes)."]
#[doc = "Return value must be freed by caller with lilv_nodes_free()."]
pub fn lilv_plugin_get_value(
plugin: *const LilvPlugin,
predicate: *const LilvNode,
) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Return whether a feature is supported by a plugin."]
#[doc = "This will return true if the feature is an optional or required feature"]
#[doc = "of the plugin."]
pub fn lilv_plugin_has_feature(plugin: *const LilvPlugin, feature: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Get the LV2 Features supported (required or optionally) by a plugin."]
#[doc = "A feature is \"supported\" by a plugin if it is required OR optional."]
#[doc = ""]
#[doc = "Since required features have special rules the host must obey, this function"]
#[doc = "probably shouldn\'t be used by normal hosts. Using lilv_plugin_get_optional_features()"]
#[doc = "and lilv_plugin_get_required_features() separately is best in most cases."]
#[doc = ""]
#[doc = "Returned value must be freed by caller with lilv_nodes_free()."]
pub fn lilv_plugin_get_supported_features(plugin: *const LilvPlugin) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Get the LV2 Features required by a plugin."]
#[doc = "If a feature is required by a plugin, hosts MUST NOT use the plugin if they do not"]
#[doc = "understand (or are unable to support) that feature."]
#[doc = ""]
#[doc = "All values returned here MUST be passed to the plugin\'s instantiate method"]
#[doc = "(along with data, if necessary, as defined by the feature specification)"]
#[doc = "or plugin instantiation will fail."]
#[doc = ""]
#[doc = "Return value must be freed by caller with lilv_nodes_free()."]
pub fn lilv_plugin_get_required_features(plugin: *const LilvPlugin) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Get the LV2 Features optionally supported by a plugin."]
#[doc = "Hosts MAY ignore optional plugin features for whatever reasons. Plugins"]
#[doc = "MUST operate (at least somewhat) if they are instantiated without being"]
#[doc = "passed optional features."]
#[doc = ""]
#[doc = "Return value must be freed by caller with lilv_nodes_free()."]
pub fn lilv_plugin_get_optional_features(plugin: *const LilvPlugin) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Return whether or not a plugin provides a specific extension data."]
pub fn lilv_plugin_has_extension_data(plugin: *const LilvPlugin, uri: *const LilvNode) -> bool;
}
extern "C" {
#[doc = "Get a sequence of all extension data provided by a plugin."]
#[doc = "This can be used to find which URIs lilv_instance_get_extension_data()"]
#[doc = "will return a value for without instantiating the plugin."]
pub fn lilv_plugin_get_extension_data(plugin: *const LilvPlugin) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Get the number of ports on this plugin."]
pub fn lilv_plugin_get_num_ports(plugin: *const LilvPlugin) -> u32;
}
extern "C" {
#[doc = "Get the port ranges (minimum, maximum and default values) for all ports."]
#[doc = "`min_values`, `max_values` and `def_values` must either point to an array"]
#[doc = "of N floats, where N is the value returned by lilv_plugin_get_num_ports()"]
#[doc = "for this plugin, or NULL. The elements of the array will be set to the"]
#[doc = "the minimum, maximum and default values of the ports on this plugin,"]
#[doc = "with array index corresponding to port index. If a port doesn\'t have a"]
#[doc = "minimum, maximum or default value, or the port\'s type is not float, the"]
#[doc = "corresponding array element will be set to NAN."]
#[doc = ""]
#[doc = "This is a convenience method for the common case of getting the range of"]
#[doc = "all float ports on a plugin, and may be significantly faster than"]
#[doc = "repeated calls to lilv_port_get_range()."]
pub fn lilv_plugin_get_port_ranges_float(
plugin: *const LilvPlugin,
min_values: *mut f32,
max_values: *mut f32,
def_values: *mut f32,
);
}
extern "C" {
#[doc = "Get the number of ports on this plugin that are members of some class(es)."]
#[doc = "Note that this is a varargs function so ports fitting any type \'profile\'"]
#[doc = "desired can be found quickly. REMEMBER TO TERMINATE THE PARAMETER LIST"]
#[doc = "OF THIS FUNCTION WITH NULL OR VERY NASTY THINGS WILL HAPPEN."]
pub fn lilv_plugin_get_num_ports_of_class(
plugin: *const LilvPlugin,
class_1: *const LilvNode,
...
) -> u32;
}
extern "C" {
#[doc = "Variant of lilv_plugin_get_num_ports_of_class() that takes a va_list."]
#[doc = ""]
#[doc = "This function calls va_arg() on `args` but does not call va_end()."]
pub fn lilv_plugin_get_num_ports_of_class_va(
plugin: *const LilvPlugin,
class_1: *const LilvNode,
args: *mut __va_list_tag,
) -> u32;
}
extern "C" {
#[doc = "Return whether or not the plugin introduces (and reports) latency."]
#[doc = "The index of the latency port can be found with"]
#[doc = "lilv_plugin_get_latency_port() ONLY if this function returns true."]
pub fn lilv_plugin_has_latency(plugin: *const LilvPlugin) -> bool;
}
extern "C" {
#[doc = "Return the index of the plugin\'s latency port."]
#[doc = "It is a fatal error to call this on a plugin without checking if the port"]
#[doc = "exists by first calling lilv_plugin_has_latency()."]
#[doc = ""]
#[doc = "Any plugin that introduces unwanted latency that should be compensated for"]
#[doc = "(by hosts with the ability/need) MUST provide this port, which is a control"]
#[doc = "rate output port that reports the latency for each cycle in frames."]
pub fn lilv_plugin_get_latency_port_index(plugin: *const LilvPlugin) -> u32;
}
extern "C" {
#[doc = "Get a port on `plugin` by `index`."]
pub fn lilv_plugin_get_port_by_index(plugin: *const LilvPlugin, index: u32) -> *const LilvPort;
}
extern "C" {
#[doc = "Get a port on `plugin` by `symbol`."]
#[doc = "Note this function is slower than lilv_plugin_get_port_by_index(),"]
#[doc = "especially on plugins with a very large number of ports."]
pub fn lilv_plugin_get_port_by_symbol(
plugin: *const LilvPlugin,
symbol: *const LilvNode,
) -> *const LilvPort;
}
extern "C" {
#[doc = "Get a port on `plugin` by its lv2:designation."]
#[doc = ""]
#[doc = "The designation of a port describes the meaning, assignment, allocation or"]
#[doc = "role of the port, e.g. \"left channel\" or \"gain\". If found, the port with"]
#[doc = "matching `port_class` and `designation` is be returned, otherwise NULL is"]
#[doc = "returned. The `port_class` can be used to distinguish the input and output"]
#[doc = "ports for a particular designation. If `port_class` is NULL, any port with"]
#[doc = "the given designation will be returned."]
pub fn lilv_plugin_get_port_by_designation(
plugin: *const LilvPlugin,
port_class: *const LilvNode,
designation: *const LilvNode,
) -> *const LilvPort;
}
extern "C" {
#[doc = "Get the project the plugin is a part of."]
#[doc = ""]
#[doc = "More information about the project can be read via lilv_world_find_nodes(),"]
#[doc = "typically using properties from DOAP (e.g. doap:name)."]
pub fn lilv_plugin_get_project(plugin: *const LilvPlugin) -> *mut LilvNode;
}
extern "C" {
#[doc = "Get the full name of the plugin\'s author."]
#[doc = "Returns NULL if author name is not present."]
#[doc = "Returned value must be freed by caller."]
pub fn lilv_plugin_get_author_name(plugin: *const LilvPlugin) -> *mut LilvNode;
}
extern "C" {
#[doc = "Get the email address of the plugin\'s author."]
#[doc = "Returns NULL if author email address is not present."]
#[doc = "Returned value must be freed by caller."]
pub fn lilv_plugin_get_author_email(plugin: *const LilvPlugin) -> *mut LilvNode;
}
extern "C" {
#[doc = "Get the address of the plugin author\'s home page."]
#[doc = "Returns NULL if author homepage is not present."]
#[doc = "Returned value must be freed by caller."]
pub fn lilv_plugin_get_author_homepage(plugin: *const LilvPlugin) -> *mut LilvNode;
}
extern "C" {
#[doc = "Return true iff `plugin` has been replaced by another plugin."]
#[doc = ""]
#[doc = "The plugin will still be usable, but hosts should hide them from their"]
#[doc = "user interfaces to prevent users from using deprecated plugins."]
pub fn lilv_plugin_is_replaced(plugin: *const LilvPlugin) -> bool;
}
extern "C" {
#[doc = "Write the Turtle description of `plugin` to `plugin_file`."]
#[doc = ""]
#[doc = "This function is particularly useful for porting plugins in conjunction with"]
#[doc = "an LV2 bridge such as NASPRO."]
pub fn lilv_plugin_write_description(
world: *mut LilvWorld,
plugin: *const LilvPlugin,
base_uri: *const LilvNode,
plugin_file: *mut FILE,
);
}
extern "C" {
#[doc = "Write a manifest entry for `plugin` to `manifest_file`."]
#[doc = ""]
#[doc = "This function is intended for use with lilv_plugin_write_description() to"]
#[doc = "write a complete description of a plugin to a bundle."]
pub fn lilv_plugin_write_manifest_entry(
world: *mut LilvWorld,
plugin: *const LilvPlugin,
base_uri: *const LilvNode,
manifest_file: *mut FILE,
plugin_file_path: *const ::std::os::raw::c_char,
);
}
extern "C" {
#[doc = "Get the resources related to `plugin` with lv2:appliesTo."]
#[doc = ""]
#[doc = "Some plugin-related resources are not linked directly to the plugin with"]
#[doc = "rdfs:seeAlso and thus will not be automatically loaded along with the plugin"]
#[doc = "data (usually for performance reasons). All such resources of the given @c"]
#[doc = "type related to `plugin` can be accessed with this function."]
#[doc = ""]
#[doc = "If `type` is NULL, all such resources will be returned, regardless of type."]
#[doc = ""]
#[doc = "To actually load the data for each returned resource, use"]
#[doc = "lilv_world_load_resource()."]
pub fn lilv_plugin_get_related(
plugin: *const LilvPlugin,
type_: *const LilvNode,
) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Get the RDF node of `port`."]
#[doc = ""]
#[doc = "Ports nodes may be may be URIs or blank nodes."]
#[doc = ""]
#[doc = "@return A shared node which must not be modified or freed."]
pub fn lilv_port_get_node(plugin: *const LilvPlugin, port: *const LilvPort) -> *const LilvNode;
}
extern "C" {
#[doc = "Port analog of lilv_plugin_get_value()."]
pub fn lilv_port_get_value(
plugin: *const LilvPlugin,
port: *const LilvPort,
predicate: *const LilvNode,
) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Get a single property value of a port."]
#[doc = ""]
#[doc = "This is equivalent to lilv_nodes_get_first(lilv_port_get_value(...)) but is"]
#[doc = "simpler to use in the common case of only caring about one value. The"]
#[doc = "caller is responsible for freeing the returned node."]
pub fn lilv_port_get(
plugin: *const LilvPlugin,
port: *const LilvPort,
predicate: *const LilvNode,
) -> *mut LilvNode;
}
extern "C" {
#[doc = "Return the LV2 port properties of a port."]
pub fn lilv_port_get_properties(
plugin: *const LilvPlugin,
port: *const LilvPort,
) -> *mut LilvNodes;
}
extern "C" {
#[doc = "Return whether a port has a certain property."]
pub fn lilv_port_has_property(
plugin: *const LilvPlugin,
port: *const LilvPort,
property: *const LilvNode,
) -> bool;
}
extern "C" {
#[doc = "Return whether a port supports a certain event type."]
#[doc = ""]
#[doc = "More precisely, this returns true iff the port has an atom:supports or an"]
#[doc = "ev:supportsEvent property with `event_type` as the value."]
pub fn lilv_port_supports_event(
plugin: *const LilvPlugin,
port: *const LilvPort,
event_type: *const LilvNode,
) -> bool;
}
extern "C" {
#[doc = "Get the index of a port."]
#[doc = "The index is only valid for the life of the plugin and may change between"]
#[doc = "versions. For a stable identifier, use the symbol."]
pub fn lilv_port_get_index(plugin: *const LilvPlugin, port: *const LilvPort) -> u32;
}
extern "C" {
#[doc = "Get the symbol of a port."]
#[doc = "The \'symbol\' is a short string, a valid C identifier."]
#[doc = "Returned value is owned by `port` and must not be freed."]
pub fn lilv_port_get_symbol(
plugin: *const LilvPlugin,
port: *const LilvPort,
) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the name of a port."]
#[doc = "This is guaranteed to return the untranslated name (the doap:name in the"]
#[doc = "data file without a language tag). Returned value must be freed by"]
#[doc = "the caller."]
pub fn lilv_port_get_name(plugin: *const LilvPlugin, port: *const LilvPort) -> *mut LilvNode;
}
extern "C" {
#[doc = "Get all the classes of a port."]
#[doc = "This can be used to determine if a port is an input, output, audio,"]
#[doc = "control, midi, etc, etc, though it\'s simpler to use lilv_port_is_a()."]
#[doc = "The returned list does not include lv2:Port, which is implied."]
#[doc = "Returned value is shared and must not be destroyed by caller."]
pub fn lilv_port_get_classes(
plugin: *const LilvPlugin,
port: *const LilvPort,
) -> *const LilvNodes;
}
extern "C" {
#[doc = "Determine if a port is of a given class (input, output, audio, etc)."]
#[doc = "For convenience/performance/extensibility reasons, hosts are expected to"]
#[doc = "create a LilvNode for each port class they \"care about\". Well-known type"]
#[doc = "URI strings are defined (e.g. LILV_URI_INPUT_PORT) for convenience, but"]
#[doc = "this function is designed so that Lilv is usable with any port types"]
#[doc = "without requiring explicit support in Lilv."]
pub fn lilv_port_is_a(
plugin: *const LilvPlugin,
port: *const LilvPort,
port_class: *const LilvNode,
) -> bool;
}
extern "C" {
#[doc = "Get the default, minimum, and maximum values of a port."]
#[doc = ""]
#[doc = "`def`, `min`, and `max` are outputs, pass pointers to uninitialized"]
#[doc = "LilvNode* variables. These will be set to point at new values (which must"]
#[doc = "be freed by the caller using lilv_node_free()), or NULL if the value does"]
#[doc = "not exist."]
pub fn lilv_port_get_range(
plugin: *const LilvPlugin,
port: *const LilvPort,
def: *mut *mut LilvNode,
min: *mut *mut LilvNode,
max: *mut *mut LilvNode,
);
}
extern "C" {
#[doc = "Get the scale points (enumeration values) of a port."]
#[doc = "This returns a collection of \'interesting\' named values of a port"]
#[doc = "(e.g. appropriate entries for a UI selector associated with this port)."]
#[doc = "Returned value may be NULL if `port` has no scale points, otherwise it"]
#[doc = "must be freed by caller with lilv_scale_points_free()."]
pub fn lilv_port_get_scale_points(
plugin: *const LilvPlugin,
port: *const LilvPort,
) -> *mut LilvScalePoints;
}
extern "C" {
#[doc = "Load a state snapshot from the world RDF model."]
#[doc = "This function can be used to load the default state of a plugin by passing"]
#[doc = "the plugin URI as the `subject` parameter."]
#[doc = "@param world The world."]
#[doc = "@param map URID mapper."]
#[doc = "@param node The subject of the state description (e.g. a preset URI)."]
#[doc = "@return A new LilvState which must be freed with lilv_state_free(), or NULL."]
pub fn lilv_state_new_from_world(
world: *mut LilvWorld,
map: *mut LV2_URID_Map,
node: *const LilvNode,
) -> *mut LilvState;
}
extern "C" {
#[doc = "Load a state snapshot from a file."]
#[doc = "@param world The world."]
#[doc = "@param map URID mapper."]
#[doc = "@param subject The subject of the state description (e.g. a preset URI)."]
#[doc = "@param path The path of the file containing the state description."]
#[doc = "@return A new LilvState which must be freed with lilv_state_free()."]
#[doc = ""]
#[doc = "If `subject` is NULL, it is taken to be the URI of the file (i.e."]
#[doc = "\"<>\" in Turtle)."]
#[doc = ""]
#[doc = "This function parses the file separately to create the state, it does not"]
#[doc = "parse the file into the world model, i.e. the returned state is the only"]
#[doc = "new memory consumed once this function returns."]
pub fn lilv_state_new_from_file(
world: *mut LilvWorld,
map: *mut LV2_URID_Map,
subject: *const LilvNode,
path: *const ::std::os::raw::c_char,
) -> *mut LilvState;
}
extern "C" {
#[doc = "Load a state snapshot from a string made by lilv_state_to_string()."]
pub fn lilv_state_new_from_string(
world: *mut LilvWorld,
map: *mut LV2_URID_Map,
str: *const ::std::os::raw::c_char,
) -> *mut LilvState;
}
#[doc = "Function to get a port value."]
#[doc = "@param port_symbol The symbol of the port."]
#[doc = "@param user_data The user_data passed to lilv_state_new_from_instance()."]
#[doc = "@param size (Output) The size of the returned value."]
#[doc = "@param type (Output) The URID of the type of the returned value."]
#[doc = "@return A pointer to the port value."]
#[doc = ""]
#[doc = "This function MUST set `size` and `type` appropriately."]
pub type LilvGetPortValueFunc = ::std::option::Option<
unsafe extern "C" fn(
port_symbol: *const ::std::os::raw::c_char,
user_data: *mut ::std::os::raw::c_void,
size: *mut u32,
type_: *mut u32,
) -> *const ::std::os::raw::c_void,
>;
extern "C" {
#[doc = "Create a new state snapshot from a plugin instance."]
#[doc = ""]
#[doc = "@param plugin The plugin this state applies to."]
#[doc = ""]
#[doc = "@param instance An instance of `plugin`."]
#[doc = ""]
#[doc = "@param map The map to use for mapping URIs in state."]
#[doc = ""]
#[doc = "@param file_dir Directory of files created by the plugin earlier (or NULL)."]
#[doc = "This is for hosts that support file creation at any time with state"]
#[doc = "state:makePath. These files will be copied as necessary to `copy_dir` and"]
#[doc = "not be referred to directly in state (a temporary directory is appropriate)."]
#[doc = ""]
#[doc = "@param copy_dir Directory of copies of files in `file_dir` (or NULL). This"]
#[doc = "directory will have the same structure as `file_dir` but with possibly"]
#[doc = "modified file names to distinguish different revisions. If you only care"]
#[doc = "about saving one state snapshot, it can be the same as `save_dir`. Plugin"]
#[doc = "state will refer to files in this directory."]
#[doc = ""]
#[doc = "@param save_dir Directory of files created by plugin during save (or NULL)."]
#[doc = "If the state will be saved, this should be the bundle directory later passed"]
#[doc = "to lilv_state_save()."]
#[doc = ""]
#[doc = "@param get_value Function to get port values (or NULL). If NULL, the"]
#[doc = "returned state will not represent port values. This should only be NULL in"]
#[doc = "hosts that save and restore port values via some other mechanism."]
#[doc = ""]
#[doc = "@param user_data User data to pass to `get_value`."]
#[doc = ""]
#[doc = "@param link_dir Directory of links to external files (or NULL). A link will"]
#[doc = "be made in this directory to any external files referred to in plugin state."]
#[doc = "In turn, links will be created in the save directory to these links (e.g."]
#[doc = "save_dir/file => link_dir/file => /foo/bar/file). This allows many state"]
#[doc = "snapshots to share a single link to an external file, so archival"]
#[doc = "(e.g. with tar -h) will not create several copies of the file. If this is"]
#[doc = "not required, it can be the same as save_dir."]
#[doc = ""]
#[doc = "@param flags Bitwise OR of LV2_State_Flags values."]
#[doc = ""]
#[doc = "@param features Features to pass LV2_State_Interface.save()."]
#[doc = ""]
#[doc = "@return A new LilvState which must be freed with lilv_state_free()."]
#[doc = ""]
#[doc = "This function may be called simultaneously with any instance function"]
#[doc = "(except discovery functions) unless the threading class of that function"]
#[doc = "explicitly disallows this."]
#[doc = ""]
#[doc = "To support advanced file functionality, there are several directory"]
#[doc = "parameters. Simple hosts that only wish to save a single plugins state once"]
#[doc = "may simply use the same directory for all of them (or pass NULL to not"]
#[doc = "support files at all). The multiple parameters are necessary to support"]
#[doc = "saving an instances state many times while avoiding any duplication of data."]
#[doc = ""]
#[doc = "If supported (via state:makePath passed to LV2_Descriptor::instantiate()),"]
#[doc = "`file_dir` should be the directory where any files created by the plugin"]
#[doc = "(not during save time, e.g. during instantiation) are stored. These files"]
#[doc = "will be copied to preserve their state at this time.plugin-created files are stored."]
#[doc = "Lilv will assume any files within this directory (recursively) are created"]
#[doc = "by the plugin and all other files are immutable. Note that this function"]
#[doc = "does not save the state, use lilv_state_save() for that."]
#[doc = ""]
#[doc = "See <a href=\"http://lv2plug.in/ns/ext/state/state.h\">state.h</a> from the"]
#[doc = "LV2 State extension for details on the `flags` and `features` parameters."]
pub fn lilv_state_new_from_instance(
plugin: *const LilvPlugin,
instance: *mut LilvInstance,
map: *mut LV2_URID_Map,
file_dir: *const ::std::os::raw::c_char,
copy_dir: *const ::std::os::raw::c_char,
link_dir: *const ::std::os::raw::c_char,
save_dir: *const ::std::os::raw::c_char,
get_value: LilvGetPortValueFunc,
user_data: *mut ::std::os::raw::c_void,
flags: u32,
features: *const *const LV2_Feature,
) -> *mut LilvState;
}
extern "C" {
#[doc = "Free `state`."]
pub fn lilv_state_free(state: *mut LilvState);
}
extern "C" {
#[doc = "Return true iff `a` is equivalent to `b`."]
pub fn lilv_state_equals(a: *const LilvState, b: *const LilvState) -> bool;
}
extern "C" {
#[doc = "Return the number of properties in `state`."]
pub fn lilv_state_get_num_properties(state: *const LilvState) -> ::std::os::raw::c_uint;
}
extern "C" {
#[doc = "Get the URI of the plugin `state` applies to."]
pub fn lilv_state_get_plugin_uri(state: *const LilvState) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the URI of `state`."]
#[doc = ""]
#[doc = "This may return NULL if the state has not been saved and has no URI."]
pub fn lilv_state_get_uri(state: *const LilvState) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the label of `state`."]
pub fn lilv_state_get_label(state: *const LilvState) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Set the label of `state`."]
pub fn lilv_state_set_label(state: *mut LilvState, label: *const ::std::os::raw::c_char);
}
extern "C" {
#[doc = "Set a metadata property on `state`."]
#[doc = "@param state The state to set the metadata for."]
#[doc = "@param key The key to store `value` under (URID)."]
#[doc = "@param value Pointer to the value to be stored."]
#[doc = "@param size The size of `value` in bytes."]
#[doc = "@param type The type of `value` (URID)."]
#[doc = "@param flags LV2_State_Flags for `value`."]
#[doc = "@return 0 on success."]
#[doc = ""]
#[doc = "This is a generic version of lilv_state_set_label(), which sets metadata"]
#[doc = "properties visible to hosts, but not plugins. This allows storing useful"]
#[doc = "information such as comments or preset banks."]
pub fn lilv_state_set_metadata(
state: *mut LilvState,
key: u32,
value: *const ::std::os::raw::c_void,
size: usize,
type_: u32,
flags: u32,
) -> ::std::os::raw::c_int;
}
#[doc = "Function to set a port value."]
#[doc = "@param port_symbol The symbol of the port."]
#[doc = "@param user_data The user_data passed to lilv_state_restore()."]
#[doc = "@param size The size of `value`."]
#[doc = "@param type The URID of the type of `value`."]
#[doc = "@param value A pointer to the port value."]
pub type LilvSetPortValueFunc = ::std::option::Option<
unsafe extern "C" fn(
port_symbol: *const ::std::os::raw::c_char,
user_data: *mut ::std::os::raw::c_void,
value: *const ::std::os::raw::c_void,
size: u32,
type_: u32,
),
>;
extern "C" {
#[doc = "Enumerate the port values in a state snapshot."]
#[doc = "@param state The state to retrieve port values from."]
#[doc = "@param set_value A function to receive port values."]
#[doc = "@param user_data User data to pass to `set_value`."]
#[doc = ""]
#[doc = "This function is a subset of lilv_state_restore() that only fires the"]
#[doc = "`set_value` callback and does not directly affect a plugin instance. This"]
#[doc = "is useful in hosts that need to retrieve the port values in a state snapshot"]
#[doc = "for special handling."]
pub fn lilv_state_emit_port_values(
state: *const LilvState,
set_value: LilvSetPortValueFunc,
user_data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = "Restore a plugin instance from a state snapshot."]
#[doc = "@param state The state to restore, which must apply to the correct plugin."]
#[doc = "@param instance An instance of the plugin `state` applies to, or NULL."]
#[doc = "@param set_value A function to set a port value (may be NULL)."]
#[doc = "@param user_data User data to pass to `set_value`."]
#[doc = "@param flags Bitwise OR of LV2_State_Flags values."]
#[doc = "@param features Features to pass LV2_State_Interface.restore()."]
#[doc = ""]
#[doc = "This will set all the properties of `instance`, if given, to the values"]
#[doc = "stored in `state`. If `set_value` is provided, it will be called (with the"]
#[doc = "given `user_data`) to restore each port value, otherwise the host must"]
#[doc = "restore the port values itself (using lilv_state_get_port_value()) in order"]
#[doc = "to completely restore `state`."]
#[doc = ""]
#[doc = "If the state has properties and `instance` is given, this function is in"]
#[doc = "the \"instantiation\" threading class, i.e. it MUST NOT be called"]
#[doc = "simultaneously with any function on the same plugin instance. If the state"]
#[doc = "has no properties, only port values are set via `set_value`."]
#[doc = ""]
#[doc = "See <a href=\"http://lv2plug.in/ns/ext/state/state.h\">state.h</a> from the"]
#[doc = "LV2 State extension for details on the `flags` and `features` parameters."]
pub fn lilv_state_restore(
state: *const LilvState,
instance: *mut LilvInstance,
set_value: LilvSetPortValueFunc,
user_data: *mut ::std::os::raw::c_void,
flags: u32,
features: *const *const LV2_Feature,
);
}
extern "C" {
#[doc = "Save state to a file."]
#[doc = "@param world The world."]
#[doc = "@param map URID mapper."]
#[doc = "@param unmap URID unmapper."]
#[doc = "@param state State to save."]
#[doc = "@param uri URI of state, may be NULL."]
#[doc = "@param dir Path of the bundle directory to save into."]
#[doc = "@param filename Path of the state file relative to `dir`."]
#[doc = ""]
#[doc = "The format of state on disk is compatible with that defined in the LV2"]
#[doc = "preset extension, i.e. this function may be used to save presets which can"]
#[doc = "be loaded by any host."]
#[doc = ""]
#[doc = "If `uri` is NULL, the preset URI will be a file URI, but the bundle"]
#[doc = "can safely be moved (i.e. the state file will use \"<>\" as the subject)."]
pub fn lilv_state_save(
world: *mut LilvWorld,
map: *mut LV2_URID_Map,
unmap: *mut LV2_URID_Unmap,
state: *const LilvState,
uri: *const ::std::os::raw::c_char,
dir: *const ::std::os::raw::c_char,
filename: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = "Save state to a string. This function does not use the filesystem."]
#[doc = ""]
#[doc = "@param world The world."]
#[doc = "@param map URID mapper."]
#[doc = "@param unmap URID unmapper."]
#[doc = "@param state The state to serialize."]
#[doc = "@param uri URI for the state description (mandatory)."]
#[doc = "@param base_uri Base URI for serialisation. Unless you know what you are"]
#[doc = "doing, pass NULL for this, otherwise the state may not be restorable via"]
#[doc = "lilv_state_new_from_string()."]
pub fn lilv_state_to_string(
world: *mut LilvWorld,
map: *mut LV2_URID_Map,
unmap: *mut LV2_URID_Unmap,
state: *const LilvState,
uri: *const ::std::os::raw::c_char,
base_uri: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[doc = "Unload a state from the world and delete all associated files."]
#[doc = "@param world The world."]
#[doc = "@param state State to remove from the system."]
#[doc = ""]
#[doc = "This function DELETES FILES/DIRECTORIES FROM THE FILESYSTEM! It is intended"]
#[doc = "for removing user-saved presets, but can delete any state the user has"]
#[doc = "permission to delete, including presets shipped with plugins."]
#[doc = ""]
#[doc = "The rdfs:seeAlso file for the state will be removed. The entry in the"]
#[doc = "bundle\'s manifest.ttl is removed, and if this results in an empty manifest,"]
#[doc = "then the manifest file is removed. If this results in an empty bundle, then"]
#[doc = "the bundle directory is removed as well."]
pub fn lilv_state_delete(
world: *mut LilvWorld,
state: *const LilvState,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = "Get the label of this scale point (enumeration value)"]
#[doc = "Returned value is owned by `point` and must not be freed."]
pub fn lilv_scale_point_get_label(point: *const LilvScalePoint) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the value of this scale point (enumeration value)"]
#[doc = "Returned value is owned by `point` and must not be freed."]
pub fn lilv_scale_point_get_value(point: *const LilvScalePoint) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the URI of this class\' superclass."]
#[doc = "Returned value is owned by `plugin_class` and must not be freed by caller."]
#[doc = "Returned value may be NULL, if class has no parent."]
pub fn lilv_plugin_class_get_parent_uri(
plugin_class: *const LilvPluginClass,
) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the URI of this plugin class."]
#[doc = "Returned value is owned by `plugin_class` and must not be freed by caller."]
pub fn lilv_plugin_class_get_uri(plugin_class: *const LilvPluginClass) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the label of this plugin class, ie \"Oscillators\"."]
#[doc = "Returned value is owned by `plugin_class` and must not be freed by caller."]
pub fn lilv_plugin_class_get_label(plugin_class: *const LilvPluginClass) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the subclasses of this plugin class."]
#[doc = "Returned value must be freed by caller with lilv_plugin_classes_free()."]
pub fn lilv_plugin_class_get_children(
plugin_class: *const LilvPluginClass,
) -> *mut LilvPluginClasses;
}
#[doc = "@cond LILV_DOCUMENT_INSTANCE_IMPL"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LilvInstanceImpl {
pub lv2_descriptor: *const LV2_Descriptor,
pub lv2_handle: LV2_Handle,
pub pimpl: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_LilvInstanceImpl() {
assert_eq!(
::std::mem::size_of::<LilvInstanceImpl>(),
24usize,
concat!("Size of: ", stringify!(LilvInstanceImpl))
);
assert_eq!(
::std::mem::align_of::<LilvInstanceImpl>(),
8usize,
concat!("Alignment of ", stringify!(LilvInstanceImpl))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<LilvInstanceImpl>())).lv2_descriptor as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(LilvInstanceImpl),
"::",
stringify!(lv2_descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<LilvInstanceImpl>())).lv2_handle as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(LilvInstanceImpl),
"::",
stringify!(lv2_handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<LilvInstanceImpl>())).pimpl as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(LilvInstanceImpl),
"::",
stringify!(pimpl)
)
);
}
extern "C" {
#[doc = "Instantiate a plugin."]
#[doc = "The returned value is a lightweight handle for an LV2 plugin instance,"]
#[doc = "it does not refer to `plugin`, or any other Lilv state. The caller must"]
#[doc = "eventually free it with lilv_instance_free()."]
#[doc = "`features` is a NULL-terminated array of features the host supports."]
#[doc = "NULL may be passed if the host supports no additional features."]
#[doc = "@return NULL if instantiation failed."]
pub fn lilv_plugin_instantiate(
plugin: *const LilvPlugin,
sample_rate: f64,
features: *const *const LV2_Feature,
) -> *mut LilvInstance;
}
extern "C" {
#[doc = "Free a plugin instance."]
#[doc = "It is safe to call this function on NULL."]
#[doc = "`instance` is invalid after this call."]
pub fn lilv_instance_free(instance: *mut LilvInstance);
}
extern "C" {
#[doc = "Get all UIs for `plugin`."]
#[doc = "Returned value must be freed by caller using lilv_uis_free()."]
pub fn lilv_plugin_get_uis(plugin: *const LilvPlugin) -> *mut LilvUIs;
}
extern "C" {
#[doc = "Get the URI of a Plugin UI."]
#[doc = "@param ui The Plugin UI"]
#[doc = "@return a shared value which must not be modified or freed."]
pub fn lilv_ui_get_uri(ui: *const LilvUI) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the types (URIs of RDF classes) of a Plugin UI."]
#[doc = "@param ui The Plugin UI"]
#[doc = "@return a shared value which must not be modified or freed."]
#[doc = ""]
#[doc = "Note that in most cases lilv_ui_is_supported() should be used, which avoids"]
#[doc = "the need to use this function (and type specific logic)."]
pub fn lilv_ui_get_classes(ui: *const LilvUI) -> *const LilvNodes;
}
extern "C" {
#[doc = "Check whether a plugin UI has a given type."]
#[doc = "@param ui The Plugin UI"]
#[doc = "@param class_uri The URI of the LV2 UI type to check this UI against"]
pub fn lilv_ui_is_a(ui: *const LilvUI, class_uri: *const LilvNode) -> bool;
}
#[doc = "Function to determine whether a UI type is supported."]
#[doc = ""]
#[doc = "This is provided by the user and must return non-zero iff using a UI of type"]
#[doc = "`ui_type_uri` in a container of type `container_type_uri` is supported."]
pub type LilvUISupportedFunc = ::std::option::Option<
unsafe extern "C" fn(
container_type_uri: *const ::std::os::raw::c_char,
ui_type_uri: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_uint,
>;
extern "C" {
#[doc = "Return true iff a Plugin UI is supported as a given widget type."]
#[doc = "@param ui The Plugin UI"]
#[doc = "@param supported_func User provided supported predicate."]
#[doc = "@param container_type The widget type to host the UI within."]
#[doc = "@param ui_type (Output) If non-NULL, set to the native type of the UI"]
#[doc = "which is owned by `ui` and must not be freed by the caller."]
#[doc = "@return The embedding quality level returned by `supported_func`."]
pub fn lilv_ui_is_supported(
ui: *const LilvUI,
supported_func: LilvUISupportedFunc,
container_type: *const LilvNode,
ui_type: *mut *const LilvNode,
) -> ::std::os::raw::c_uint;
}
extern "C" {
#[doc = "Get the URI for a Plugin UI\'s bundle."]
#[doc = "@param ui The Plugin UI"]
#[doc = "@return a shared value which must not be modified or freed."]
pub fn lilv_ui_get_bundle_uri(ui: *const LilvUI) -> *const LilvNode;
}
extern "C" {
#[doc = "Get the URI for a Plugin UI\'s shared library."]
#[doc = "@param ui The Plugin UI"]
#[doc = "@return a shared value which must not be modified or freed."]
pub fn lilv_ui_get_binary_uri(ui: *const LilvUI) -> *const LilvNode;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
assert_eq!(
::std::mem::size_of::<__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(__va_list_tag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}