Event Class Reference

#include <switch_cpp.h>

Collaboration diagram for Event:

Public Member Functions
	Event (const char *type, const char *subclass_name=NULL)
	Event (switch_event_t *wrap_me, int free_me=0)
virtual	~ Event ()
int	chat_execute (const char *app, const char *data=NULL)
int	chat_send (const char *dest_proto=NULL)
const char *	serialize (const char *format=NULL)
bool	setPriority (switch_priority_t priority=SWITCH_PRIORITY_NORMAL)
const char *	getHeader (const char *header_name)
char *	getBody (void)
const char *	getType (void)
bool	addBody (const char *value)
bool	addHeader (const char *header_name, const char *value)
bool	delHeader (const char *header_name)
bool	fire (void)
bool	merge (Event *to_merge)

Data Fields
switch_event_t *	event
char *	serialized_string
int	mine

Detailed Description

Definition at line 158 of file switch_cpp.h.

Constructor & Destructor Documentation

Event() [1/2]

Event::Event	(	const char *	type,
		const char *	subclass_name = NULL
	)

Definition at line 294 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_create_json(), switch_event_create_subclass, SWITCH_EVENT_CUSTOM, SWITCH_EVENT_MESSAGE, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_name_event(), SWITCH_STATUS_SUCCESS, and zstr.

{
        switch_event_types_t event_id;

        if (!strcasecmp(type, "json") && !zstr(subclass_name)) {
        if (switch_event_create_json(&event, subclass_name) != SWITCH_STATUS_SUCCESS) {
                        return;
                }

                event_id = event->event_id;

    } else {
                if (switch_name_event(type, &event_id) != SWITCH_STATUS_SUCCESS) {
                        event_id = SWITCH_EVENT_MESSAGE;
                }

                if (!zstr(subclass_name) && event_id != SWITCH_EVENT_CUSTOM) {
                        switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_WARNING, "Changing event type to custom because you specified a subclass name!\n");
                        event_id = SWITCH_EVENT_CUSTOM;
                }

                if (switch_event_create_subclass(&event, event_id, subclass_name) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Failed to create event!\n");
                        event = NULL;
                }
        }

        serialized_string = NULL;
        mine = 1;
}

Event() [2/2]

Event::Event	(	switch_event_t *	wrap_me,
		int	free_me = 0
	)

Definition at line 325 of file switch_cpp.cpp.

References SWITCH_DECLARE_CONSTRUCTOR, and switch_event_destroy().

{
        event = wrap_me;
        mine = free_me;
        serialized_string = NULL;
}

~ Event()

virtual Event::~ Event ( )

virtual

Member Function Documentation

addBody()

bool Event::addBody

(

const char *

value

)

