\hypertarget{group__invoke}{}\doxysection{Invoke}
\label{group__invoke}\index{Invoke@{Invoke}}


Functionality to use plugins and invoke functions.  


\doxysubsection*{Functions}
\begin{DoxyCompactItemize}
\item 
Elektra\+Invoke\+Handle $\ast$ \mbox{\hyperlink{group__invoke_gaae89e2497eba478be2043f1b25adbb3c}{elektra\+Invoke\+Initialize}} (const char $\ast$elektra\+Plugin\+Name)
\item 
Elektra\+Invoke\+Handle $\ast$ \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open}} (const char $\ast$elektra\+Plugin\+Name, Key\+Set $\ast$config, Key $\ast$error\+Key)
\begin{DoxyCompactList}\small\item\em Opens a new handle to invoke functions for a plugin. \end{DoxyCompactList}\item 
const void $\ast$ \mbox{\hyperlink{group__invoke_ga4531a643a71a63c19c94d87bd8d0b40f}{elektra\+Invoke\+Get\+Function}} (Elektra\+Invoke\+Handle $\ast$handle, const char $\ast$elektra\+Plugin\+Function\+Name)
\begin{DoxyCompactList}\small\item\em Get a function pointer. \end{DoxyCompactList}\item 
Key\+Set $\ast$ \mbox{\hyperlink{group__invoke_gafc090b80f3ba846bf3c3fd8ccd34f2f5}{elektra\+Invoke\+Get\+Plugin\+Config}} (Elektra\+Invoke\+Handle $\ast$handle)
\begin{DoxyCompactList}\small\item\em Get the configuration the plugin uses. \end{DoxyCompactList}\item 
const char $\ast$ \mbox{\hyperlink{group__invoke_ga13bd3afe428624d459239df73641d769}{elektra\+Invoke\+Get\+Plugin\+Name}} (Elektra\+Invoke\+Handle $\ast$handle)
\begin{DoxyCompactList}\small\item\em Get the name of the plugin. \end{DoxyCompactList}\item 
void $\ast$ \mbox{\hyperlink{group__invoke_gac615e211a4d3c77addfa18152c274345}{elektra\+Invoke\+Get\+Plugin\+Data}} (Elektra\+Invoke\+Handle $\ast$handle)
\begin{DoxyCompactList}\small\item\em Get the data of the plugin. \end{DoxyCompactList}\item 
Key\+Set $\ast$ \mbox{\hyperlink{group__invoke_gaf3564011b52e96c9754a7b9bc41ea478}{elektra\+Invoke\+Get\+Modules}} (Elektra\+Invoke\+Handle $\ast$handle)
\begin{DoxyCompactList}\small\item\em Get the modules used for invoking. \end{DoxyCompactList}\item 
Key\+Set $\ast$ \mbox{\hyperlink{group__invoke_ga6ab386aba337d8d3fd7978070d613efe}{elektra\+Invoke\+Get\+Exports}} (Elektra\+Invoke\+Handle $\ast$handle)
\begin{DoxyCompactList}\small\item\em Get the exports from the plugin. \end{DoxyCompactList}\item 
int \mbox{\hyperlink{group__invoke_gaa257d93399c60f73c611205bbfa7c9a0}{elektra\+Invoke2\+Args}} (Elektra\+Invoke\+Handle $\ast$handle, const char $\ast$elektra\+Plugin\+Function\+Name, Key\+Set $\ast$ks, Key $\ast$k)
\begin{DoxyCompactList}\small\item\em A convenience function to call a function with two arguments. \end{DoxyCompactList}\item 
void \mbox{\hyperlink{group__invoke_ga684a21daa0b3c20783c55184a9157b3b}{elektra\+Invoke\+Close}} (Elektra\+Invoke\+Handle $\ast$handle, Key $\ast$error\+Key)
\begin{DoxyCompactList}\small\item\em Closes all affairs with the handle. \end{DoxyCompactList}\item 
int \mbox{\hyperlink{group__invoke_ga0c1fe2bab1f3a465106d6585363787a1}{elektra\+Invoke\+Call\+Deferable}} (Elektra\+Invoke\+Handle $\ast$handle, const char $\ast$elektra\+Plugin\+Function\+Name, Key\+Set $\ast$parameters)
\begin{DoxyCompactList}\small\item\em Invokes a deferable function on an invoke handle. \end{DoxyCompactList}\item 
void \mbox{\hyperlink{group__invoke_ga933ae8c38aadef6af1462297fcfb5041}{elektra\+Invoke\+Execute\+Deferred\+Calls}} (Elektra\+Invoke\+Handle $\ast$handle, Elektra\+Deferred\+Call\+List $\ast$list)
\begin{DoxyCompactList}\small\item\em Execute deferred calls from list on given invoke handle. \end{DoxyCompactList}\item 
int \mbox{\hyperlink{group__invoke_ga80328407d9d418af04c54ab5f10a63c0}{elektra\+Deferred\+Call}} (Plugin $\ast$handle, const char $\ast$elektra\+Plugin\+Function\+Name, Key\+Set $\ast$parameters)
\begin{DoxyCompactList}\small\item\em Call a deferable function on a plugin handle. \end{DoxyCompactList}\item 
int \mbox{\hyperlink{group__invoke_gaa6200aa148a20b58d62cd8cc73f293ce}{elektra\+Deferred\+Call\+Add}} (Elektra\+Deferred\+Call\+List $\ast$list, const char $\ast$name, Key\+Set $\ast$parameters)
\begin{DoxyCompactList}\small\item\em Add a new deferred call to the deferred call list. \end{DoxyCompactList}\item 
Elektra\+Deferred\+Call\+List $\ast$ \mbox{\hyperlink{group__invoke_gacff96e795f6fc2fad61ed2f8a5cd80cb}{elektra\+Deferred\+Call\+Create\+List}} (void)
\begin{DoxyCompactList}\small\item\em Create new deferred call list. \end{DoxyCompactList}\item 
void \mbox{\hyperlink{group__invoke_ga7b9d8b37ebd5205fded885164d3ad6b7}{elektra\+Deferred\+Call\+Delete\+List}} (Elektra\+Deferred\+Call\+List $\ast$list)
\begin{DoxyCompactList}\small\item\em Delete deferred call list. \end{DoxyCompactList}\item 
void \mbox{\hyperlink{group__invoke_gad59c673dce3c2f08fbe52c5c667f55ce}{elektra\+Deferred\+Calls\+Execute}} (Plugin $\ast$plugin, Elektra\+Deferred\+Call\+List $\ast$list)
\begin{DoxyCompactList}\small\item\em Execute deferred calls on given plugin. \end{DoxyCompactList}\end{DoxyCompactItemize}


