/* automatically generated by rust-bindgen */

pub const NT_DEFAULT_PORT : u32 = 1735 ; 
 /// Typedefs 
 pub type NT_Bool = :: std :: os :: raw :: c_int ; pub type NT_Handle = :: std :: os :: raw :: c_uint ; pub type NT_ConnectionListener = NT_Handle ; pub type NT_ConnectionListenerPoller = NT_Handle ; pub type NT_Entry = NT_Handle ; pub type NT_EntryListener = NT_Handle ; pub type NT_EntryListenerPoller = NT_Handle ; pub type NT_Inst = NT_Handle ; pub type NT_Logger = NT_Handle ; pub type NT_LoggerPoller = NT_Handle ; pub type NT_RpcCall = NT_Handle ; pub type NT_RpcCallPoller = NT_Handle ; pub const NT_Type_NT_UNASSIGNED : NT_Type = 0 ; pub const NT_Type_NT_BOOLEAN : NT_Type = 1 ; pub const NT_Type_NT_DOUBLE : NT_Type = 2 ; pub const NT_Type_NT_STRING : NT_Type = 4 ; pub const NT_Type_NT_RAW : NT_Type = 8 ; pub const NT_Type_NT_BOOLEAN_ARRAY : NT_Type = 16 ; pub const NT_Type_NT_DOUBLE_ARRAY : NT_Type = 32 ; pub const NT_Type_NT_STRING_ARRAY : NT_Type = 64 ; pub const NT_Type_NT_RPC : NT_Type = 128 ; 
 /// NetworkTables data types. 
 pub type NT_Type = u32 ; pub const NT_EntryFlags_NT_PERSISTENT : NT_EntryFlags = 1 ; 
 /// NetworkTables entry flags. 
 pub type NT_EntryFlags = u32 ; pub const NT_LogLevel_NT_LOG_CRITICAL : NT_LogLevel = 50 ; pub const NT_LogLevel_NT_LOG_ERROR : NT_LogLevel = 40 ; pub const NT_LogLevel_NT_LOG_WARNING : NT_LogLevel = 30 ; pub const NT_LogLevel_NT_LOG_INFO : NT_LogLevel = 20 ; pub const NT_LogLevel_NT_LOG_DEBUG : NT_LogLevel = 10 ; pub const NT_LogLevel_NT_LOG_DEBUG1 : NT_LogLevel = 9 ; pub const NT_LogLevel_NT_LOG_DEBUG2 : NT_LogLevel = 8 ; pub const NT_LogLevel_NT_LOG_DEBUG3 : NT_LogLevel = 7 ; pub const NT_LogLevel_NT_LOG_DEBUG4 : NT_LogLevel = 6 ; 
 /// NetworkTables logging levels. 
 pub type NT_LogLevel = u32 ; pub const NT_NotifyKind_NT_NOTIFY_NONE : NT_NotifyKind = 0 ; pub const NT_NotifyKind_NT_NOTIFY_IMMEDIATE : NT_NotifyKind = 1 ; pub const NT_NotifyKind_NT_NOTIFY_LOCAL : NT_NotifyKind = 2 ; pub const NT_NotifyKind_NT_NOTIFY_NEW : NT_NotifyKind = 4 ; pub const NT_NotifyKind_NT_NOTIFY_DELETE : NT_NotifyKind = 8 ; pub const NT_NotifyKind_NT_NOTIFY_UPDATE : NT_NotifyKind = 16 ; pub const NT_NotifyKind_NT_NOTIFY_FLAGS : NT_NotifyKind = 32 ; 
 /// NetworkTables notifier kinds. 
 pub type NT_NotifyKind = u32 ; pub const NT_NetworkMode_NT_NET_MODE_NONE : NT_NetworkMode = 0 ; pub const NT_NetworkMode_NT_NET_MODE_SERVER : NT_NetworkMode = 1 ; pub const NT_NetworkMode_NT_NET_MODE_CLIENT : NT_NetworkMode = 2 ; pub const NT_NetworkMode_NT_NET_MODE_STARTING : NT_NetworkMode = 4 ; pub const NT_NetworkMode_NT_NET_MODE_FAILURE : NT_NetworkMode = 8 ; 
 /// Client/server modes 
 pub type NT_NetworkMode = u32 ; 
 /// A NetworkTables string. 
 # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_String { 
 /// String contents (UTF-8).
    /// The string is NOT required to be zero-terminated.
    /// When returned by the library, this is zero-terminated and allocated with
    /// std::malloc(). 
 pub str : * mut :: std :: os :: raw :: c_char , 
 /// Length of the string in bytes.  If the string happens to be zero
    /// terminated, this does not include the zero-termination. 
 pub len : usize , } # [ test ] fn bindgen_test_layout_NT_String ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_String > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( NT_String ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_String > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_String ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_String > ( ) ) ) . str as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_String ) , "::" , stringify ! ( str ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_String > ( ) ) ) . len as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_String ) , "::" , stringify ! ( len ) ) ) ; } 
 /// NetworkTables Entry Value.  Note this is a typed union. 
 # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct NT_Value { pub type_ : NT_Type , pub last_change : u64 , pub data : NT_Value__bindgen_ty_1 , } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union NT_Value__bindgen_ty_1 { pub v_boolean : NT_Bool , pub v_double : f64 , pub v_string : NT_String , pub v_raw : NT_String , pub arr_boolean : NT_Value__bindgen_ty_1__bindgen_ty_1 , pub arr_double : NT_Value__bindgen_ty_1__bindgen_ty_2 , pub arr_string : NT_Value__bindgen_ty_1__bindgen_ty_3 , _bindgen_union_align : [ u64 ; 2usize ] , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_Value__bindgen_ty_1__bindgen_ty_1 { pub arr : * mut NT_Bool , pub size : usize , } # [ test ] fn bindgen_test_layout_NT_Value__bindgen_ty_1__bindgen_ty_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_Value__bindgen_ty_1__bindgen_ty_1 > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_Value__bindgen_ty_1__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1__bindgen_ty_1 > ( ) ) ) . arr as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_1 ) , "::" , stringify ! ( arr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1__bindgen_ty_1 > ( ) ) ) . size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_1 ) , "::" , stringify ! ( size ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_Value__bindgen_ty_1__bindgen_ty_2 { pub arr : * mut f64 , pub size : usize , } # [ test ] fn bindgen_test_layout_NT_Value__bindgen_ty_1__bindgen_ty_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_Value__bindgen_ty_1__bindgen_ty_2 > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_2 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_Value__bindgen_ty_1__bindgen_ty_2 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1__bindgen_ty_2 > ( ) ) ) . arr as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_2 ) , "::" , stringify ! ( arr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1__bindgen_ty_2 > ( ) ) ) . size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_2 ) , "::" , stringify ! ( size ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_Value__bindgen_ty_1__bindgen_ty_3 { pub arr : * mut NT_String , pub size : usize , } # [ test ] fn bindgen_test_layout_NT_Value__bindgen_ty_1__bindgen_ty_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_Value__bindgen_ty_1__bindgen_ty_3 > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_3 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_Value__bindgen_ty_1__bindgen_ty_3 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1__bindgen_ty_3 > ( ) ) ) . arr as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_3 ) , "::" , stringify ! ( arr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1__bindgen_ty_3 > ( ) ) ) . size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1__bindgen_ty_3 ) , "::" , stringify ! ( size ) ) ) ; } # [ test ] fn bindgen_test_layout_NT_Value__bindgen_ty_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_Value__bindgen_ty_1 > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( NT_Value__bindgen_ty_1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_Value__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_Value__bindgen_ty_1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1 > ( ) ) ) . v_boolean as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1 ) , "::" , stringify ! ( v_boolean ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1 > ( ) ) ) . v_double as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1 ) , "::" , stringify ! ( v_double ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1 > ( ) ) ) . v_string as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1 ) , "::" , stringify ! ( v_string ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1 > ( ) ) ) . v_raw as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1 ) , "::" , stringify ! ( v_raw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1 > ( ) ) ) . arr_boolean as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1 ) , "::" , stringify ! ( arr_boolean ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1 > ( ) ) ) . arr_double as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1 ) , "::" , stringify ! ( arr_double ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value__bindgen_ty_1 > ( ) ) ) . arr_string as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value__bindgen_ty_1 ) , "::" , stringify ! ( arr_string ) ) ) ; } # [ test ] fn bindgen_test_layout_NT_Value ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_Value > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( NT_Value ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_Value > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_Value ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value > ( ) ) ) . type_ as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value ) , "::" , stringify ! ( type_ ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value > ( ) ) ) . last_change as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value ) , "::" , stringify ! ( last_change ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_Value > ( ) ) ) . data as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( NT_Value ) , "::" , stringify ! ( data ) ) ) ; } 
 /// NetworkTables Entry Information 
 # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_EntryInfo { 
 /// Entry handle 
 pub entry : NT_Entry , 
 /// Entry name 
 pub name : NT_String , 
 /// Entry type 
 pub type_ : NT_Type , 
 /// Entry flags 
 pub flags : :: std :: os :: raw :: c_uint , 
 /// Timestamp of last change to entry (type or value). 
 pub last_change : u64 , } # [ test ] fn bindgen_test_layout_NT_EntryInfo ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_EntryInfo > ( ) , 40usize , concat ! ( "Size of: " , stringify ! ( NT_EntryInfo ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_EntryInfo > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_EntryInfo ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryInfo > ( ) ) ) . entry as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryInfo ) , "::" , stringify ! ( entry ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryInfo > ( ) ) ) . name as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryInfo ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryInfo > ( ) ) ) . type_ as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryInfo ) , "::" , stringify ! ( type_ ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryInfo > ( ) ) ) . flags as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryInfo ) , "::" , stringify ! ( flags ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryInfo > ( ) ) ) . last_change as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryInfo ) , "::" , stringify ! ( last_change ) ) ) ; } 
 /// NetworkTables Connection Information 
 # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_ConnectionInfo { 
 /// The remote identifier (as set on the remote node by
    /// NetworkTableInstance::SetNetworkIdentity() or nt::SetNetworkIdentity()). 
 pub remote_id : NT_String , 
 /// The IP address of the remote node. 
 pub remote_ip : NT_String , 
 /// The port number of the remote node. 
 pub remote_port : :: std :: os :: raw :: c_uint , 
 /// The last time any update was received from the remote node (same scale as
    /// returned by nt::Now()). 
 pub last_update : u64 , 
 /// The protocol version being used for this connection.  This in protocol
    /// layer format, so 0x0200 = 2.0, 0x0300 = 3.0). 
 pub protocol_version : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_NT_ConnectionInfo ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_ConnectionInfo > ( ) , 56usize , concat ! ( "Size of: " , stringify ! ( NT_ConnectionInfo ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_ConnectionInfo > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_ConnectionInfo ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_ConnectionInfo > ( ) ) ) . remote_id as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_ConnectionInfo ) , "::" , stringify ! ( remote_id ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_ConnectionInfo > ( ) ) ) . remote_ip as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( NT_ConnectionInfo ) , "::" , stringify ! ( remote_ip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_ConnectionInfo > ( ) ) ) . remote_port as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( NT_ConnectionInfo ) , "::" , stringify ! ( remote_port ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_ConnectionInfo > ( ) ) ) . last_update as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( NT_ConnectionInfo ) , "::" , stringify ! ( last_update ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_ConnectionInfo > ( ) ) ) . protocol_version as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( NT_ConnectionInfo ) , "::" , stringify ! ( protocol_version ) ) ) ; } 
 /// NetworkTables RPC Version 1 Definition Parameter 
 # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct NT_RpcParamDef { pub name : NT_String , pub def_value : NT_Value , } # [ test ] fn bindgen_test_layout_NT_RpcParamDef ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_RpcParamDef > ( ) , 48usize , concat ! ( "Size of: " , stringify ! ( NT_RpcParamDef ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_RpcParamDef > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_RpcParamDef ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcParamDef > ( ) ) ) . name as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcParamDef ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcParamDef > ( ) ) ) . def_value as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcParamDef ) , "::" , stringify ! ( def_value ) ) ) ; } 
 /// NetworkTables RPC Version 1 Definition Result 
 # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_RpcResultDef { pub name : NT_String , pub type_ : NT_Type , } # [ test ] fn bindgen_test_layout_NT_RpcResultDef ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_RpcResultDef > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( NT_RpcResultDef ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_RpcResultDef > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_RpcResultDef ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcResultDef > ( ) ) ) . name as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcResultDef ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcResultDef > ( ) ) ) . type_ as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcResultDef ) , "::" , stringify ! ( type_ ) ) ) ; } 
 /// NetworkTables RPC Version 1 Definition 
 # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_RpcDefinition { pub version : :: std :: os :: raw :: c_uint , pub name : NT_String , pub num_params : usize , pub params : * mut NT_RpcParamDef , pub num_results : usize , pub results : * mut NT_RpcResultDef , } # [ test ] fn bindgen_test_layout_NT_RpcDefinition ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_RpcDefinition > ( ) , 56usize , concat ! ( "Size of: " , stringify ! ( NT_RpcDefinition ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_RpcDefinition > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_RpcDefinition ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcDefinition > ( ) ) ) . version as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcDefinition ) , "::" , stringify ! ( version ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcDefinition > ( ) ) ) . name as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcDefinition ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcDefinition > ( ) ) ) . num_params as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcDefinition ) , "::" , stringify ! ( num_params ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcDefinition > ( ) ) ) . params as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcDefinition ) , "::" , stringify ! ( params ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcDefinition > ( ) ) ) . num_results as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcDefinition ) , "::" , stringify ! ( num_results ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcDefinition > ( ) ) ) . results as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcDefinition ) , "::" , stringify ! ( results ) ) ) ; } 
 /// NetworkTables RPC Call Data 
 # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_RpcAnswer { pub entry : NT_Entry , pub call : NT_RpcCall , pub name : NT_String , pub params : NT_String , pub conn : NT_ConnectionInfo , } # [ test ] fn bindgen_test_layout_NT_RpcAnswer ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_RpcAnswer > ( ) , 96usize , concat ! ( "Size of: " , stringify ! ( NT_RpcAnswer ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_RpcAnswer > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_RpcAnswer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcAnswer > ( ) ) ) . entry as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcAnswer ) , "::" , stringify ! ( entry ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcAnswer > ( ) ) ) . call as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcAnswer ) , "::" , stringify ! ( call ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcAnswer > ( ) ) ) . name as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcAnswer ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcAnswer > ( ) ) ) . params as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcAnswer ) , "::" , stringify ! ( params ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_RpcAnswer > ( ) ) ) . conn as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( NT_RpcAnswer ) , "::" , stringify ! ( conn ) ) ) ; } 
 /// NetworkTables Entry Notification 
 # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct NT_EntryNotification { 
 /// Listener that was triggered. 
 pub listener : NT_EntryListener , 
 /// Entry handle. 
 pub entry : NT_Entry , 
 /// Entry name. 
 pub name : NT_String , 
 /// The new value. 
 pub value : NT_Value , 
 /// Update flags.  For example, NT_NOTIFY_NEW if the key did not previously
    /// exist. 
 pub flags : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_NT_EntryNotification ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_EntryNotification > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( NT_EntryNotification ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_EntryNotification > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_EntryNotification ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryNotification > ( ) ) ) . listener as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryNotification ) , "::" , stringify ! ( listener ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryNotification > ( ) ) ) . entry as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryNotification ) , "::" , stringify ! ( entry ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryNotification > ( ) ) ) . name as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryNotification ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryNotification > ( ) ) ) . value as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryNotification ) , "::" , stringify ! ( value ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_EntryNotification > ( ) ) ) . flags as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( NT_EntryNotification ) , "::" , stringify ! ( flags ) ) ) ; } 
 /// NetworkTables Connection Notification 
 # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_ConnectionNotification { 
 /// Listener that was triggered. 
 pub listener : NT_ConnectionListener , 
 /// True if event is due to connection being established. 
 pub connected : NT_Bool , 
 /// Connection info. 
 pub conn : NT_ConnectionInfo , } # [ test ] fn bindgen_test_layout_NT_ConnectionNotification ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_ConnectionNotification > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( NT_ConnectionNotification ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_ConnectionNotification > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_ConnectionNotification ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_ConnectionNotification > ( ) ) ) . listener as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_ConnectionNotification ) , "::" , stringify ! ( listener ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_ConnectionNotification > ( ) ) ) . connected as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( NT_ConnectionNotification ) , "::" , stringify ! ( connected ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_ConnectionNotification > ( ) ) ) . conn as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_ConnectionNotification ) , "::" , stringify ! ( conn ) ) ) ; } 
 /// NetworkTables log message. 
 # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct NT_LogMessage { 
 /// The logger that generated the message. 
 pub logger : NT_Logger , 
 /// Log level of the message.  See NT_LogLevel. 
 pub level : :: std :: os :: raw :: c_uint , 
 /// The filename of the source file that generated the message. 
 pub filename : * const :: std :: os :: raw :: c_char , 
 /// The line number in the source file that generated the message. 
 pub line : :: std :: os :: raw :: c_uint , 
 /// The message. 
 pub message : * mut :: std :: os :: raw :: c_char , } # [ test ] fn bindgen_test_layout_NT_LogMessage ( ) { assert_eq ! ( :: std :: mem :: size_of :: < NT_LogMessage > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( NT_LogMessage ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < NT_LogMessage > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( NT_LogMessage ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_LogMessage > ( ) ) ) . logger as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( NT_LogMessage ) , "::" , stringify ! ( logger ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_LogMessage > ( ) ) ) . level as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( NT_LogMessage ) , "::" , stringify ! ( level ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_LogMessage > ( ) ) ) . filename as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( NT_LogMessage ) , "::" , stringify ! ( filename ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_LogMessage > ( ) ) ) . line as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( NT_LogMessage ) , "::" , stringify ! ( line ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < NT_LogMessage > ( ) ) ) . message as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( NT_LogMessage ) , "::" , stringify ! ( message ) ) ) ; } extern "C" { 
 /// Get default instance.
