vsomeip-sys 0.6.0

Somewhat low level unsafe wrapper around vsomeip
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

/********************************************************************************
 * Copyright (c) 2024 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * SPDX-License-Identifier: Apache-2.0
 ********************************************************************************/

/// autocxx fails to generate bindings currently to functions which contain usage
/// of C++ std::function, so we manually generate these separately using cxx
#[cxx::bridge(namespace = "glue")]
pub mod handler_registration {
    unsafe extern "C++" {
        include!("vsomeip/vsomeip.hpp");
        include!("include/application_wrapper.h");
        include!("application_registrations.h");

        pub unsafe fn request_single_event(
            _application_wrapper: *mut ApplicationWrapper,
            _service: u16,
            _instance: u16,
            _notifier: u16,
            _eventgroup: u16,
        );

        pub unsafe fn offer_single_event(
            _application_wrapper: *mut ApplicationWrapper,
            _service: u16,
            _instance: u16,
            _notifier: u16,
            _eventgroup: u16,
        );

        type message_handler_fn_ptr = crate::extern_callback_wrappers::MessageHandlerFnPtr;
        type ApplicationWrapper = crate::ffi::glue::ApplicationWrapper;

        /// Registers a message handler
        ///
        /// # Rationale
        ///
        /// This function exists as a workaround, since the vsomeip API for
        /// application::register_message_handler() takes a std::function
        /// which is not supported by autocxx or cxx
        ///
        /// So we instead use this C++ glue code which accepts a function pointer
        /// and creates an std::function with which to then call application::register_message_handler()
        ///
        /// # Parameters
        ///
        /// * _application_wrapper - An [ApplicationWrapper]
        /// * _service - A SOME/IP [service_t](crate::vsomeip::service_t), i.e service ID
        /// * _instance - A SOME/IP [instance_t](crate::vsomeip::instance_t), i.e instance ID
        /// * _method - A SOME/IP [method_t](crate::vsomeip::method_t), i.e method/event ID
        /// * _fn_ptr_handler - A [MessageHandlerFnPtr](crate::extern_callback_wrappers::MessageHandlerFnPtr)
        pub unsafe fn register_message_handler_fn_ptr(
            _application_wrapper: *mut ApplicationWrapper,
            _service: u16,
            _instance: u16,
            _method: u16,
            _fn_ptr_handler: message_handler_fn_ptr,
        );

        type availability_handler_fn_ptr =
            crate::extern_callback_wrappers::AvailabilityHandlerFnPtr;

        /// Registers an availability handler
        ///
        /// # Rationale
        ///
        /// This function exists as a workaround, since the vsomeip API for
        /// application::register_availability_handler() takes a std::function
        /// which is not supported by autocxx or cxx
        ///
        /// So we instead use this C++ glue code which accepts a function pointer
        /// and creates a lambda with which to then call application::register_availablity_handler()
        ///
        /// # Parameters
        ///
        /// * _application_wrapper - An [ApplicationWrapper]
        /// * _service - A SOME/IP [service_t](crate::vsomeip::service_t), i.e service ID
        /// * _instance - A SOME/IP [instance_t](crate::vsomeip::instance_t), i.e instance ID
        /// * _fn_ptr_handler - A [AvailabilityHandlerFnPtr](crate::extern_callback_wrappers::AvailabilityHandlerFnPtr)
        /// * _major - A SOME/IP [major_version_t](crate::vsomeip::major_version_t), i.e the major version
        /// * _minor - A SOME/IP [minor_version_t](crate::vsomeip::minor_version_t), i.e the major version
        pub unsafe fn register_availability_handler_fn_ptr(
            _application_wrapper: *mut ApplicationWrapper,
            _service: u16,
            _instance: u16,
            _fn_ptr_handler: availability_handler_fn_ptr,
            _major: u8,
            _minor: u32,
        );

        type subscription_status_handler_fn_ptr =
            crate::extern_callback_wrappers::SubscriptionStatusHandlerFnPtr;

        /// Registers a subscription status handler
        ///
        /// # Rationale
        ///
        /// This function exists as a workaround, since the vsomeip API for
        /// application::register_subscription_status_handler() takes a std::function
        /// which is not supported by autocxx or cxx
        ///
        /// So we instead use this C++ glue code which accepts a function pointer
        /// and creates a lambda with which to then call application::register_subscription_status_handler()
        ///
        /// # Parameters
        ///
        /// * _application_wrapper - An [crate::cxx_bridge::handler_registration::ApplicationWrapper]
        /// * _service - A SOME/IP [service_t](crate::vsomeip::service_t), i.e service ID
        /// * _instance - A SOME/IP [instance_t](crate::vsomeip::instance_t), i.e instance ID
        /// * _eventgroup - A SOME/IP [eventgroup_t](crate::vsomeip::eventgroup_t)
        /// * _event - A SOME/IP [event_t](crate::vsomeip::event_t)
        /// * _fn_ptr_handler - A [SubscriptionStatusHandlerFnPtr](crate::extern_callback_wrappers::SubscriptionStatusHandlerFnPtr)
        /// * _is_selective - If true the callback is called even when there's an error registering the subscription
        pub unsafe fn register_subscription_status_handler_fn_ptr(
            _application_wrapper: *mut ApplicationWrapper,
            _service: u16,
            _instance: u16,
            _eventgroup: u16,
            _event: u16,
            _fn_ptr_handler: subscription_status_handler_fn_ptr,
            _is_selective: bool,
        );

        type state_handler_fn_ptr = crate::extern_callback_wrappers::AvailableStateHandlerFnPtr;

        pub unsafe fn register_state_handler_fn_ptr(
            application_wrapper: *mut ApplicationWrapper,
            _fn_ptr_handler: state_handler_fn_ptr,
        );
    }
}

/// autocxx fails to generate bindings to these functions, so we write the bindings for them
/// by hand and inject them into the vsomeip_v3 namespace
#[cxx::bridge(namespace = "vsomeip_v3")]
mod autocxx_failed {
    unsafe extern "C++" {
        include!("vsomeip/vsomeip.hpp");

        type payload = crate::vsomeip::payload;

        /// # Safety
        ///
        /// We are simply creating a binding here for one that autocxx failed to generate
        #[allow(clippy::missing_safety_doc)]
        pub(crate) unsafe fn set_data(self: Pin<&mut payload>, _data: *const u8, _length: u32);

        pub fn get_data(self: &payload) -> *const u8;

        pub fn get_length(self: &payload) -> u32;
    }
}