\doxysubsection{Detailed Description}
Functionality to use plugins and invoke functions. 

Allows invoking functions of plugins as needed within applications and plugins inside and outside of the K\+DB.

To use this library, you need to include\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{preprocessor}{\#include <kdbinvoke.h>}`}
\end{DoxyCode}


and link against {\ttfamily libelektra-\/invoke}. Then you can use it\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{ElektraInvokeHandle * handle = \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektraInvokeOpen}} (\textcolor{stringliteral}{"dini"}, 0);}
\DoxyCodeLine{\mbox{\hyperlink{group__invoke_gaa257d93399c60f73c611205bbfa7c9a0}{elektraInvoke2Args}} (handle, \textcolor{stringliteral}{"get"}, ks, k);}
\DoxyCodeLine{\mbox{\hyperlink{group__invoke_ga684a21daa0b3c20783c55184a9157b3b}{elektraInvokeClose}} (handle);}
\end{DoxyCode}
 

\doxysubsection{Function Documentation}
\mbox{\Hypertarget{group__invoke_ga80328407d9d418af04c54ab5f10a63c0}\label{group__invoke_ga80328407d9d418af04c54ab5f10a63c0}} 
\index{Invoke@{Invoke}!elektraDeferredCall@{elektraDeferredCall}}
\index{elektraDeferredCall@{elektraDeferredCall}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraDeferredCall()}{elektraDeferredCall()}}
{\footnotesize\ttfamily int elektra\+Deferred\+Call (\begin{DoxyParamCaption}\item[{Plugin $\ast$}]{handle,  }\item[{const char $\ast$}]{elektra\+Plugin\+Function\+Name,  }\item[{Key\+Set $\ast$}]{parameters }\end{DoxyParamCaption})}