/// This is the instance used by non-handle-taking functions.
/// @return Instance handle 
 pub fn NT_GetDefaultInstance ( ) -> NT_Inst ; } extern "C" { 
 /// Create an instance.
/// @return Instance handle 
 pub fn NT_CreateInstance ( ) -> NT_Inst ; } extern "C" { 
 /// Destroy an instance.
/// The default instance cannot be destroyed.
/// @param inst Instance handle 
 pub fn NT_DestroyInstance ( inst : NT_Inst ) ; } extern "C" { 
 /// Get instance handle from another handle.
/// @param handle    handle
/// @return Instance handle 
 pub fn NT_GetInstanceFromHandle ( handle : NT_Handle ) -> NT_Inst ; } extern "C" { 
 /// Get Entry Handle.
/// @param inst      instance handle
/// @param name      entry name (UTF-8 string)
/// @param name_len  length of name in bytes
/// @return entry handle 
 pub fn NT_GetEntry ( inst : NT_Inst , name : * const :: std :: os :: raw :: c_char , name_len : usize ) -> NT_Entry ; } extern "C" { 
 /// Get Entry Handles.
/// Returns an array of entry handles.  The results are optionally
/// filtered by string prefix and entry type to only return a subset of all
/// entries.
///
/// @param prefix        entry name required prefix; only entries whose name
/// starts with this string are returned
/// @param prefix_len    length of prefix in bytes
/// @param types         bitmask of NT_Type values; 0 is treated specially
/// as a "don't care"
/// @return Array of entry handles. 
 pub fn NT_GetEntries ( inst : NT_Inst , prefix : * const :: std :: os :: raw :: c_char , prefix_len : usize , types : :: std :: os :: raw :: c_uint , count : * mut usize ) -> * mut NT_Entry ; } extern "C" { 
 /// Gets the name of the specified entry.
/// Returns an empty string if the handle is invalid.
/// @param entry     entry handle
/// @param name_len  length of the returned string (output parameter)
/// @return Entry name 
 pub fn NT_GetEntryName ( entry : NT_Entry , name_len : * mut usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Gets the type for the specified key, or unassigned if non existent.
/// @param entry   entry handle
/// @return Entry type 
 pub fn NT_GetEntryType ( entry : NT_Entry ) -> NT_Type ; } extern "C" { 
 /// Gets the last time the entry was changed.
/// Returns 0 if the handle is invalid.
/// @param entry   entry handle
/// @return Entry last change time 
 pub fn NT_GetEntryLastChange ( entry : NT_Entry ) -> u64 ; } extern "C" { 
 /// Get Entry Value.
/// Returns copy of current entry value.
/// Note that one of the type options is "unassigned".
///
/// @param entry     entry handle
/// @param value     storage for returned entry value
///
/// It is the caller's responsibility to free value once it's no longer
/// needed (the utility function NT_DisposeValue() is useful for this
/// purpose). 
 pub fn NT_GetEntryValue ( entry : NT_Entry , value : * mut NT_Value ) ; } extern "C" { 
 /// Set Default Entry Value.
/// Returns copy of current entry value if it exists.
/// Otherwise, sets passed in value, and returns set value.
/// Note that one of the type options is "unassigned".
///
/// @param entry     entry handle
/// @param default_value     value to be set if name does not exist
/// @return 0 on error (value not set), 1 on success 
 pub fn NT_SetDefaultEntryValue ( entry : NT_Entry , default_value : * const NT_Value ) -> NT_Bool ; } extern "C" { 
 /// Set Entry Value.
/// Sets new entry value.  If type of new value differs from the type of the
/// currently stored entry, returns error and does not update value.
///
/// @param entry     entry handle
/// @param value     new entry value
/// @return 0 on error (type mismatch), 1 on success 
 pub fn NT_SetEntryValue ( entry : NT_Entry , value : * const NT_Value ) -> NT_Bool ; } extern "C" { 
 /// Set Entry Type and Value.
/// Sets new entry value.  If type of new value differs from the type of the
/// currently stored entry, the currently stored entry type is overridden
/// (generally this will generate an Entry Assignment message).
///
/// This is NOT the preferred method to update a value; generally
/// NT_SetEntryValue() should be used instead, with appropriate error handling.
///
/// @param entry     entry handle
/// @param value     new entry value 
 pub fn NT_SetEntryTypeValue ( entry : NT_Entry , value : * const NT_Value ) ; } extern "C" { 
 /// Set Entry Flags.
/// @param entry     entry handle
/// @param flags     flags value (bitmask of NT_EntryFlags) 
 pub fn NT_SetEntryFlags ( entry : NT_Entry , flags : :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Get Entry Flags.
/// @param entry     entry handle
/// @return Flags value (bitmask of NT_EntryFlags) 
 pub fn NT_GetEntryFlags ( entry : NT_Entry ) -> :: std :: os :: raw :: c_uint ; } extern "C" { 
 /// Delete Entry.
/// Deletes an entry.  This is a new feature in version 3.0 of the protocol,
/// so this may not have an effect if any other node in the network is not
/// version 3.0 or newer.
///
/// Note: NT_GetConnections() can be used to determine the protocol version
/// of direct remote connection(s), but this is not sufficient to determine
/// if all nodes in the network are version 3.0 or newer.
///
/// @param entry     entry handle 
 pub fn NT_DeleteEntry ( entry : NT_Entry ) ; } extern "C" { 
 /// Delete All Entries.
/// Deletes ALL table entries.  This is a new feature in version 3.0 of the
/// so this may not have an effect if any other node in the network is not
/// version 3.0 or newer.
///
/// Note: NT_GetConnections() can be used to determine the protocol version
/// of direct remote connection(s), but this is not sufficient to determine
/// if all nodes in the network are version 3.0 or newer.
///
/// @param inst      instance handle 
 pub fn NT_DeleteAllEntries ( inst : NT_Inst ) ; } extern "C" { 
 /// Get Entry Information.
/// Returns an array of entry information (entry handle, name, entry type,
/// and timestamp of last change to type/value).  The results are optionally
/// filtered by string prefix and entry type to only return a subset of all
/// entries.
///
/// @param inst          instance handle
/// @param prefix        entry name required prefix; only entries whose name
/// starts with this string are returned
/// @param prefix_len    length of prefix in bytes
/// @param types         bitmask of NT_Type values; 0 is treated specially
/// as a "don't care"
/// @param count         output parameter; set to length of returned array
/// @return Array of entry information. 
 pub fn NT_GetEntryInfo ( inst : NT_Inst , prefix : * const :: std :: os :: raw :: c_char , prefix_len : usize , types : :: std :: os :: raw :: c_uint , count : * mut usize ) -> * mut NT_EntryInfo ; } extern "C" { 
 /// Get Entry Information.
/// Returns information about an entry (name, entry type,
/// and timestamp of last change to type/value).
///
/// @param entry         entry handle
/// @param info          entry information (output)
/// @return True if successful, false on error. 
 pub fn NT_GetEntryInfoHandle ( entry : NT_Entry , info : * mut NT_EntryInfo ) -> NT_Bool ; } 
 /// Entry listener callback function.
/// Called when a key-value pair is changed.
///
/// @param data            data pointer provided to callback creation function
/// @param event           event information 
 pub type NT_EntryListenerCallback = :: std :: option :: Option < unsafe extern "C" fn ( data : * mut :: std :: os :: raw :: c_void , event : * const NT_EntryNotification ) > ; extern "C" { 
 /// Add a listener for all entries starting with a certain prefix.
///
/// @param inst              instance handle
/// @param prefix            UTF-8 string prefix
/// @param prefix_len        length of prefix in bytes
/// @param data              data pointer to pass to callback
/// @param callback          listener to add
/// @param flags             NT_NotifyKind bitmask
/// @return Listener handle 
 pub fn NT_AddEntryListener ( inst : NT_Inst , prefix : * const :: std :: os :: raw :: c_char , prefix_len : usize , data : * mut :: std :: os :: raw :: c_void , callback : NT_EntryListenerCallback , flags : :: std :: os :: raw :: c_uint ) -> NT_EntryListener ; } extern "C" { 
 /// Add a listener for a single entry.
///
/// @param entry             entry handle
/// @param data              data pointer to pass to callback
/// @param callback          listener to add
/// @param flags             NT_NotifyKind bitmask
/// @return Listener handle 
 pub fn NT_AddEntryListenerSingle ( entry : NT_Entry , data : * mut :: std :: os :: raw :: c_void , callback : NT_EntryListenerCallback , flags : :: std :: os :: raw :: c_uint ) -> NT_EntryListener ; } extern "C" { 
 /// Create a entry listener poller.
/// A poller provides a single queue of poll events.  Events linked to this
/// poller (using NT_AddPolledEntryListener()) will be stored in the queue and
/// must be collected by calling NT_PollEntryListener().
/// The returned handle must be destroyed with NT_DestroyEntryListenerPoller().
/// @param inst      instance handle
/// @return poller handle 
 pub fn NT_CreateEntryListenerPoller ( inst : NT_Inst ) -> NT_EntryListenerPoller ; } extern "C" { 
 /// Destroy a entry listener poller.  This will abort any blocked polling
/// call and prevent additional events from being generated for this poller.
/// @param poller    poller handle 
 pub fn NT_DestroyEntryListenerPoller ( poller : NT_EntryListenerPoller ) ; } extern "C" { 
 /// Create a polled entry listener.
/// The caller is responsible for calling NT_PollEntryListener() to poll.
/// @param poller            poller handle
/// @param prefix            UTF-8 string prefix
/// @param flags             NT_NotifyKind bitmask
/// @return Listener handle 
 pub fn NT_AddPolledEntryListener ( poller : NT_EntryListenerPoller , prefix : * const :: std :: os :: raw :: c_char , prefix_len : usize , flags : :: std :: os :: raw :: c_uint ) -> NT_EntryListener ; } extern "C" { 
 /// Create a polled entry listener.
/// The caller is responsible for calling NT_PollEntryListener() to poll.
/// @param poller            poller handle
/// @param prefix            UTF-8 string prefix
/// @param flags             NT_NotifyKind bitmask
/// @return Listener handle 
 pub fn NT_AddPolledEntryListenerSingle ( poller : NT_EntryListenerPoller , entry : NT_Entry , flags : :: std :: os :: raw :: c_uint ) -> NT_EntryListener ; } extern "C" { 
 /// Get the next entry listener event.  This blocks until the next event occurs.
/// This is intended to be used with NT_AddPolledEntryListener(void); entry
/// listeners created using NT_AddEntryListener() will not be serviced through
/// this function.
/// @param poller    poller handle
/// @param len       length of returned array (output)
/// @return Array of information on the entry listener events.  Returns NULL if
/// an erroroccurred (e.g. the instance was invalid or is shutting down). 
 pub fn NT_PollEntryListener ( poller : NT_EntryListenerPoller , len : * mut usize ) -> * mut NT_EntryNotification ; } extern "C" { 
 /// Get the next entry listener event.  This blocks until the next event occurs
/// or it times out.  This is intended to be used with
/// NT_AddPolledEntryListener(); entry listeners created using
/// NT_AddEntryListener() will not be serviced through this function.
/// @param poller      poller handle
/// @param len         length of returned array (output)
/// @param timeout     timeout, in seconds
/// @param timed_out   true if the timeout period elapsed (output)
/// @return Array of information on the entry listener events.  If NULL is
/// returned and timed_out is also false, an error occurred (e.g. the
/// instance was invalid or is shutting down). 
 pub fn NT_PollEntryListenerTimeout ( poller : NT_EntryListenerPoller , len : * mut usize , timeout : f64 , timed_out : * mut NT_Bool ) -> * mut NT_EntryNotification ; } extern "C" { 
 /// Cancel a PollEntryListener call.  This wakes up a call to
/// PollEntryListener for this poller and causes it to immediately return
/// an empty array.
/// @param poller  poller handle 
 pub fn NT_CancelPollEntryListener ( poller : NT_EntryListenerPoller ) ; } extern "C" { 
 /// Remove an entry listener.
/// @param entry_listener Listener handle to remove 
 pub fn NT_RemoveEntryListener ( entry_listener : NT_EntryListener ) ; } extern "C" { 
 /// Wait for the entry listener queue to be empty.  This is primarily useful
/// for deterministic testing.  This blocks until either the entry listener
/// queue is empty (e.g. there are no more events that need to be passed along
/// to callbacks or poll queues) or the timeout expires.
/// @param inst      instance handle
/// @param timeout   timeout, in seconds.  Set to 0 for non-blocking behavior,
/// or a negative value to block indefinitely
/// @return False if timed out, otherwise true. 
 pub fn NT_WaitForEntryListenerQueue ( inst : NT_Inst , timeout : f64 ) -> NT_Bool ; } 
 /// Connection listener callback function.
/// Called when a network connection is made or lost.
///
/// @param data            data pointer provided to callback creation function
/// @param event           event info 
 pub type NT_ConnectionListenerCallback = :: std :: option :: Option < unsafe extern "C" fn ( data : * mut :: std :: os :: raw :: c_void , event : * const NT_ConnectionNotification ) > ; extern "C" { 
 /// Add a connection listener.
///
/// @param inst              instance handle
/// @param data              data pointer to pass to callback
/// @param callback          listener to add
/// @param immediate_notify  notify listener of all existing connections
/// @return Listener handle 
 pub fn NT_AddConnectionListener ( inst : NT_Inst , data : * mut :: std :: os :: raw :: c_void , callback : NT_ConnectionListenerCallback , immediate_notify : NT_Bool ) -> NT_ConnectionListener ; } extern "C" { 
 /// Create a connection listener poller.
/// A poller provides a single queue of poll events.  Events linked to this
/// poller (using NT_AddPolledConnectionListener()) will be stored in the queue
/// and must be collected by calling NT_PollConnectionListener().
/// The returned handle must be destroyed with
/// NT_DestroyConnectionListenerPoller().
/// @param inst      instance handle
/// @return poller handle 
 pub fn NT_CreateConnectionListenerPoller ( inst : NT_Inst ) -> NT_ConnectionListenerPoller ; } extern "C" { 
 /// Destroy a connection listener poller.  This will abort any blocked polling
/// call and prevent additional events from being generated for this poller.
/// @param poller    poller handle 
 pub fn NT_DestroyConnectionListenerPoller ( poller : NT_ConnectionListenerPoller ) ; } extern "C" { 
 /// Create a polled connection listener.
/// The caller is responsible for calling NT_PollConnectionListener() to poll.
/// @param poller            poller handle
/// @param immediate_notify  notify listener of all existing connections 
 pub fn NT_AddPolledConnectionListener ( poller : NT_ConnectionListenerPoller , immediate_notify : NT_Bool ) -> NT_ConnectionListener ; } extern "C" { 
 /// Get the next connection event.  This blocks until the next connect or
/// disconnect occurs.  This is intended to be used with
/// NT_AddPolledConnectionListener(); connection listeners created using
/// NT_AddConnectionListener() will not be serviced through this function.
/// @param poller    poller handle
/// @param len       length of returned array (output)
/// @return Array of information on the connection events.  Only returns NULL
/// if an error occurred (e.g. the instance was invalid or is shutting
/// down). 
 pub fn NT_PollConnectionListener ( poller : NT_ConnectionListenerPoller , len : * mut usize ) -> * mut NT_ConnectionNotification ; } extern "C" { 
 /// Get the next connection event.  This blocks until the next connect or
/// disconnect occurs or it times out.  This is intended to be used with
/// NT_AddPolledConnectionListener(); connection listeners created using
/// NT_AddConnectionListener() will not be serviced through this function.
/// @param poller      poller handle
/// @param len         length of returned array (output)
/// @param timeout     timeout, in seconds
/// @param timed_out   true if the timeout period elapsed (output)
/// @return Array of information on the connection events.  If NULL is returned
/// and timed_out is also false, an error occurred (e.g. the instance
/// was invalid or is shutting down). 
 pub fn NT_PollConnectionListenerTimeout ( poller : NT_ConnectionListenerPoller , len : * mut usize , timeout : f64 , timed_out : * mut NT_Bool ) -> * mut NT_ConnectionNotification ; } extern "C" { 
 /// Cancel a PollConnectionListener call.  This wakes up a call to
/// PollConnectionListener for this poller and causes it to immediately return
/// an empty array.
/// @param poller  poller handle 
 pub fn NT_CancelPollConnectionListener ( poller : NT_ConnectionListenerPoller ) ; } extern "C" { 
 /// Remove a connection listener.
/// @param conn_listener Listener handle to remove 
 pub fn NT_RemoveConnectionListener ( conn_listener : NT_ConnectionListener ) ; } extern "C" { 
 /// Wait for the connection listener queue to be empty.  This is primarily useful
/// for deterministic testing.  This blocks until either the connection listener
/// queue is empty (e.g. there are no more events that need to be passed along
/// to callbacks or poll queues) or the timeout expires.
/// @param inst      instance handle
/// @param timeout   timeout, in seconds.  Set to 0 for non-blocking behavior,
/// or a negative value to block indefinitely
/// @return False if timed out, otherwise true. 
 pub fn NT_WaitForConnectionListenerQueue ( inst : NT_Inst , timeout : f64 ) -> NT_Bool ; } 
 /// Remote Procedure Call (RPC) callback function.
/// @param data        data pointer provided to NT_CreateRpc()
/// @param call        call information
/// Note: NT_PostRpcResponse() must be called by the callback to provide a
/// response to the call. 
 pub type NT_RpcCallback = :: std :: option :: Option < unsafe extern "C" fn ( data : * mut :: std :: os :: raw :: c_void , call : * const NT_RpcAnswer ) > ; extern "C" { 
 /// Create a callback-based RPC entry point.  Only valid to use on the server.
/// The callback function will be called when the RPC is called.
/// @param entry     entry handle of RPC entry
/// @param def       RPC definition
/// @param def_len   length of def in bytes
/// @param data      data pointer to pass to callback function
/// @param callback  callback function 
 pub fn NT_CreateRpc ( entry : NT_Entry , def : * const :: std :: os :: raw :: c_char , def_len : usize , data : * mut :: std :: os :: raw :: c_void , callback : NT_RpcCallback ) ; } extern "C" { 
 /// Create a RPC call poller.  Only valid to use on the server.
/// A poller provides a single queue of poll events.  Events linked to this
/// poller (using NT_CreatePolledRpc()) will be stored in the queue and must be
/// collected by calling NT_PollRpc() or NT_PollRpcTimeout().
/// The returned handle must be destroyed with NT_DestroyRpcCallPoller().
/// @param inst      instance handle
/// @return poller handle 
 pub fn NT_CreateRpcCallPoller ( inst : NT_Inst ) -> NT_RpcCallPoller ; } extern "C" { 
 /// Destroy a RPC call poller.  This will abort any blocked polling call and
/// prevent additional events from being generated for this poller.
/// @param poller    poller handle 
 pub fn NT_DestroyRpcCallPoller ( poller : NT_RpcCallPoller ) ; } extern "C" { 
 /// Create a polled RPC entry point.  Only valid to use on the server.
/// The caller is responsible for calling NT_PollRpc() or NT_PollRpcTimeout()
/// to poll for servicing incoming RPC calls.
/// @param entry     entry handle of RPC entry
/// @param def       RPC definition
/// @param def_len   length of def in bytes
/// @param poller    poller handle 
 pub fn NT_CreatePolledRpc ( entry : NT_Entry , def : * const :: std :: os :: raw :: c_char , def_len : usize , poller : NT_RpcCallPoller ) ; } extern "C" { 
 /// Get the next incoming RPC call.  This blocks until the next incoming RPC
/// call is received.  This is intended to be used with NT_CreatePolledRpc(void);
/// RPC calls created using NT_CreateRpc() will not be serviced through this
/// function.  Upon successful return, NT_PostRpcResponse() must be called to
/// send the return value to the caller.  The returned array must be freed
/// using NT_DisposeRpcAnswerArray().
/// @param poller      poller handle
/// @param len         length of returned array (output)
/// @return Array of RPC call information.  Only returns NULL if an error
/// occurred (e.g. the instance was invalid or is shutting down). 
 pub fn NT_PollRpc ( poller : NT_RpcCallPoller , len : * mut usize ) -> * mut NT_RpcAnswer ; } extern "C" { 
 /// Get the next incoming RPC call.  This blocks until the next incoming RPC
/// call is received or it times out.  This is intended to be used with
/// NT_CreatePolledRpc(); RPC calls created using NT_CreateRpc() will not be
/// serviced through this function.  Upon successful return,
/// NT_PostRpcResponse() must be called to send the return value to the caller.
/// The returned array must be freed using NT_DisposeRpcAnswerArray().
/// @param poller      poller handle
/// @param len         length of returned array (output)
/// @param timeout     timeout, in seconds
/// @param timed_out   true if the timeout period elapsed (output)
/// @return Array of RPC call information.  If NULL is returned and timed_out
/// is also false, an error occurred (e.g. the instance was invalid or
/// is shutting down). 
 pub fn NT_PollRpcTimeout ( poller : NT_RpcCallPoller , len : * mut usize , timeout : f64 , timed_out : * mut NT_Bool ) -> * mut NT_RpcAnswer ; } extern "C" { 
 /// Cancel a PollRpc call.  This wakes up a call to PollRpc for this poller
/// and causes it to immediately return an empty array.
/// @param poller  poller handle 
 pub fn NT_CancelPollRpc ( poller : NT_RpcCallPoller ) ; } extern "C" { 
 /// Wait for the incoming RPC call queue to be empty.  This is primarily useful
/// for deterministic testing.  This blocks until either the RPC call
/// queue is empty (e.g. there are no more events that need to be passed along
/// to callbacks or poll queues) or the timeout expires.
/// @param inst      instance handle
/// @param timeout   timeout, in seconds.  Set to 0 for non-blocking behavior,
/// or a negative value to block indefinitely
/// @return False if timed out, otherwise true. 
 pub fn NT_WaitForRpcCallQueue ( inst : NT_Inst , timeout : f64 ) -> NT_Bool ; } extern "C" { 
 /// Post RPC response (return value) for a polled RPC.
/// The rpc and call parameters should come from the NT_RpcAnswer returned
/// by NT_PollRpc().
/// @param entry       entry handle of RPC entry (from NT_RpcAnswer)
/// @param call        RPC call handle (from NT_RpcAnswer)
/// @param result      result raw data that will be provided to remote caller
/// @param result_len  length of result in bytes 
 pub fn NT_PostRpcResponse ( entry : NT_Entry , call : NT_RpcCall , result : * const :: std :: os :: raw :: c_char , result_len : usize ) ; } extern "C" { 
 /// Call a RPC function.  May be used on either the client or server.
/// This function is non-blocking.  Either NT_GetRpcResult() or
/// NT_CancelRpcResult() must be called to either get or ignore the result of
/// the call.
/// @param entry       entry handle of RPC entry
/// @param params      parameter
/// @param params_len  length of param in bytes
/// @return RPC call handle (for use with NT_GetRpcResult() or
/// NT_CancelRpcResult()). 
 pub fn NT_CallRpc ( entry : NT_Entry , params : * const :: std :: os :: raw :: c_char , params_len : usize ) -> NT_RpcCall ; } extern "C" { 
 /// Get the result (return value) of a RPC call.  This function blocks until
/// the result is received.
/// @param entry       entry handle of RPC entry
/// @param call        RPC call handle returned by NT_CallRpc()
/// @param result_len  length of returned result in bytes
/// @return NULL on error, or result. 
 pub fn NT_GetRpcResult ( entry : NT_Entry , call : NT_RpcCall , result_len : * mut usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Get the result (return value) of a RPC call.  This function blocks until
/// the result is received or it times out.
/// @param entry       entry handle of RPC entry
/// @param call        RPC call handle returned by NT_CallRpc()
/// @param result_len  length of returned result in bytes
/// @param timeout     timeout, in seconds
/// @param timed_out   true if the timeout period elapsed (output)
/// @return NULL on error or timeout, or result. 
 pub fn NT_GetRpcResultTimeout ( entry : NT_Entry , call : NT_RpcCall , result_len : * mut usize , timeout : f64 , timed_out : * mut NT_Bool ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Ignore the result of a RPC call.  This function is non-blocking.
/// @param entry       entry handle of RPC entry
/// @param call        RPC call handle returned by NT_CallRpc() 
 pub fn NT_CancelRpcResult ( entry : NT_Entry , call : NT_RpcCall ) ; } extern "C" { 
 /// Pack a RPC version 1 definition.
/// @param def         RPC version 1 definition
/// @param packed_len  length of return value in bytes
/// @return Raw packed bytes.  Use C standard library std::free() to release. 
 pub fn NT_PackRpcDefinition ( def : * const NT_RpcDefinition , packed_len : * mut usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Unpack a RPC version 1 definition.  This can be used for introspection or
/// validation.
/// @param packed      raw packed bytes
/// @param packed_len  length of packed in bytes
/// @param def         RPC version 1 definition (output)
/// @return True if successfully unpacked, false otherwise. 
 pub fn NT_UnpackRpcDefinition ( packed : * const :: std :: os :: raw :: c_char , packed_len : usize , def : * mut NT_RpcDefinition ) -> NT_Bool ; } extern "C" { 
 /// Pack RPC values as required for RPC version 1 definition messages.
/// @param values      array of values to pack
/// @param values_len  length of values
/// @param packed_len  length of return value in bytes
/// @return Raw packed bytes.  Use C standard library std::free() to release. 
 pub fn NT_PackRpcValues ( values : * mut * const NT_Value , values_len : usize , packed_len : * mut usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Unpack RPC values as required for RPC version 1 definition messages.
/// @param packed      raw packed bytes
/// @param packed_len  length of packed in bytes
/// @param types       array of data types (as provided in the RPC definition)
/// @param types_len   length of types
/// @return Array of NT_Value's. 
 pub fn NT_UnpackRpcValues ( packed : * const :: std :: os :: raw :: c_char , packed_len : usize , types : * const NT_Type , types_len : usize ) -> * mut * mut NT_Value ; } extern "C" { 
 /// Set the network identity of this node.
/// This is the name used during the initial connection handshake, and is
/// visible through NT_ConnectionInfo on the remote node.
/// @param inst      instance handle
/// @param name      identity to advertise
/// @param name_len  length of name in bytes 
 pub fn NT_SetNetworkIdentity ( inst : NT_Inst , name : * const :: std :: os :: raw :: c_char , name_len : usize ) ; } extern "C" { 
 /// Get the current network mode.
/// @param inst  instance handle
/// @return Bitmask of NT_NetworkMode. 
 pub fn NT_GetNetworkMode ( inst : NT_Inst ) -> :: std :: os :: raw :: c_uint ; } extern "C" { 
 /// Starts a server using the specified filename, listening address, and port.
///
/// @param inst              instance handle
/// @param persist_filename  the name of the persist file to use (UTF-8 string,
/// null terminated)
/// @param listen_address    the address to listen on, or null to listen on any
/// address. (UTF-8 string, null terminated)
/// @param port              port to communicate over. 
 pub fn NT_StartServer ( inst : NT_Inst , persist_filename : * const :: std :: os :: raw :: c_char , listen_address : * const :: std :: os :: raw :: c_char , port : :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Stops the server if it is running.
/// @param inst  instance handle 
 pub fn NT_StopServer ( inst : NT_Inst ) ; } extern "C" { 
 /// Starts a client.  Use NT_SetServer to set the server name and port.
/// @param inst  instance handle 
 pub fn NT_StartClientNone ( inst : NT_Inst ) ; } extern "C" { 
 /// Starts a client using the specified server and port
///
/// @param inst        instance handle
/// @param server_name server name (UTF-8 string, null terminated)
/// @param port        port to communicate over 
 pub fn NT_StartClient ( inst : NT_Inst , server_name : * const :: std :: os :: raw :: c_char , port : :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Starts a client using the specified (server, port) combinations.  The
/// client will attempt to connect to each server in round robin fashion.
///
/// @param inst         instance handle
/// @param count        length of the server_names and ports arrays
/// @param server_names array of server names (each a UTF-8 string, null
/// terminated)
/// @param ports        array of ports to communicate over (one for each server) 
 pub fn NT_StartClientMulti ( inst : NT_Inst , count : usize , server_names : * mut * const :: std :: os :: raw :: c_char , ports : * const :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Starts a client using commonly known robot addresses for the specified team.
///
/// @param inst        instance handle
/// @param team        team number
/// @param port        port to communicate over 
 pub fn NT_StartClientTeam ( inst : NT_Inst , team : :: std :: os :: raw :: c_uint , port : :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Stops the client if it is running.
/// @param inst  instance handle 
 pub fn NT_StopClient ( inst : NT_Inst ) ; } extern "C" { 
 /// Sets server address and port for client (without restarting client).
///
/// @param inst        instance handle
/// @param server_name server name (UTF-8 string, null terminated)
/// @param port        port to communicate over 
 pub fn NT_SetServer ( inst : NT_Inst , server_name : * const :: std :: os :: raw :: c_char , port : :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Sets server addresses for client (without restarting client).
/// The client will attempt to connect to each server in round robin fashion.
///
/// @param inst         instance handle
/// @param count        length of the server_names and ports arrays
/// @param server_names array of server names (each a UTF-8 string, null
/// terminated)
/// @param ports        array of ports to communicate over (one for each server) 
 pub fn NT_SetServerMulti ( inst : NT_Inst , count : usize , server_names : * mut * const :: std :: os :: raw :: c_char , ports : * const :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Sets server addresses and port for client (without restarting client).
/// Connects using commonly known robot addresses for the specified team.
///
/// @param inst        instance handle
/// @param team        team number
/// @param port        port to communicate over 
 pub fn NT_SetServerTeam ( inst : NT_Inst , team : :: std :: os :: raw :: c_uint , port : :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Starts requesting server address from Driver Station.
/// This connects to the Driver Station running on localhost to obtain the
/// server IP address.
///
/// @param inst  instance handle
/// @param port server port to use in combination with IP from DS 
 pub fn NT_StartDSClient ( inst : NT_Inst , port : :: std :: os :: raw :: c_uint ) ; } extern "C" { 
 /// Stops requesting server address from Driver Station.
/// @param inst  instance handle 
 pub fn NT_StopDSClient ( inst : NT_Inst ) ; } extern "C" { 
 /// Set the periodic update rate.
/// Sets how frequently updates are sent to other nodes over the network.
///
/// @param inst      instance handle
/// @param interval  update interval in seconds (range 0.01 to 1.0) 
 pub fn NT_SetUpdateRate ( inst : NT_Inst , interval : f64 ) ; } extern "C" { 
 /// Flush Entries.
/// Forces an immediate flush of all local entry changes to network.
/// Normally this is done on a regularly scheduled interval (see
/// NT_SetUpdateRate()).
///
/// Note: flushes are rate limited to avoid excessive network traffic.  If
/// the time between calls is too short, the flush will occur after the minimum
/// time elapses (rather than immediately).
///
/// @param inst      instance handle 
 pub fn NT_Flush ( inst : NT_Inst ) ; } extern "C" { 
 /// Get information on the currently established network connections.
/// If operating as a client, this will return either zero or one values.
///
/// @param inst  instance handle
/// @param count returns the number of elements in the array
/// @return      array of connection information
///
/// It is the caller's responsibility to free the array. The
/// NT_DisposeConnectionInfoArray function is useful for this purpose. 
 pub fn NT_GetConnections ( inst : NT_Inst , count : * mut usize ) -> * mut NT_ConnectionInfo ; } extern "C" { 
 /// Return whether or not the instance is connected to another node.
/// @param inst  instance handle
/// @return True if connected. 
 pub fn NT_IsConnected ( inst : NT_Inst ) -> NT_Bool ; } extern "C" { 
 /// Save persistent values to a file.  The server automatically does this,
/// but this function provides a way to save persistent values in the same
/// format to a file on either a client or a server.
/// @param inst      instance handle
/// @param filename  filename
/// @return error string, or NULL if successful 
 pub fn NT_SavePersistent ( inst : NT_Inst , filename : * const :: std :: os :: raw :: c_char ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Load persistent values from a file.  The server automatically does this
/// at startup, but this function provides a way to restore persistent values
/// in the same format from a file at any time on either a client or a server.
/// @param inst      instance handle
/// @param filename  filename
/// @param warn      callback function for warnings
/// @return error string, or NULL if successful 
 pub fn NT_LoadPersistent ( inst : NT_Inst , filename : * const :: std :: os :: raw :: c_char , warn : :: std :: option :: Option < unsafe extern "C" fn ( line : usize , msg : * const :: std :: os :: raw :: c_char ) > ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Save table values to a file.  The file format used is identical to
/// that used for SavePersistent.
/// @param inst        instance handle
/// @param filename    filename
/// @param prefix      save only keys starting with this prefix
/// @param prefix_len  length of prefix in bytes
/// @return error string, or nullptr if successful 
 pub fn NT_SaveEntries ( inst : NT_Inst , filename : * const :: std :: os :: raw :: c_char , prefix : * const :: std :: os :: raw :: c_char , prefix_len : usize ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Load table values from a file.  The file format used is identical to
/// that used for SavePersistent / LoadPersistent.
/// @param inst        instance handle
/// @param filename    filename
/// @param prefix      load only keys starting with this prefix
/// @param prefix_len  length of prefix in bytes
/// @param warn        callback function for warnings
/// @return error string, or nullptr if successful 
 pub fn NT_LoadEntries ( inst : NT_Inst , filename : * const :: std :: os :: raw :: c_char , prefix : * const :: std :: os :: raw :: c_char , prefix_len : usize , warn : :: std :: option :: Option < unsafe extern "C" fn ( line : usize , msg : * const :: std :: os :: raw :: c_char ) > ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Frees value memory.
/// @param value   value to free 
 pub fn NT_DisposeValue ( value : * mut NT_Value ) ; } extern "C" { 
 /// Initializes a NT_Value.
/// Sets type to NT_UNASSIGNED and clears rest of struct.
/// @param value value to initialize 
 pub fn NT_InitValue ( value : * mut NT_Value ) ; } extern "C" { 
 /// Frees string memory.
/// @param str   string to free 
 pub fn NT_DisposeString ( str : * mut NT_String ) ; } extern "C" { 
 /// Initializes a NT_String.
/// Sets length to zero and pointer to null.
/// @param str   string to initialize 
 pub fn NT_InitString ( str : * mut NT_String ) ; } extern "C" { 
 /// Disposes an entry handle array.
/// @param arr   pointer to the array to dispose
/// @param count number of elements in the array 
 pub fn NT_DisposeEntryArray ( arr : * mut NT_Entry , count : usize ) ; } extern "C" { 
 /// Disposes a connection info array.
/// @param arr   pointer to the array to dispose
/// @param count number of elements in the array 
 pub fn NT_DisposeConnectionInfoArray ( arr : * mut NT_ConnectionInfo , count : usize ) ; } extern "C" { 
 /// Disposes an entry info array.
/// @param arr   pointer to the array to dispose
/// @param count number of elements in the array 
 pub fn NT_DisposeEntryInfoArray ( arr : * mut NT_EntryInfo , count : usize ) ; } extern "C" { 
 /// Disposes a single entry info (as returned by NT_GetEntryInfoHandle).
/// @param info  pointer to the info to dispose 
 pub fn NT_DisposeEntryInfo ( info : * mut NT_EntryInfo ) ; } extern "C" { 
 /// Disposes a Rpc Definition structure.
/// @param def  pointer to the struct to dispose 
 pub fn NT_DisposeRpcDefinition ( def : * mut NT_RpcDefinition ) ; } extern "C" { 
 /// Disposes a Rpc Answer array.
/// @param arr   pointer to the array to dispose
/// @param count number of elements in the array 
 pub fn NT_DisposeRpcAnswerArray ( arr : * mut NT_RpcAnswer , count : usize ) ; } extern "C" { 
 /// Disposes a Rpc Answer structure.
/// @param answer     pointer to the struct to dispose 
 pub fn NT_DisposeRpcAnswer ( answer : * mut NT_RpcAnswer ) ; } extern "C" { 
 /// Disposes an entry notification array.
/// @param arr   pointer to the array to dispose
/// @param count number of elements in the array 
 pub fn NT_DisposeEntryNotificationArray ( arr : * mut NT_EntryNotification , count : usize ) ; } extern "C" { 
 /// Disposes a single entry notification.
/// @param info  pointer to the info to dispose 
 pub fn NT_DisposeEntryNotification ( info : * mut NT_EntryNotification ) ; } extern "C" { 
 /// Disposes a connection notification array.
/// @param arr   pointer to the array to dispose
/// @param count number of elements in the array 
 pub fn NT_DisposeConnectionNotificationArray ( arr : * mut NT_ConnectionNotification , count : usize ) ; } extern "C" { 
 /// Disposes a single connection notification.
/// @param info  pointer to the info to dispose 
 pub fn NT_DisposeConnectionNotification ( info : * mut NT_ConnectionNotification ) ; } extern "C" { 
 /// Disposes a log message array.
/// @param arr   pointer to the array to dispose
/// @param count number of elements in the array 
 pub fn NT_DisposeLogMessageArray ( arr : * mut NT_LogMessage , count : usize ) ; } extern "C" { 
 /// Disposes a single log message.
/// @param info  pointer to the info to dispose 
 pub fn NT_DisposeLogMessage ( info : * mut NT_LogMessage ) ; } extern "C" { 
 /// Returns monotonic current time in 1 us increments.
/// This is the same time base used for entry and connection timestamps.
/// This function is a compatibility wrapper around WPI_Now().
/// @return Timestamp 
 pub fn NT_Now ( ) -> u64 ; } 
 /// Log function.
/// @param data    data pointer passed to NT_AddLogger()
/// @param msg     message information 
 pub type NT_LogFunc = :: std :: option :: Option < unsafe extern "C" fn ( data : * mut :: std :: os :: raw :: c_void , msg : * const NT_LogMessage ) > ; extern "C" { 
 /// Add logger callback function.  By default, log messages are sent to stderr;
/// this function sends log messages to the provided callback function instead.
/// The callback function will only be called for log messages with level
/// greater than or equal to min_level and less than or equal to max_level;
/// messages outside this range will be silently ignored.
///
/// @param inst        instance handle
/// @param data        data pointer to pass to func
/// @param func        log callback function
/// @param min_level   minimum log level
/// @param max_level   maximum log level
/// @return Logger handle 
 pub fn NT_AddLogger ( inst : NT_Inst , data : * mut :: std :: os :: raw :: c_void , func : NT_LogFunc , min_level : :: std :: os :: raw :: c_uint , max_level : :: std :: os :: raw :: c_uint ) -> NT_Logger ; } extern "C" { 
 /// Create a log poller.  A poller provides a single queue of poll events.
/// The returned handle must be destroyed with NT_DestroyLoggerPoller().
/// @param inst      instance handle
/// @return poller handle 
 pub fn NT_CreateLoggerPoller ( inst : NT_Inst ) -> NT_LoggerPoller ; } extern "C" { 
 /// Destroy a log poller.  This will abort any blocked polling call and prevent
/// additional events from being generated for this poller.
/// @param poller    poller handle 
 pub fn NT_DestroyLoggerPoller ( poller : NT_LoggerPoller ) ; } extern "C" { 
 /// Set the log level for a log poller.  Events will only be generated for
/// log messages with level greater than or equal to min_level and less than or
/// equal to max_level; messages outside this range will be silently ignored.
/// @param poller        poller handle
/// @param min_level     minimum log level
/// @param max_level     maximum log level
/// @return Logger handle 
 pub fn NT_AddPolledLogger ( poller : NT_LoggerPoller , min_level : :: std :: os :: raw :: c_uint , max_level : :: std :: os :: raw :: c_uint ) -> NT_Logger ; } extern "C" { 
 /// Get the next log event.  This blocks until the next log occurs.
/// @param poller    poller handle
/// @param len       length of returned array (output)
/// @return Array of information on the log events.  Only returns NULL if an
/// error occurred (e.g. the instance was invalid or is shutting down). 
 pub fn NT_PollLogger ( poller : NT_LoggerPoller , len : * mut usize ) -> * mut NT_LogMessage ; } extern "C" { 
 /// Get the next log event.  This blocks until the next log occurs or it times
/// out.
/// @param poller      poller handle
/// @param len         length of returned array (output)
/// @param timeout     timeout, in seconds
/// @param timed_out   true if the timeout period elapsed (output)
/// @return Array of information on the log events.  If NULL is returned and
/// timed_out is also false, an error occurred (e.g. the instance was
/// invalid or is shutting down). 
 pub fn NT_PollLoggerTimeout ( poller : NT_LoggerPoller , len : * mut usize , timeout : f64 , timed_out : * mut NT_Bool ) -> * mut NT_LogMessage ; } extern "C" { 
 /// Cancel a PollLogger call.  This wakes up a call to PollLogger for this
/// poller and causes it to immediately return an empty array.
/// @param poller  poller handle 
 pub fn NT_CancelPollLogger ( poller : NT_LoggerPoller ) ; } extern "C" { 
 /// Remove a logger.
/// @param logger Logger handle to remove 
 pub fn NT_RemoveLogger ( logger : NT_Logger ) ; } extern "C" { 
 /// Wait for the incoming log event queue to be empty.  This is primarily useful
/// for deterministic testing.  This blocks until either the log event
/// queue is empty (e.g. there are no more events that need to be passed along
/// to callbacks or poll queues) or the timeout expires.
/// @param inst      instance handle
/// @param timeout   timeout, in seconds.  Set to 0 for non-blocking behavior,
/// or a negative value to block indefinitely
/// @return False if timed out, otherwise true. 
 pub fn NT_WaitForLoggerQueue ( inst : NT_Inst , timeout : f64 ) -> NT_Bool ; } extern "C" { 
 /// Allocates an array of chars.
/// Note that the size is the number of elements, and not the
/// specific number of bytes to allocate. That is calculated internally.
///
/// @param size  the number of elements the array will contain
/// @return      the allocated char array
///
/// After use, the array should be freed using the NT_FreeCharArray()
/// function. 
 pub fn NT_AllocateCharArray ( size : usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Allocates an array of booleans.
/// Note that the size is the number of elements, and not the
/// specific number of bytes to allocate. That is calculated internally.
///
/// @param size  the number of elements the array will contain
/// @return      the allocated boolean array
///
/// After use, the array should be freed using the NT_FreeBooleanArray()
/// function. 
 pub fn NT_AllocateBooleanArray ( size : usize ) -> * mut NT_Bool ; } extern "C" { 
 /// Allocates an array of doubles.
/// Note that the size is the number of elements, and not the
/// specific number of bytes to allocate. That is calculated internally.
///
/// @param size  the number of elements the array will contain
/// @return      the allocated double array
///
/// After use, the array should be freed using the NT_FreeDoubleArray()
/// function. 
 pub fn NT_AllocateDoubleArray ( size : usize ) -> * mut f64 ; } extern "C" { 
 /// Allocates an array of NT_Strings.
/// Note that the size is the number of elements, and not the
/// specific number of bytes to allocate. That is calculated internally.
///
/// @param size  the number of elements the array will contain
/// @return      the allocated NT_String array
///
/// After use, the array should be freed using the NT_FreeStringArray()
/// function. 
 pub fn NT_AllocateStringArray ( size : usize ) -> * mut NT_String ; } extern "C" { 
 /// Frees an array of chars.
///
/// @param v_boolean  pointer to the char array to free 
 pub fn NT_FreeCharArray ( v_char : * mut :: std :: os :: raw :: c_char ) ; } extern "C" { 
 /// Frees an array of doubles.
///
/// @param v_boolean  pointer to the double array to free 
 pub fn NT_FreeDoubleArray ( v_double : * mut f64 ) ; } extern "C" { 
 /// Frees an array of booleans.
///
/// @param v_boolean  pointer to the boolean array to free 
 pub fn NT_FreeBooleanArray ( v_boolean : * mut NT_Bool ) ; } extern "C" { 
 /// Frees an array of NT_Strings.
///
/// @param v_string  pointer to the string array to free
/// @param arr_size  size of the string array to free
///
/// Note that the individual NT_Strings in the array should NOT be
/// freed before calling this. This function will free all the strings
/// individually. 
 pub fn NT_FreeStringArray ( v_string : * mut NT_String , arr_size : usize ) ; } extern "C" { 
 /// Returns the type of an NT_Value struct.
/// Note that one of the type options is "unassigned".
///
/// @param value  The NT_Value struct to get the type from.
/// @return       The type of the value, or unassigned if null. 
 pub fn NT_GetValueType ( value : * const NT_Value ) -> NT_Type ; } extern "C" { 
 /// Returns the boolean from the NT_Value.
/// If the NT_Value is null, or is assigned to a different type, returns 0.
///
/// @param value       NT_Value struct to get the boolean from
/// @param last_change returns time in ms since the last change in the value
/// @param v_boolean   returns the boolean assigned to the name
/// @return            1 if successful, or 0 if value is null or not a boolean 
 pub fn NT_GetValueBoolean ( value : * const NT_Value , last_change : * mut u64 , v_boolean : * mut NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Returns the double from the NT_Value.
/// If the NT_Value is null, or is assigned to a different type, returns 0.
///
/// @param value       NT_Value struct to get the double from
/// @param last_change returns time in ms since the last change in the value
/// @param v_double    returns the boolean assigned to the name
/// @return            1 if successful, or 0 if value is null or not a double 
 pub fn NT_GetValueDouble ( value : * const NT_Value , last_change : * mut u64 , v_double : * mut f64 ) -> NT_Bool ; } extern "C" { 
 /// Returns a copy of the string from the NT_Value.
/// If the NT_Value is null, or is assigned to a different type, returns 0.
///
/// @param value       NT_Value struct to get the string from
/// @param last_change returns time in ms since the last change in the value
/// @param str_len     returns the length of the string
/// @return            pointer to the string (UTF-8), or null if error
///
/// It is the caller's responsibility to free the string once its no longer
/// needed. The NT_FreeCharArray() function is useful for this purpose. The
/// returned string is a copy of the string in the value, and must be freed
/// separately. 
 pub fn NT_GetValueString ( value : * const NT_Value , last_change : * mut u64 , str_len : * mut usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Returns a copy of the raw value from the NT_Value.
/// If the NT_Value is null, or is assigned to a different type, returns null.
///
/// @param value       NT_Value struct to get the string from
/// @param last_change returns time in ms since the last change in the value
/// @param raw_len     returns the length of the string
/// @return            pointer to the raw value (UTF-8), or null if error
///
/// It is the caller's responsibility to free the raw value once its no longer
/// needed. The NT_FreeCharArray() function is useful for this purpose. The
/// returned string is a copy of the string in the value, and must be freed
/// separately. 
 pub fn NT_GetValueRaw ( value : * const NT_Value , last_change : * mut u64 , raw_len : * mut usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Returns a copy of the boolean array from the NT_Value.
/// If the NT_Value is null, or is assigned to a different type, returns null.
///
/// @param value       NT_Value struct to get the boolean array from
/// @param last_change returns time in ms since the last change in the value
/// @param arr_size    returns the number of elements in the array
/// @return            pointer to the boolean array, or null if error
///
/// It is the caller's responsibility to free the array once its no longer
/// needed. The NT_FreeBooleanArray() function is useful for this purpose.
/// The returned array is a copy of the array in the value, and must be
/// freed separately. 
 pub fn NT_GetValueBooleanArray ( value : * const NT_Value , last_change : * mut u64 , arr_size : * mut usize ) -> * mut NT_Bool ; } extern "C" { 
 /// Returns a copy of the double array from the NT_Value.
/// If the NT_Value is null, or is assigned to a different type, returns null.
///
/// @param value       NT_Value struct to get the double array from
/// @param last_change returns time in ms since the last change in the value
/// @param arr_size    returns the number of elements in the array
/// @return            pointer to the double array, or null if error
///
/// It is the caller's responsibility to free the array once its no longer
/// needed. The NT_FreeDoubleArray() function is useful for this purpose.
/// The returned array is a copy of the array in the value, and must be
/// freed separately. 
 pub fn NT_GetValueDoubleArray ( value : * const NT_Value , last_change : * mut u64 , arr_size : * mut usize ) -> * mut f64 ; } extern "C" { 
 /// Returns a copy of the NT_String array from the NT_Value.
/// If the NT_Value is null, or is assigned to a different type, returns null.
///
/// @param value       NT_Value struct to get the NT_String array from
/// @param last_change returns time in ms since the last change in the value
/// @param arr_size    returns the number of elements in the array
/// @return            pointer to the NT_String array, or null if error
///
/// It is the caller's responsibility to free the array once its no longer
/// needed. The NT_FreeStringArray() function is useful for this purpose.
/// The returned array is a copy of the array in the value, and must be
/// freed seperately. Note that the individual NT_Strings should not be freed,
/// but the entire array should be freed at once. The NT_FreeStringArray()
/// function will free all the NT_Strings. 
 pub fn NT_GetValueStringArray ( value : * const NT_Value , last_change : * mut u64 , arr_size : * mut usize ) -> * mut NT_String ; } extern "C" { 
 /// Returns the boolean currently assigned to the entry name.
/// If the entry name is not currently assigned, or is assigned to a
/// different type, returns 0.
///
/// @param entry       entry handle
/// @param last_change returns time in ms since the last change in the value
/// @param v_boolean   returns the boolean assigned to the name
/// @return            1 if successful, or 0 if value is unassigned or not a
/// boolean 
 pub fn NT_GetEntryBoolean ( entry : NT_Entry , last_change : * mut u64 , v_boolean : * mut NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Returns the double currently assigned to the entry name.
/// If the entry name is not currently assigned, or is assigned to a
/// different type, returns 0.
///
/// @param entry       entry handle
/// @param last_change returns time in ms since the last change in the value
/// @param v_double    returns the double assigned to the name
/// @return            1 if successful, or 0 if value is unassigned or not a
/// double 
 pub fn NT_GetEntryDouble ( entry : NT_Entry , last_change : * mut u64 , v_double : * mut f64 ) -> NT_Bool ; } extern "C" { 
 /// Returns a copy of the string assigned to the entry name.
/// If the entry name is not currently assigned, or is assigned to a
/// different type, returns null.
///
/// @param entry       entry handle
/// @param last_change returns time in ms since the last change in the value
/// @param str_len     returns the length of the string
/// @return            pointer to the string (UTF-8), or null if error
///
/// It is the caller's responsibility to free the string once its no longer
/// needed. The NT_FreeCharArray() function is useful for this purpose. 
 pub fn NT_GetEntryString ( entry : NT_Entry , last_change : * mut u64 , str_len : * mut usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Returns a copy of the raw value assigned to the entry name.
/// If the entry name is not currently assigned, or is assigned to a
/// different type, returns null.
///
/// @param entry       entry handle
/// @param last_change returns time in ms since the last change in the value
/// @param raw_len     returns the length of the string
/// @return            pointer to the raw value (UTF-8), or null if error
///
/// It is the caller's responsibility to free the raw value once its no longer
/// needed. The NT_FreeCharArray() function is useful for this purpose. 
 pub fn NT_GetEntryRaw ( entry : NT_Entry , last_change : * mut u64 , raw_len : * mut usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Returns a copy of the boolean array assigned to the entry name.
/// If the entry name is not currently assigned, or is assigned to a
/// different type, returns null.
///
/// @param entry       entry handle
/// @param last_change returns time in ms since the last change in the value
/// @param arr_size    returns the number of elements in the array
/// @return            pointer to the boolean array, or null if error
///
/// It is the caller's responsibility to free the array once its no longer
/// needed. The NT_FreeBooleanArray() function is useful for this purpose. 
 pub fn NT_GetEntryBooleanArray ( entry : NT_Entry , last_change : * mut u64 , arr_size : * mut usize ) -> * mut NT_Bool ; } extern "C" { 
 /// Returns a copy of the double array assigned to the entry name.
/// If the entry name is not currently assigned, or is assigned to a
/// different type, returns null.
///
/// @param entry       entry handle
/// @param last_change returns time in ms since the last change in the value
/// @param arr_size    returns the number of elements in the array
/// @return            pointer to the double array, or null if error
///
/// It is the caller's responsibility to free the array once its no longer
/// needed. The NT_FreeDoubleArray() function is useful for this purpose. 
 pub fn NT_GetEntryDoubleArray ( entry : NT_Entry , last_change : * mut u64 , arr_size : * mut usize ) -> * mut f64 ; } extern "C" { 
 /// Returns a copy of the NT_String array assigned to the entry name.
/// If the entry name is not currently assigned, or is assigned to a
/// different type, returns null.
///
/// @param entry       entry handle
/// @param last_change returns time in ms since the last change in the value
/// @param arr_size    returns the number of elements in the array
/// @return            pointer to the NT_String array, or null if error
///
/// It is the caller's responsibility to free the array once its no longer
/// needed. The NT_FreeStringArray() function is useful for this purpose. Note
/// that the individual NT_Strings should not be freed, but the entire array
/// should be freed at once. The NT_FreeStringArray() function will free all the
/// NT_Strings. 
 pub fn NT_GetEntryStringArray ( entry : NT_Entry , last_change : * mut u64 , arr_size : * mut usize ) -> * mut NT_String ; } extern "C" { 
 /// Set Default Entry Boolean.
/// Sets the default for the specified key to be a boolean.
/// If key exists with same type, does not set value. Otherwise
/// sets value to the default.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param default_boolean     value to be set if name does not exist
/// @return 0 on error (value not set), 1 on success 
 pub fn NT_SetDefaultEntryBoolean ( entry : NT_Entry , time : u64 , default_boolean : NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Set Default Entry Double.
/// Sets the default for the specified key.
/// If key exists with same type, does not set value. Otherwise
/// sets value to the default.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param default_double     value to be set if name does not exist
/// @return 0 on error (value not set), 1 on success 
 pub fn NT_SetDefaultEntryDouble ( entry : NT_Entry , time : u64 , default_double : f64 ) -> NT_Bool ; } extern "C" { 
 /// Set Default Entry String.
/// Sets the default for the specified key.
/// If key exists with same type, does not set value. Otherwise
/// sets value to the default.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param default_value     value to be set if name does not exist
/// @param default_len       length of value
/// @return 0 on error (value not set), 1 on success 
 pub fn NT_SetDefaultEntryString ( entry : NT_Entry , time : u64 , default_value : * const :: std :: os :: raw :: c_char , default_len : usize ) -> NT_Bool ; } extern "C" { 
 /// Set Default Entry Raw.
/// Sets the default for the specified key.
/// If key exists with same type, does not set value. Otherwise
/// sets value to the default.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param default_value     value to be set if name does not exist
/// @param default_len       length of value array
/// @return 0 on error (value not set), 1 on success 
 pub fn NT_SetDefaultEntryRaw ( entry : NT_Entry , time : u64 , default_value : * const :: std :: os :: raw :: c_char , default_len : usize ) -> NT_Bool ; } extern "C" { 
 /// Set Default Entry Boolean Array.
/// Sets the default for the specified key.
/// If key exists with same type, does not set value. Otherwise
/// sets value to the default.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param default_value     value to be set if name does not exist
/// @param default_size      size of value array
/// @return 0 on error (value not set), 1 on success 
 pub fn NT_SetDefaultEntryBooleanArray ( entry : NT_Entry , time : u64 , default_value : * const :: std :: os :: raw :: c_int , default_size : usize ) -> NT_Bool ; } extern "C" { 
 /// Set Default Entry Double Array.
/// Sets the default for the specified key.
/// If key exists with same type, does not set value. Otherwise
/// sets value to the default.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param default_value     value to be set if name does not exist
/// @param default_size      size of value array
/// @return 0 on error (value not set), 1 on success 
 pub fn NT_SetDefaultEntryDoubleArray ( entry : NT_Entry , time : u64 , default_value : * const f64 , default_size : usize ) -> NT_Bool ; } extern "C" { 
 /// Set Default Entry String Array.
/// Sets the default for the specified key.
/// If key exists with same type, does not set value. Otherwise
/// sets value to the default.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param default_value     value to be set if name does not exist
/// @param default_size      size of value array
/// @return 0 on error (value not set), 1 on success 
 pub fn NT_SetDefaultEntryStringArray ( entry : NT_Entry , time : u64 , default_value : * const NT_String , default_size : usize ) -> NT_Bool ; } extern "C" { 
 /// Set Entry Boolean
/// Sets an entry boolean. If the entry name is not currently assigned to a
/// boolean, returns error unless the force parameter is set.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param v_boolean boolean value to set
/// @param force     1 to force the entry to get overwritten, otherwise 0
/// @return          0 on error (type mismatch), 1 on success 
 pub fn NT_SetEntryBoolean ( entry : NT_Entry , time : u64 , v_boolean : NT_Bool , force : NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Set Entry Double
/// Sets an entry double. If the entry name is not currently assigned to a
/// double, returns error unless the force parameter is set.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param v_double  double value to set
/// @param force     1 to force the entry to get overwritten, otherwise 0
/// @return          0 on error (type mismatch), 1 on success 
 pub fn NT_SetEntryDouble ( entry : NT_Entry , time : u64 , v_double : f64 , force : NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Set Entry String
/// Sets an entry string. If the entry name is not currently assigned to a
/// string, returns error unless the force parameter is set.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param str       string to set (UTF-8 string)
/// @param str_len   length of string to write in bytes
/// @param force     1 to force the entry to get overwritten, otherwise 0
/// @return          0 on error (type mismatch), 1 on success 
 pub fn NT_SetEntryString ( entry : NT_Entry , time : u64 , str : * const :: std :: os :: raw :: c_char , str_len : usize , force : NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Set Entry Raw
/// Sets the raw value of an entry. If the entry name is not currently assigned
/// to a raw value, returns error unless the force parameter is set.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param raw       raw string to set (UTF-8 string)
/// @param raw_len   length of raw string to write in bytes
/// @param force     1 to force the entry to get overwritten, otherwise 0
/// @return          0 on error (type mismatch), 1 on success 
 pub fn NT_SetEntryRaw ( entry : NT_Entry , time : u64 , raw : * const :: std :: os :: raw :: c_char , raw_len : usize , force : NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Set Entry Boolean Array
/// Sets an entry boolean array. If the entry name is not currently assigned to
/// a boolean array, returns error unless the force parameter is set.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param arr       boolean array to write
/// @param size      number of elements in the array
/// @param force     1 to force the entry to get overwritten, otherwise 0
/// @return          0 on error (type mismatch), 1 on success 
 pub fn NT_SetEntryBooleanArray ( entry : NT_Entry , time : u64 , arr : * const :: std :: os :: raw :: c_int , size : usize , force : NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Set Entry Double Array
/// Sets an entry double array. If the entry name is not currently assigned to
/// a double array, returns error unless the force parameter is set.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param arr       double array to write
/// @param size      number of elements in the array
/// @param force     1 to force the entry to get overwritten, otherwise 0
/// @return          0 on error (type mismatch), 1 on success 
 pub fn NT_SetEntryDoubleArray ( entry : NT_Entry , time : u64 , arr : * const f64 , size : usize , force : NT_Bool ) -> NT_Bool ; } extern "C" { 
 /// Set Entry String Array
/// Sets an entry string array. If the entry name is not currently assigned to
/// a string array, returns error unless the force parameter is set.
///
/// @param entry     entry handle
/// @param time      timestamp
/// @param arr       NT_String array to write
/// @param size      number of elements in the array
/// @param force     1 to force the entry to get overwritten, otherwise 0
/// @return          0 on error (type mismatch), 1 on success 
 pub fn NT_SetEntryStringArray ( entry : NT_Entry , time : u64 , arr : * const NT_String , size : usize , force : NT_Bool ) -> NT_Bool ; }