class_impl.mustache 4.04 KB
Newer Older
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
#include "linphone.hh"

using namespace {{{namespace}}};

{{#_class}}

{{#isNotListener}}
{{{namespace}}}::{{{className}}}::{{{className}}}(::belle_sip_object_t *ptr, bool takeRef): {{{parentClassName}}}(ptr, takeRef) {}
{{/isNotListener}}

{{#ismonolistenable}}
void {{{namespace}}}::{{{className}}}::setListener(const std::shared_ptr<{{{listenerClassName}}}> & listener) {
	ListenableObject::setListener(std::static_pointer_cast<Listener>(listener));
	{{{cListenerName}}} *cbs = {{{cCbsGetter}}}(({{{cClassName}}} *)mPrivPtr);
	if (listener == nullptr) {
		{{#wrapperCbs}}
		{{{callbackSetter}}}(cbs, NULL);
		{{/wrapperCbs}}
	} else {
		{{#wrapperCbs}}
		{{{callbackSetter}}}(cbs, {{{cbName}}});
		{{/wrapperCbs}}
	}
}
{{/ismonolistenable}}

{{#ismultilistenable}}
{{{cListenerName}}} *{{{className}}}::createCallbacks(const std::shared_ptr<{{{listenerClassName}}}> &listener) {
	{{{cListenerName}}} *cbs = {{{listenerCreator}}}(linphone_factory_get());
	{{{userDataSetter}}}(cbs, listener.get());
	{{#wrapperCbs}}
	{{{callbackSetter}}}(cbs, {{{cbName}}});
	{{/wrapperCbs}}
	return cbs;
}

void {{{className}}}::addListener(std::shared_ptr<{{{listenerClassName}}}> &listener) {
	MultiListenableObject::addListener(std::static_pointer_cast<Listener,{{{listenerClassName}}}>(listener));
	{{{cListenerName}}} *cbs = createCallbacks(listener);
	{{{callbacksAdder}}}(({{{cClassName}}} *)mPrivPtr, cbs);
	listener->setCallbacks((::belle_sip_object_t *)cbs);
	belle_sip_object_unref(cbs);
}

void {{{className}}}::removeListener(std::shared_ptr<{{{listenerClassName}}}> &listener) {
	::belle_sip_object_t *cbs = belle_sip_object_ref(listener->getCallbacks());
	{{{callbacksRemover}}}(({{{cClassName}}} *)mPrivPtr, ({{{cListenerName}}} *)cbs);
	listener->setCallbacks(NULL);
	belle_sip_object_unref(cbs);
	
	MultiListenableObject::removeListener(listener);
}
{{/ismultilistenable}}

{{#isfactory}}
std::shared_ptr<Core> Factory::createCore(const std::shared_ptr<CoreListener> & cbs, const std::string & configPath, const std::string & factoryConfigPath) const {
	::LinphoneFactory *factory = linphone_factory_get();
	::LinphoneCoreCbs *c_cbs = cbs != nullptr ? Core::createCallbacks(cbs) : NULL;
	::LinphoneCore *core_ptr = linphone_factory_create_core(factory, c_cbs, configPath.c_str(), factoryConfigPath.c_str());
	std::shared_ptr<Core> core = cPtrToSharedPtr<Core>((belle_sip_object_t *)core_ptr, false);
	if (core != nullptr && cbs != nullptr) {
		std::static_pointer_cast<MultiListenableObject,Core>(core)->addListener(cbs);
		cbs->setCallbacks((belle_sip_object_t *)c_cbs);
	}
	if (c_cbs) linphone_core_cbs_unref(c_cbs);
	return core;
}

std::shared_ptr<Core> Factory::createCoreWithConfig(const std::shared_ptr<CoreListener> & cbs, const std::shared_ptr<Config> & config) const {
	::LinphoneFactory *factory = linphone_factory_get();
	::LinphoneCoreCbs *c_cbs = cbs != nullptr ? Core::createCallbacks(cbs) : NULL;
	::LinphoneCore *core_ptr = linphone_factory_create_core_with_config(factory, c_cbs, (::LinphoneConfig *)sharedPtrToCPtr(config));
	std::shared_ptr<Core> core = cPtrToSharedPtr<Core>((belle_sip_object_t *)core_ptr, false);
	if (core != nullptr && cbs != nullptr) {
		std::static_pointer_cast<MultiListenableObject,Core>(core)->addListener(cbs);
		cbs->setCallbacks((belle_sip_object_t *)c_cbs);
	}
	if (c_cbs) linphone_core_cbs_unref(c_cbs);
	return core;
}
{{/isfactory}}

{{#methods}}
{{{implPrototype}}} {
	{{{sourceCode}}}
}
{{/methods}}

{{#staticMethods}}
{{{implPrototype}}} {
	{{{sourceCode}}}
}
{{/staticMethods}}

{{#wrapperCbs}}
{{{returnType}}} {{{className}}}::{{{cbName}}}({{{declArgs}}}) {
	{{#ismonolistenable}}std::shared_ptr<{{{cppListenerName}}}> listener = std::static_pointer_cast<{{{cppListenerName}}},Listener>(getListenerFromObject((::belle_sip_object_t *){{{firstArgName}}}));{{/ismonolistenable}}
	{{#ismultilistenable}}
	LinphoneCoreCbs *cbs = linphone_core_get_current_callbacks(lc);
	CoreListener *listener = (CoreListener *)linphone_core_cbs_get_user_data(cbs);
	{{/ismultilistenable}}
	{{#hasReturnValue}}return {{/hasReturnValue}}{{{cppMethodCallingLine}}}
}
{{/wrapperCbs}}

{{/_class}}