Call a deferable function on a plugin handle. 

If the function is exported by the plugin it is directly invoked, if the plugin supports deferring calls, the call is deferred. If both is possible (function is exported and deferred calls are supported), the function is directly called and the call is deferred (i.\+e. for nested plugins).


\begin{DoxyParams}{Parameters}
{\em handle} & invoke handle \\
\hline
{\em elektra\+Plugin\+Function\+Name} & function name \\
\hline
{\em parameters} & parameter key set. Can bee freed afterwards. \\
\hline
\end{DoxyParams}

\begin{DoxyRetVals}{Return values}
{\em 0} & on success \\
\hline
{\em -\/1} & when the call failed (direct call and deferring not available) \\
\hline
\end{DoxyRetVals}
\mbox{\Hypertarget{group__invoke_gaa6200aa148a20b58d62cd8cc73f293ce}\label{group__invoke_gaa6200aa148a20b58d62cd8cc73f293ce}} 
\index{Invoke@{Invoke}!elektraDeferredCallAdd@{elektraDeferredCallAdd}}
\index{elektraDeferredCallAdd@{elektraDeferredCallAdd}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraDeferredCallAdd()}{elektraDeferredCallAdd()}}
{\footnotesize\ttfamily int elektra\+Deferred\+Call\+Add (\begin{DoxyParamCaption}\item[{Elektra\+Deferred\+Call\+List $\ast$}]{list,  }\item[{const char $\ast$}]{name,  }\item[{Key\+Set $\ast$}]{parameters }\end{DoxyParamCaption})}



Add a new deferred call to the deferred call list. 

Used internally by plugins.


\begin{DoxyParams}{Parameters}
{\em list} & deferred call list \\
\hline
{\em name} & function name \\
\hline
{\em parameters} & function parameters \\
\hline
\end{DoxyParams}

\begin{DoxyRetVals}{Return values}
{\em 1} & on success \\
\hline
{\em 0} & when malloc failed \\
\hline
\end{DoxyRetVals}
\mbox{\Hypertarget{group__invoke_gacff96e795f6fc2fad61ed2f8a5cd80cb}\label{group__invoke_gacff96e795f6fc2fad61ed2f8a5cd80cb}} 
\index{Invoke@{Invoke}!elektraDeferredCallCreateList@{elektraDeferredCallCreateList}}
\index{elektraDeferredCallCreateList@{elektraDeferredCallCreateList}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraDeferredCallCreateList()}{elektraDeferredCallCreateList()}}
{\footnotesize\ttfamily Elektra\+Deferred\+Call\+List$\ast$ elektra\+Deferred\+Call\+Create\+List (\begin{DoxyParamCaption}\item[{void}]{ }\end{DoxyParamCaption})}



Create new deferred call list. 

The list needs to be deleted with \mbox{\hyperlink{group__invoke_ga7b9d8b37ebd5205fded885164d3ad6b7}{elektra\+Deferred\+Call\+Delete\+List()}}. Used internally by plugins.

\begin{DoxyReturn}{Returns}
new list 
\end{DoxyReturn}
\mbox{\Hypertarget{group__invoke_ga7b9d8b37ebd5205fded885164d3ad6b7}\label{group__invoke_ga7b9d8b37ebd5205fded885164d3ad6b7}} 
\index{Invoke@{Invoke}!elektraDeferredCallDeleteList@{elektraDeferredCallDeleteList}}
\index{elektraDeferredCallDeleteList@{elektraDeferredCallDeleteList}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraDeferredCallDeleteList()}{elektraDeferredCallDeleteList()}}
{\footnotesize\ttfamily void elektra\+Deferred\+Call\+Delete\+List (\begin{DoxyParamCaption}\item[{Elektra\+Deferred\+Call\+List $\ast$}]{list }\end{DoxyParamCaption})}



Delete deferred call list. 