Definition at line 484 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_add_body(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_SUCCESS, this_check, and true.

{
        this_check(false);

        if (event) {
                return switch_event_add_body(event, "%s", value) == SWITCH_STATUS_SUCCESS ? true : false;
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to addBody an event that does not exist!\n");
        }

        return false;
}

addHeader()

bool Event::addHeader	(	const char *	header_name,
		const char *	value
	)

Definition at line 452 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_add_header_string(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, this_check, and true.

{
        this_check(false);

        if (event) {
                return switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header_name, value) == SWITCH_STATUS_SUCCESS ? true : false;
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to addHeader an event that does not exist!\n");
        }

        return false;
}

chat_execute()

int Event::chat_execute	(	const char *	app,
		const char *	data = NULL
	)

Definition at line 344 of file switch_cpp.cpp.

References switch_core_execute_chat_app().

{
        return (int) switch_core_execute_chat_app(event, app, data);
}

chat_send()

int Event::chat_send

(

const char *

dest_proto = NULL

)

Definition at line 349 of file switch_cpp.cpp.

References switch_core_chat_send(), switch_event_get_header, and zstr.

{
        if (zstr(dest_proto)) {
                dest_proto = switch_event_get_header(event, "dest_proto");
        }

        return (int) switch_core_chat_send(dest_proto, event);
}

delHeader()

bool Event::delHeader

(

const char *

header_name

)

Definition at line 465 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_del_header, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_SUCCESS, this_check, true, and zstr.

{
        this_check(false);

        if (zstr(header_name)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Trying to delHeader an invalid header!\n");
                return false;
        }

        if (event) {
                return switch_event_del_header(event, header_name) == SWITCH_STATUS_SUCCESS ? true : false;
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to delHeader an event that does not exist!\n");
        }

        return false;
}

fire()

bool Event::fire

(

void

)

Definition at line 394 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_destroy(), switch_event_dup(), switch_event_fire, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_SUCCESS, and this_check.

{

        this_check(false);

        if (!mine) {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Not My event!\n");
                return false;
        }

        if (event) {
                switch_event_t *new_event;
                if (switch_event_dup(&new_event, event) == SWITCH_STATUS_SUCCESS) {
                        if (switch_event_fire(&new_event) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Failed to fire the event!\n");
                                switch_event_destroy(&new_event);
                                return false;
                        }
                        return true;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Failed to dup the event!\n");
                }
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to fire an event that does not exist!\n");
        }
        return false;
}

getBody()

char * Event::getBody

(

void

)

Definition at line 497 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_get_body(), SWITCH_LOG_ERROR, switch_log_printf(), and this_check.

{

        this_check((char *)"");

        if (event) {
                return switch_event_get_body(event);
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to getBody an event that does not exist!\n");
        }

        return NULL;
}

getHeader()

const char * Event::getHeader

(

const char *

header_name

)

Definition at line 435 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_get_header, SWITCH_LOG_ERROR, switch_log_printf(), this_check, and zstr.

{
        this_check("");

    if (zstr(header_name)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Trying to getHeader an invalid header!\n");
                return NULL;
    }

        if (event) {
                return switch_event_get_header(event, header_name);
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to getHeader an event that does not exist!\n");
        }
        return NULL;
}

getType()

const char * Event::getType

(

void

)

Definition at line 511 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_name(), SWITCH_LOG_ERROR, switch_log_printf(), and this_check.

{
        this_check("");

        if (event) {
                return switch_event_name(event->event_id);
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to getType an event that does not exist!\n");
        }

        return (char *) "invalid";
}

merge()

bool Event::merge

(

Event *

to_merge

)

Definition at line 524 of file switch_cpp.cpp.

References event, SWITCH_CHANNEL_LOG, switch_event_merge(), SWITCH_LOG_ERROR, switch_log_printf(), and this_check.

{
        this_check(false);

        if (!event) {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to merge to an event that does not exist!\n");
                return false;
        }

        if (!to_merge || !to_merge->event) {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to merge from an event that does not exist!\n");
                return false;
        }

        switch_event_merge(event, to_merge->event);

        return true;
}

serialize()

const char * Event::serialize

(

const char *

format = NULL

)

Definition at line 358 of file switch_cpp.cpp.

References switch_event_serialize(), switch_event_serialize_json(), switch_event_xmlize(), SWITCH_FALSE, switch_mprintf(), switch_safe_free, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, SWITCH_VA_NONE, switch_xml_free(), switch_xml_toxml, and this_check.

{
        this_check("");


        switch_safe_free(serialized_string);

        if (!event) {
                return "";
        }

        if (format && !strcasecmp(format, "xml")) {
                switch_xml_t xml;
                if ((xml = switch_event_xmlize(event, SWITCH_VA_NONE))) {
                        serialized_string = switch_xml_toxml(xml, SWITCH_FALSE);
                        switch_xml_free(xml);
                        return serialized_string;
                } else {
                        return "";
                }
        } else if (format && !strcasecmp(format, "json")) {
                switch_event_serialize_json(event, &serialized_string);
                return serialized_string;
        } else {
                if (switch_event_serialize(event, &serialized_string, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
                        char *new_serialized_string = switch_mprintf("%s", serialized_string);
                        free(serialized_string);
                        serialized_string = new_serialized_string;
                        return serialized_string;
                }
        }

        return "";

}

setPriority()

bool Event::setPriority

(

switch_priority_t

priority = SWITCH_PRIORITY_NORMAL

)

Definition at line 422 of file switch_cpp.cpp.

References SWITCH_CHANNEL_LOG, switch_event_set_priority(), SWITCH_LOG_ERROR, switch_log_printf(), and this_check.

{
        this_check(false);

        if (event) {
        switch_event_set_priority(event, priority);
                return true;
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "Trying to setPriority an event that does not exist!\n");
    }
        return false;
}

Field Documentation

event

switch_event_t* Event::event

Definition at line 161 of file switch_cpp.h.

Referenced by merge(), CoreSession::sendEvent(), and CoreSession::setEventData().

mine

int Event::mine

Definition at line 163 of file switch_cpp.h.

serialized_string

char* Event::serialized_string

Definition at line 162 of file switch_cpp.h.

---

The documentation for this class was generated from the following files:

• switch_cpp.h
• switch_cpp.cpp