Russian Qt Forum

Есть программа с что-то типа плагинами, я через функцию библиотеки передаю callback функцию основной формы (как бы для обратной связи)
Как узнать, какая именно библиотека вызвала этот callback ? Естественно не передавая эту метку явно через функцию.

"какая dll" не совсем так, приложение может иметь несколько экземпляров одного плагина использующих одну и ту же dll но с разными данными. Можно просто запомнить указатель на плагин (объект) перед вызовом dll ф-ции. Для multi-thread плюс еще ID нитки

Да, действительно. Как-то не подумал

А вот тут подробнее, пожалуйста
Вот я, например вызывал из библиотеки функцию SetCallback и назначил ей callback setText. Т.е. теперь сама библиотека может менять текст в основной программе.
Пример грубый, но я думаю понятно...

какой указатель запомнить ?

Простой/примитивный вариант

C++ (Qt)
static QLibrary * theActiveLib = 0;
...
QLibrary library;
...
   if (funcSetCallback){
      theActiveLib = &library;
      funcSetCallback(setText);
      theActiveLib = 0;
   }
...
void setText( void )
{
  assert(theActiveLib);
  qDebug() << "caller is" << theActiveLib->fileName();
  ...
}
 

Если можно поменять тело ф-ии в либе, то может проще сделать как нормальные люди - в ее сигнатуру добавить void *data ?

На мой взгляд это не проще и не лучше

- перекомпилировать либу не всегда просто, да и ф-ция может быть не одна
- неск объектов зовут ту же dll
- dll вызываетcя через др dll, напр цепочка host->dll1->...->dll2->callback

А из хоста нужен по существу scoped_lock

Не вариант.

Зачем сохранять указатель в переменной theActiveLib при установке callback-функции, а после этого ее обнулять?  :)
Ведь вызываться установленная функция (setText) будет не в этот момент, а потом.

Ага, живой (а я уж думал Вы заболели  :))
Если "потом" то окружить те dll ф-ции из которых setText зовется, это несложно сделать в общем виде. Суть та же

Ну так, твоими молитвами...  :)

Т.е. изменить все функции во всех библиотеках, которые будут использовать этот callback? Что-то мне подсказывает, что топикстартер хотел все это сделать меньшими усилиями.  ;)
Если есть возможность изменить все библиотеки, то проще изменить интерфейс и штатно передавать какой-то идентификатор библиотеки.

Та нет, либы не трогать, просто поменять обертки. Напр есть dll ф-ция

C++ (Qt)
int FuncDLL1( int param );
 

Вместо нее использовать

C++ (Qt)
int FuncDLL1_( int param, const QLibrary * theLib, void *  )
{
// удобно и resolve свалить сюда
 static TFunc FuncDLL1 = 0;
 if (!FuncDLL1)
  FuncDLL1 = theLib->resolve("FuncDLL1");
 assert(FuncDLL1);
 
// запоминаем либу и/или вызываюшего
 theActLib = theLib;
 ...
 
// вызываем
 int result = FuncDLL1(param); 
 
 theActLib = 0;
 return result;
}
 

На самом деле в библиотеке есть функция, которая регистрирует callback-функцию. Далее эта функция будет вызвана и уже в ней нужно определить кто ее дернул.

Это подходит, если бы вызывающая библиотека была одна. А как сделать, если их, например, 10 ? В моем примере, они все считываются из какой то условной папки. А потом ждем вызов функции setText(). Ну а в ней нужно сделать, например, лог. "Такая то dll вызвала эту функцию".

Выше я писал, что без передачи какого либо специального параметра.

Можно дать каждой dll свою callback, но это случай частный, так можно отследить только dll (модуль), да и регистрации никто не обещал

Без разницы 1, 10 или 100. Приложение (хост) всегда знает когда оно отдает управление в dll (плагин) и всегда знает в какой именно. Нужно только перед отдачей управления (вызовом dll ф-ции) сохранить эту информацию. Что сохранять - дело хозяйское. Напр если интересно только имя файла  

C++ (Qt)
std::maр <void *, QString> theMap;
QString theActiveDLL;
 
// получаем dll ф-цию которая вызовет setText
TFunc FuncDLL1 = library.resolve("FuncDLL1");
 
// запоминаем из какого файла эта ф-ция
theMap[(void *) FuncDLL1] = library.fileName();
...
// перед вызовом ф-ции устанавливаем имя dll
theActiveDLL = theMap.find((void *) FuncDLL1)->second;
// вызываем
FuncDLL1(..);
 

Небольшой набросок:

C++ (Qt)
#include <iostream>
#include <boost/function.hpp>
#include <boost/bind.hpp>
 
// Наша callback-функция
void setText( const std::string &str )
{
	std::cout << "Call setText( " << str << " )" << std::endl;
}
 
typedef boost::function<void ( const std::string & )>	CallbackFunc;
 
// ========================================================================
// Этот класс просто эмитирует разделяемую библиотеку
class Dll
{
public:
	void setCallback( const CallbackFunc &fn )
	{
		m_func = fn;
	}
 
	void run()
	{
		if( !m_func.empty() )
			m_func( "Test string" );
	}
 
private:
	CallbackFunc	m_func;
};
 
// ========================================================================
// Класс адаптор
// Объект этого класса служит переходником, который сохраняет идентификатор
// библиотеки
class Adaptor
{
public:
	Adaptor( const std::string &dllName, const CallbackFunc &fn ) :
		m_dllName( dllName ), m_func( fn )
	{
	}
 
	void	recall( const std::string &str )
	{
		m_func( m_dllName + ";" + str );
	}
 
private:
	std::string		m_dllName;
	CallbackFunc	m_func;
};
 
// ========================================================================
 
 
 
int main( int argc, char **argv )
{
	Dll	dll1;
	Dll	dll2;
 
// Варианты с адаптором или без.
#if	1		
	dll1.setCallback( boost::bind( &setText, _1 ) );
	dll2.setCallback( boost::bind( &setText, _1 ) );
 
#else
	Adaptor a1( "first.dll", boost::bind( &setText, _1 ) );
	Adaptor a2( "second.dll", boost::bind( &setText, _1 ) );
 
	dll1.setCallback( boost::bind( &Adaptor::recall, &a1, _1 ) );
	dll2.setCallback( boost::bind( &Adaptor::recall, &a2, _1 ) );
#endif
 
	dll1.run();
	dll2.run();
 
	return 0;
}
 

Это-то понятно.
Но ведь библиотека может слать сигнал в основную программу и не по вызову, а по своему какому либо таймеру. Или не может ? :)

В ситуациях когда dll открывает свои окна, крутит цикл событий, таймер и.т.п.  все проще т.к. хосту известно какой плагин какое окно создал.

Конечно может. Можно добавить таймер и посмотреть.  :)