Used internally by plugins.


\begin{DoxyParams}{Parameters}
{\em list} & list \\
\hline
\end{DoxyParams}
\mbox{\Hypertarget{group__invoke_gad59c673dce3c2f08fbe52c5c667f55ce}\label{group__invoke_gad59c673dce3c2f08fbe52c5c667f55ce}} 
\index{Invoke@{Invoke}!elektraDeferredCallsExecute@{elektraDeferredCallsExecute}}
\index{elektraDeferredCallsExecute@{elektraDeferredCallsExecute}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraDeferredCallsExecute()}{elektraDeferredCallsExecute()}}
{\footnotesize\ttfamily void elektra\+Deferred\+Calls\+Execute (\begin{DoxyParamCaption}\item[{Plugin $\ast$}]{plugin,  }\item[{Elektra\+Deferred\+Call\+List $\ast$}]{list }\end{DoxyParamCaption})}



Execute deferred calls on given plugin. 

Used internally by plugins.


\begin{DoxyParams}{Parameters}
{\em plugin} & plugin handle \\
\hline
{\em list} & list \\
\hline
\end{DoxyParams}
\mbox{\Hypertarget{group__invoke_gaa257d93399c60f73c611205bbfa7c9a0}\label{group__invoke_gaa257d93399c60f73c611205bbfa7c9a0}} 
\index{Invoke@{Invoke}!elektraInvoke2Args@{elektraInvoke2Args}}
\index{elektraInvoke2Args@{elektraInvoke2Args}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvoke2Args()}{elektraInvoke2Args()}}
{\footnotesize\ttfamily int elektra\+Invoke2\+Args (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle,  }\item[{const char $\ast$}]{elektra\+Plugin\+Function\+Name,  }\item[{Key\+Set $\ast$}]{ks,  }\item[{Key $\ast$}]{k }\end{DoxyParamCaption})}



A convenience function to call a function with two arguments. 


\begin{DoxyParams}{Parameters}
{\em handle} & the handle to work with \\
\hline
{\em elektra\+Plugin\+Function\+Name} & the function to call, e.\+g. \char`\"{}get\char`\"{} \\
\hline
{\em ks} & the keyset to be used as first parameter \\
\hline
{\em k} & the key to be used as second parameter\\
\hline
\end{DoxyParams}
\begin{DoxyPrecond}{Precondition}
handle must be as returned from \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}}
\end{DoxyPrecond}
\begin{DoxyReturn}{Returns}
the return value of the invoked function (i.\+e. -\/1, 0, or 1) 
\end{DoxyReturn}

\begin{DoxyRetVals}{Return values}
{\em -\/2} & if the function was not found. \\
\hline
\end{DoxyRetVals}
\mbox{\Hypertarget{group__invoke_ga0c1fe2bab1f3a465106d6585363787a1}\label{group__invoke_ga0c1fe2bab1f3a465106d6585363787a1}} 
\index{Invoke@{Invoke}!elektraInvokeCallDeferable@{elektraInvokeCallDeferable}}
\index{elektraInvokeCallDeferable@{elektraInvokeCallDeferable}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeCallDeferable()}{elektraInvokeCallDeferable()}}
{\footnotesize\ttfamily int elektra\+Invoke\+Call\+Deferable (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle,  }\item[{const char $\ast$}]{elektra\+Plugin\+Function\+Name,  }\item[{Key\+Set $\ast$}]{parameters }\end{DoxyParamCaption})}



Invokes a deferable function on an invoke handle. 

If the function is exported by the plugin it is directly invoked, if the plugin supports deferring calls, the call is deferred.

The parameters key set can be freed afterwards.


\begin{DoxyParams}{Parameters}
{\em handle} & invoke handle \\
\hline
{\em elektra\+Plugin\+Function\+Name} & function name \\
\hline
{\em parameters} & parameter key set \\
\hline
\end{DoxyParams}

