From 935e7b392e96f4f5f5c3432a91a07c8628a2c283 Mon Sep 17 00:00:00 2001 From: Ronan Abhamon Date: Tue, 24 Oct 2017 17:01:32 +0200 Subject: [PATCH] feat(c-event-log): add ref/unref methods --- include/linphone/api/c-event-log.h | 103 +++++++++++++++++++++++++++++ src/c-wrapper/api/c-event-log.cpp | 87 ++++++++++++++++++++++++ 2 files changed, 190 insertions(+) diff --git a/include/linphone/api/c-event-log.h b/include/linphone/api/c-event-log.h index 81fd18990..c701d5202 100644 --- a/include/linphone/api/c-event-log.h +++ b/include/linphone/api/c-event-log.h @@ -42,7 +42,14 @@ **/ LINPHONE_PUBLIC LinphoneEventLog *linphone_event_log_new (void); +/** + * Increment reference count of #LinphoneEventLog object. + **/ LINPHONE_PUBLIC LinphoneEventLog *linphone_event_log_ref (LinphoneEventLog *event_log); + +/** + * Decrement reference count of #LinphoneEventLog object. When dropped to zero, memory is freed. + **/ LINPHONE_PUBLIC void linphone_event_log_unref (LinphoneEventLog *event_log); /** @@ -72,6 +79,16 @@ LINPHONE_PUBLIC LinphoneConferenceEvent *linphone_conference_event_new ( const LinphoneAddress *conference_address ); +/** + * Increment reference count of #LinphoneConferenceEvent object. + **/ +LINPHONE_PUBLIC LinphoneConferenceEvent *linphone_conference_event_ref (LinphoneConferenceEvent *conference_event); + +/** + * Decrement reference count of #LinphoneConferenceEvent object. When dropped to zero, memory is freed. + **/ +LINPHONE_PUBLIC void linphone_conference_event_unref (LinphoneConferenceEvent *conference_event); + /** * Returns the conference address of a conference event. * @param[in] conference_event A #LinphoneConferenceEvent object. @@ -95,6 +112,20 @@ LINPHONE_PUBLIC LinphoneConferenceNotifiedEvent *linphone_conference_notified_ev unsigned int notify_id ); +/** + * Increment reference count of #LinphoneConferenceNotifiedEvent object. + **/ +LINPHONE_PUBLIC LinphoneConferenceNotifiedEvent *linphone_conference_notified_event_ref ( + LinphoneConferenceNotifiedEvent *conference_notified_event +); + +/** + * Decrement reference count of #LinphoneConferenceNotifiedEvent object. When dropped to zero, memory is freed. + **/ +LINPHONE_PUBLIC void linphone_conference_notified_event_unref ( + LinphoneConferenceNotifiedEvent *conference_notified_event +); + /** * Returns the notify id of a conference notified event. * @param[in] conference_notified_event A #LinphoneConferenceNotifiedEvent object. @@ -117,6 +148,20 @@ LINPHONE_PUBLIC LinphoneConferenceCallEvent *linphone_conference_call_event_new LinphoneCall *call ); +/** + * Increment reference count of #LinphoneConferenceCallEvent object. + **/ +LINPHONE_PUBLIC LinphoneConferenceCallEvent *linphone_conference_call_event_ref ( + LinphoneConferenceCallEvent *conference_call_event +); + +/** + * Decrement reference count of #LinphoneConferenceCallEvent object. When dropped to zero, memory is freed. + **/ +LINPHONE_PUBLIC void linphone_conference_call_event_unref ( + LinphoneConferenceCallEvent *conference_call_event +); + /** * Returns the call of a conference call event. * @param[in] conference_conference_call_event A #LinphoneConferenceCallEvent object. @@ -138,6 +183,20 @@ LINPHONE_PUBLIC LinphoneConferenceChatMessageEvent *linphone_conference_chat_mes LinphoneChatMessage *chat_message ); +/** + * Increment reference count of #LinphoneConferenceChatMessageEvent object. + **/ +LINPHONE_PUBLIC LinphoneConferenceChatMessageEvent *linphone_conference_chat_message_event_ref ( + LinphoneConferenceChatMessageEvent *conference_chat_message_event +); + +/** + * Decrement reference count of #LinphoneConferenceChatMessageEvent object. When dropped to zero, memory is freed. + **/ +LINPHONE_PUBLIC void linphone_conference_chat_message_event_unref ( + LinphoneConferenceChatMessageEvent *conference_chat_message_event +); + /** * Returns the chat message of a conference chat message event. * @param[in] conference_chat_message_event A #LinphoneConferenceChatMessageEvent object. @@ -162,6 +221,20 @@ LINPHONE_PUBLIC LinphoneConferenceParticipantEvent *linphone_conference_particip const LinphoneAddress *participant_address ); +/** + * Increment reference count of #LinphoneConferenceParticipantEvent object. + **/ +LINPHONE_PUBLIC LinphoneConferenceParticipantEvent *linphone_conference_participant_event_ref ( + LinphoneConferenceParticipantEvent *conference_participant_event +); + +/** + * Decrement reference count of #LinphoneConferenceParticipantEvent object. When dropped to zero, memory is freed. + **/ +LINPHONE_PUBLIC void linphone_conference_participant_event_unref ( + LinphoneConferenceParticipantEvent *conference_participant_event +); + /** * Returns the participant address of a conference participant event. * @param[in] conference_participant_event A ConferenceParticipantEvent object. @@ -187,6 +260,21 @@ LINPHONE_PUBLIC LinphoneConferenceParticipantDeviceEvent *linphone_conference_pa const LinphoneAddress *gruu_address ); +/** + * Increment reference count of #LinphoneConferenceParticipantDeviceEvent object. + **/ +LINPHONE_PUBLIC LinphoneConferenceParticipantDeviceEvent *linphone_conference_participant_device_event_ref ( + LinphoneConferenceParticipantDeviceEvent *conference_participant_device_event +); + +/** + * Decrement reference count of #LinphoneConferenceParticipantDeviceEvent object. + * When dropped to zero, memory is freed. + **/ +LINPHONE_PUBLIC void linphone_conference_participant_device_event_unref ( + LinphoneConferenceParticipantDeviceEvent *conference_participant_device_event +); + /** * Returns the gruu address of a conference participant device event. * @param[in] conference_participant_device_event A #LinphoneConferenceParticipantDeviceEvent object. @@ -210,6 +298,21 @@ LINPHONE_PUBLIC LinphoneConferenceSubjectEvent *linphone_conference_subject_even const char *subject ); +/** + * Increment reference count of #LinphoneConferenceSubjectEvent object. + **/ +LINPHONE_PUBLIC LinphoneConferenceSubjectEvent *linphone_conference_subject_event_ref ( + LinphoneConferenceSubjectEvent *conference_subject_event +); + +/** + * Decrement reference count of #LinphoneConferenceSubjectEvent object. + * When dropped to zero, memory is freed. + **/ +LINPHONE_PUBLIC void linphone_conference_subject_event_unref ( + LinphoneConferenceSubjectEvent *conference_subject_event +); + /** * Returns the subject of a conference subject event. * @param[in] conference_subject_event A #LinphoneConferenceSubjectEvent object. diff --git a/src/c-wrapper/api/c-event-log.cpp b/src/c-wrapper/api/c-event-log.cpp index ee6625104..151f11c51 100644 --- a/src/c-wrapper/api/c-event-log.cpp +++ b/src/c-wrapper/api/c-event-log.cpp @@ -87,6 +87,15 @@ LinphoneConferenceEvent *linphone_conference_event_new ( return conference_event; } +LinphoneConferenceEvent *linphone_conference_event_ref (LinphoneConferenceEvent *conference_event) { + belle_sip_object_ref(conference_event); + return conference_event; +} + +void linphone_conference_event_unref (LinphoneConferenceEvent *conference_event) { + belle_sip_object_unref(conference_event); +} + const LinphoneAddress *linphone_conference_event_get_conference_address ( const LinphoneConferenceEvent *conference_event ) { @@ -118,6 +127,19 @@ LinphoneConferenceNotifiedEvent *linphone_conference_notified_event_new ( return conference_notified_event; } +LinphoneConferenceNotifiedEvent *linphone_conference_notified_event_ref ( + LinphoneConferenceNotifiedEvent *conference_notified_event +) { + belle_sip_object_ref(conference_notified_event); + return conference_notified_event; +} + +void linphone_conference_notified_event_unref ( + LinphoneConferenceNotifiedEvent *conference_notified_event +) { + belle_sip_object_unref(conference_notified_event); +} + unsigned int linphone_conference_notified_event_get_notify_id ( const LinphoneConferenceNotifiedEvent *conference_notified_event ) { @@ -145,6 +167,19 @@ LinphoneConferenceCallEvent *linphone_conference_call_event_new ( return conference_call_event; } +LinphoneConferenceCallEvent *linphone_conference_call_event_ref ( + LinphoneConferenceCallEvent *conference_call_event +) { + belle_sip_object_ref(conference_call_event); + return conference_call_event; +} + +void linphone_conference_call_event_unref ( + LinphoneConferenceCallEvent *conference_call_event +) { + belle_sip_object_unref(conference_call_event); +} + LinphoneCall *linphone_conference_call_event_get_call (const LinphoneConferenceCallEvent *conference_call_event) { return L_GET_C_BACK_PTR( L_GET_CPP_PTR_FROM_C_OBJECT(conference_call_event)->getCall() @@ -170,6 +205,19 @@ LinphoneConferenceChatMessageEvent *linphone_conference_chat_message_event_new ( return conference_chat_message_event; } +LinphoneConferenceChatMessageEvent *linphone_conference_chat_message_event_ref ( + LinphoneConferenceChatMessageEvent *conference_chat_message_event +) { + belle_sip_object_ref(conference_chat_message_event); + return conference_chat_message_event; +} + +void linphone_conference_chat_message_event_unref ( + LinphoneConferenceChatMessageEvent *conference_chat_message_event +) { + belle_sip_object_unref(conference_chat_message_event); +} + LinphoneChatMessage *linphone_conference_chat_message_event_get_chat_message ( const LinphoneConferenceChatMessageEvent *conference_chat_message_event ) { @@ -203,6 +251,19 @@ LinphoneConferenceParticipantEvent *linphone_conference_participant_event_new ( return conference_participant_event; } +LinphoneConferenceParticipantEvent *linphone_conference_participant_event_ref ( + LinphoneConferenceParticipantEvent *conference_participant_event +) { + belle_sip_object_ref(conference_participant_event); + return conference_participant_event; +} + +void linphone_conference_participant_event_unref ( + LinphoneConferenceParticipantEvent *conference_participant_event +) { + belle_sip_object_unref(conference_participant_event); +} + const LinphoneAddress *linphone_conference_participant_event_get_participant_address ( const LinphoneConferenceParticipantEvent *conference_participant_event ) { @@ -240,6 +301,19 @@ LinphoneConferenceParticipantDeviceEvent *linphone_conference_participant_device return conference_participant_device_event; } +LinphoneConferenceParticipantDeviceEvent *linphone_conference_participant_device_event_ref ( + LinphoneConferenceParticipantDeviceEvent *conference_participant_device_event +) { + belle_sip_object_ref(conference_participant_device_event); + return conference_participant_device_event; +} + +void linphone_conference_participant_device_event_unref ( + LinphoneConferenceParticipantDeviceEvent *conference_participant_device_event +) { + belle_sip_object_unref(conference_participant_device_event); +} + const LinphoneAddress *linphone_conference_participant_device_event_get_gruu_address ( const LinphoneConferenceParticipantDeviceEvent *conference_participant_device_event ) { @@ -272,6 +346,19 @@ LinphoneConferenceSubjectEvent *linphone_conference_subject_event_new ( return conference_subject_event; } +LinphoneConferenceSubjectEvent *linphone_conference_subject_event_ref ( + LinphoneConferenceSubjectEvent *conference_subject_event +) { + belle_sip_object_ref(conference_subject_event); + return conference_subject_event; +} + +void linphone_conference_subject_event_unref ( + LinphoneConferenceSubjectEvent *conference_subject_event +) { + belle_sip_object_unref(conference_subject_event); +} + LINPHONE_PUBLIC const char *linphone_conference_subject_event_get_subject ( const LinphoneConferenceSubjectEvent *conference_subject_event ) {