\begin{DoxyRetVals}{Return values}
{\em 0} & on success \\
\hline
{\em -\/1} & when the call failed (direct call and deferring not available) \\
\hline
\end{DoxyRetVals}
\mbox{\Hypertarget{group__invoke_ga684a21daa0b3c20783c55184a9157b3b}\label{group__invoke_ga684a21daa0b3c20783c55184a9157b3b}} 
\index{Invoke@{Invoke}!elektraInvokeClose@{elektraInvokeClose}}
\index{elektraInvokeClose@{elektraInvokeClose}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeClose()}{elektraInvokeClose()}}
{\footnotesize\ttfamily void elektra\+Invoke\+Close (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle,  }\item[{Key $\ast$}]{error\+Key }\end{DoxyParamCaption})}



Closes all affairs with the handle. 

The close function of the plugin will be called.


\begin{DoxyParams}{Parameters}
{\em handle} & the handle to work with \\
\hline
{\em error\+Key} & a key where error messages will be stored\\
\hline
\end{DoxyParams}
\begin{DoxyPrecond}{Precondition}
handle must be as returned from \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}} 
\end{DoxyPrecond}
\mbox{\Hypertarget{group__invoke_ga933ae8c38aadef6af1462297fcfb5041}\label{group__invoke_ga933ae8c38aadef6af1462297fcfb5041}} 
\index{Invoke@{Invoke}!elektraInvokeExecuteDeferredCalls@{elektraInvokeExecuteDeferredCalls}}
\index{elektraInvokeExecuteDeferredCalls@{elektraInvokeExecuteDeferredCalls}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeExecuteDeferredCalls()}{elektraInvokeExecuteDeferredCalls()}}
{\footnotesize\ttfamily void elektra\+Invoke\+Execute\+Deferred\+Calls (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle,  }\item[{Elektra\+Deferred\+Call\+List $\ast$}]{list }\end{DoxyParamCaption})}



Execute deferred calls from list on given invoke handle. 

Used internally by plugins holding invoke handles.


\begin{DoxyParams}{Parameters}
{\em handle} & invoke handle \\
\hline
{\em list} & list \\
\hline
\end{DoxyParams}
\mbox{\Hypertarget{group__invoke_ga6ab386aba337d8d3fd7978070d613efe}\label{group__invoke_ga6ab386aba337d8d3fd7978070d613efe}} 
\index{Invoke@{Invoke}!elektraInvokeGetExports@{elektraInvokeGetExports}}
\index{elektraInvokeGetExports@{elektraInvokeGetExports}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeGetExports()}{elektraInvokeGetExports()}}
{\footnotesize\ttfamily Key\+Set$\ast$ elektra\+Invoke\+Get\+Exports (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle }\end{DoxyParamCaption})}



Get the exports from the plugin. 


\begin{DoxyParams}{Parameters}
{\em handle} & the handle to work with.\\
\hline
\end{DoxyParams}
\begin{DoxyPrecond}{Precondition}
handle must be as returned from \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}}
\end{DoxyPrecond}
\begin{DoxyReturn}{Returns}
the exports of the plugin. 
\end{DoxyReturn}
\mbox{\Hypertarget{group__invoke_ga4531a643a71a63c19c94d87bd8d0b40f}\label{group__invoke_ga4531a643a71a63c19c94d87bd8d0b40f}} 
\index{Invoke@{Invoke}!elektraInvokeGetFunction@{elektraInvokeGetFunction}}
\index{elektraInvokeGetFunction@{elektraInvokeGetFunction}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeGetFunction()}{elektraInvokeGetFunction()}}
{\footnotesize\ttfamily const void$\ast$ elektra\+Invoke\+Get\+Function (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle,  }\item[{const char $\ast$}]{elektra\+Plugin\+Function\+Name }\end{DoxyParamCaption})}



Get a function pointer. 


\begin{DoxyParams}{Parameters}
{\em handle} & the handle to use \\
\hline
{\em elektra\+Plugin\+Function\+Name} & the name of the function to use, e.\+g., get/set\\
\hline
\end{DoxyParams}
\begin{DoxyPrecond}{Precondition}
handle must be as returned from \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}}
\end{DoxyPrecond}
Example\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{\textcolor{keyword}{typedef} int (*elektra2Args) (KeySet*, Key *);}
\DoxyCodeLine{elektra2Args func = *(elektra2Args *)\mbox{\hyperlink{group__invoke_ga4531a643a71a63c19c94d87bd8d0b40f}{elektraInvokeGetFunction}} (handle, elektraPluginFunctionName);}
\DoxyCodeLine{\textcolor{keywordflow}{if} (!func) exit(1);   \textcolor{comment}{// no function found, handle error}}
\DoxyCodeLine{func (ks, k);         \textcolor{comment}{// otherwise, call function}}
\end{DoxyCode}


\begin{DoxySeeAlso}{See also}
\mbox{\hyperlink{group__invoke_gaa257d93399c60f73c611205bbfa7c9a0}{elektra\+Invoke2\+Args()}} a convenience function to be used for Key\+Set,Key arguments.
\end{DoxySeeAlso}
\begin{DoxyReturn}{Returns}
a function pointer for the specified function. 
\end{DoxyReturn}
\mbox{\Hypertarget{group__invoke_gaf3564011b52e96c9754a7b9bc41ea478}\label{group__invoke_gaf3564011b52e96c9754a7b9bc41ea478}} 
\index{Invoke@{Invoke}!elektraInvokeGetModules@{elektraInvokeGetModules}}
\index{elektraInvokeGetModules@{elektraInvokeGetModules}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeGetModules()}{elektraInvokeGetModules()}}
{\footnotesize\ttfamily Key\+Set$\ast$ elektra\+Invoke\+Get\+Modules (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle }\end{DoxyParamCaption})}



Get the modules used for invoking. 

\begin{DoxyWarning}{Warning}
The modules are closed within \mbox{\hyperlink{group__invoke_ga684a21daa0b3c20783c55184a9157b3b}{elektra\+Invoke\+Close()}}. It is {\itshape not} enough to \mbox{\hyperlink{group__keyset_gac59e4b328245463f1451f68d5106151c}{ks\+Dup()}} the keyset, you must not call \mbox{\hyperlink{group__invoke_ga684a21daa0b3c20783c55184a9157b3b}{elektra\+Invoke\+Close()}} if you want to reuse the modules.
\end{DoxyWarning}

\begin{DoxyParams}{Parameters}
{\em handle} & the handle to work with.\\
\hline
\end{DoxyParams}
\begin{DoxyPrecond}{Precondition}
handle must be as returned from \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}}
\end{DoxyPrecond}
\begin{DoxyReturn}{Returns}
the modules used for invoking. 
\end{DoxyReturn}
\mbox{\Hypertarget{group__invoke_gafc090b80f3ba846bf3c3fd8ccd34f2f5}\label{group__invoke_gafc090b80f3ba846bf3c3fd8ccd34f2f5}} 
\index{Invoke@{Invoke}!elektraInvokeGetPluginConfig@{elektraInvokeGetPluginConfig}}
\index{elektraInvokeGetPluginConfig@{elektraInvokeGetPluginConfig}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeGetPluginConfig()}{elektraInvokeGetPluginConfig()}}
{\footnotesize\ttfamily Key\+Set$\ast$ elektra\+Invoke\+Get\+Plugin\+Config (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle }\end{DoxyParamCaption})}



Get the configuration the plugin uses. 


\begin{DoxyParams}{Parameters}
{\em handle} & the handle to use\\
\hline
\end{DoxyParams}
\begin{DoxyPrecond}{Precondition}
handle must be as returned from \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}}
\end{DoxyPrecond}
\begin{DoxyReturn}{Returns}
the config of the plugin. 
\end{DoxyReturn}
\mbox{\Hypertarget{group__invoke_gac615e211a4d3c77addfa18152c274345}\label{group__invoke_gac615e211a4d3c77addfa18152c274345}} 
\index{Invoke@{Invoke}!elektraInvokeGetPluginData@{elektraInvokeGetPluginData}}
\index{elektraInvokeGetPluginData@{elektraInvokeGetPluginData}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeGetPluginData()}{elektraInvokeGetPluginData()}}
{\footnotesize\ttfamily void$\ast$ elektra\+Invoke\+Get\+Plugin\+Data (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle }\end{DoxyParamCaption})}



Get the data of the plugin. 


\begin{DoxyParams}{Parameters}
{\em handle} & the handle to work with.\\
\hline
\end{DoxyParams}
\begin{DoxyPrecond}{Precondition}
handle must be as returned from \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}}
\end{DoxyPrecond}
\begin{DoxyReturn}{Returns}
a pointer to the plugin\textquotesingle{}s data. 
\end{DoxyReturn}
\mbox{\Hypertarget{group__invoke_ga13bd3afe428624d459239df73641d769}\label{group__invoke_ga13bd3afe428624d459239df73641d769}} 
\index{Invoke@{Invoke}!elektraInvokeGetPluginName@{elektraInvokeGetPluginName}}
\index{elektraInvokeGetPluginName@{elektraInvokeGetPluginName}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeGetPluginName()}{elektraInvokeGetPluginName()}}
{\footnotesize\ttfamily const char$\ast$ elektra\+Invoke\+Get\+Plugin\+Name (\begin{DoxyParamCaption}\item[{Elektra\+Invoke\+Handle $\ast$}]{handle }\end{DoxyParamCaption})}



Get the name of the plugin. 

The name might differ from the name as passed with elektra\+Invoke\+Open when symlinks are used.


\begin{DoxyParams}{Parameters}
{\em handle} & the handle to work with.\\
\hline
\end{DoxyParams}
\begin{DoxyPrecond}{Precondition}
handle must be as returned from \mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}}
\end{DoxyPrecond}
\begin{DoxyReturn}{Returns}
the name of the plugin 
\end{DoxyReturn}
\mbox{\Hypertarget{group__invoke_gaae89e2497eba478be2043f1b25adbb3c}\label{group__invoke_gaae89e2497eba478be2043f1b25adbb3c}} 
\index{Invoke@{Invoke}!elektraInvokeInitialize@{elektraInvokeInitialize}}
\index{elektraInvokeInitialize@{elektraInvokeInitialize}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeInitialize()}{elektraInvokeInitialize()}}
{\footnotesize\ttfamily Elektra\+Invoke\+Handle$\ast$ elektra\+Invoke\+Initialize (\begin{DoxyParamCaption}\item[{const char $\ast$}]{elektra\+Plugin\+Name }\end{DoxyParamCaption})}

\begin{DoxyRefDesc}{Deprecated}
\item[\mbox{\hyperlink{deprecated__deprecated000013}{Deprecated}}]Do not use.\end{DoxyRefDesc}


Use {\ttfamily elektra\+Invoke\+Open (name, 0, 0)} instead.

\begin{DoxySeeAlso}{See also}
\mbox{\hyperlink{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}{elektra\+Invoke\+Open()}} 
\end{DoxySeeAlso}
\mbox{\Hypertarget{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}\label{group__invoke_ga3eb20131e9a8fc9a6cebf126927c09bc}} 
\index{Invoke@{Invoke}!elektraInvokeOpen@{elektraInvokeOpen}}
\index{elektraInvokeOpen@{elektraInvokeOpen}!Invoke@{Invoke}}
\doxysubsubsection{\texorpdfstring{elektraInvokeOpen()}{elektraInvokeOpen()}}
{\footnotesize\ttfamily Elektra\+Invoke\+Handle$\ast$ elektra\+Invoke\+Open (\begin{DoxyParamCaption}\item[{const char $\ast$}]{elektra\+Plugin\+Name,  }\item[{Key\+Set $\ast$}]{config,  }\item[{Key $\ast$}]{error\+Key }\end{DoxyParamCaption})}



Opens a new handle to invoke functions for a plugin. 

When opening the plugin, it calls the \char`\"{}open\char`\"{} function of the plugin.


\begin{DoxyParams}{Parameters}
{\em elektra\+Plugin\+Name} & the plugin on which we want to invoke functions. \\
\hline
{\em config} & the config to be passed to the plugin. \\
\hline
{\em error\+Key} & a key where error messages will be stored\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the handle 
\end{DoxyReturn}

\begin{DoxyRetVals}{Return values}
{\em 0} & on errors \\
\hline
\end{DoxyRetVals}
