Modules.h File Reference

#include <znc/zncconfig.h>
#include <znc/WebModules.h>
#include <znc/Utils.h>
#include <znc/Threads.h>
#include <znc/Message.h>
#include <znc/main.h>
#include <znc/Translation.h>
#include <functional>
#include <memory>
#include <set>
#include <queue>
#include <sys/time.h>

Include dependency graph for Modules.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	CModuleEntry
	C-style entry point to the module. More...
class	CCapability
class	CTimer
class	CFPTimer
class	CModuleJob
	A CJob version which can be safely used in modules. More...
class	CModInfo
class	CModCommand
	A helper class for handling commands in modules. More...
class	CModule
	The base class for your own ZNC modules. More...
class	CModules

Macros
#define	ZNC_EXPORT_LIB_EXPORT
#define	MODCOMMONDEFS(CLASS, DESCRIPTION, TYPE)
#define	MODCONSTRUCTOR(CLASS)
	Instead of writing a constructor, you should call this macro.
#define	USERMODULEDEFS(CLASS, DESCRIPTION)
	This works exactly like MODULEDEFS, but for user modules.
#define	GLOBALMODULEDEFS(CLASS, DESCRIPTION)
	This works exactly like MODULEDEFS, but for global modules.
#define	NETWORKMODULEDEFS(CLASS, DESCRIPTION)
	This works exactly like MODULEDEFS, but for network modules.
#define	MODULEDEFS(CLASS, DESCRIPTION)
	At the end of your source file, you must call this macro in global context.

Typedefs
typedef void(*)	FPTimer_t(CModule *, CFPTimer *)
typedef void *	ModHandle

Functions
template<class M>
void	TModInfo (CModInfo &Info)
template<class M>
CModule *	TModLoad (ModHandle p, CUser *pUser, CIRCNetwork *pNetwork, const CString &sModName, const CString &sModPath, CModInfo::EModuleType eType)

Macro Definition Documentation

GLOBALMODULEDEFS

#define GLOBALMODULEDEFS	(		CLASS,
			DESCRIPTION )

Value:

MODCOMMONDEFS(CLASS, DESCRIPTION, CModInfo::GlobalModule)

This works exactly like MODULEDEFS, but for global modules.

MODCOMMONDEFS

#define MODCOMMONDEFS	(		CLASS,
			DESCRIPTION,
			TYPE )

Value:

static void FillModInfo(CModInfo& Info) {                               \
    auto t_s = [&](const CString& sEnglish,                             \
                   const CString& sContext = "") {                      \
        return sEnglish.empty() ? "" : Info.t_s(sEnglish, sContext);    \
    };                                                                  \
    t_s(CString());                     \
    Info.SetDescription(DESCRIPTION);                                   \
    Info.SetDefaultType(TYPE);                                          \
    Info.AddType(TYPE);                                                 \
    Info.SetLoader(TModLoad<CLASS>);                                    \
    TModInfo<CLASS>(Info);                                              \
}                                                                       \
extern "C" {                                                            \
             \
ZNC_EXPORT_LIB_EXPORT const CModuleEntry* ZNCModuleEntry();             \
ZNC_EXPORT_LIB_EXPORT const CModuleEntry* ZNCModuleEntry() {            \
    static const CModuleEntry ThisModule = {VERSION_STR, VERSION_EXTRA, \
                                            ZNC_COMPILE_OPTIONS_STRING, \
                                            FillModInfo};               \
    return &ThisModule;                                                 \
}                                                                       \
}

MODCONSTRUCTOR

#define MODCONSTRUCTOR

(

CLASS

)

Value:

CLASS(ModHandle pDLL, CUser* pUser, CIRCNetwork* pNetwork, \
      const CString& sModName, const CString& sModPath,    \
      CModInfo::EModuleType eType)                         \
    : CModule(pDLL, pUser, pNetwork, sModName, sModPath, eType)

Instead of writing a constructor, you should call this macro.

It accepts all the necessary arguments and passes them on to CModule's constructor. You should assume that there are no arguments to the constructor.

Usage:

class MyModule : public CModule {
    MODCONSTRUCTOR(MyModule) {
        // Your own constructor's code here
    }
}

Parameters

CLASS

The name of your module's class.

MODULEDEFS

#define MODULEDEFS	(		CLASS,
			DESCRIPTION )

Value:

NETWORKMODULEDEFS(CLASS, DESCRIPTION)

At the end of your source file, you must call this macro in global context.

It defines some static functions which ZNC needs to load this module. By default the module will be a network module.

Parameters

CLASS	The name of your module's class.
DESCRIPTION	A short description of your module.

NETWORKMODULEDEFS

#define NETWORKMODULEDEFS	(		CLASS,
			DESCRIPTION )

Value:

MODCOMMONDEFS(CLASS, DESCRIPTION, CModInfo::NetworkModule)

This works exactly like MODULEDEFS, but for network modules.

USERMODULEDEFS

#define USERMODULEDEFS	(		CLASS,
			DESCRIPTION )

Value:

MODCOMMONDEFS(CLASS, DESCRIPTION, CModInfo::UserModule)

This works exactly like MODULEDEFS, but for user modules.

ZNC_EXPORT_LIB_EXPORT

#define ZNC_EXPORT_LIB_EXPORT

Typedef Documentation

FPTimer_t

typedef void(*) FPTimer_t(CModule *, CFPTimer *)

ModHandle

typedef void* ModHandle

Function Documentation

TModInfo()

template<class M>

void TModInfo

(

CModInfo &

Info

)

References TModInfo().

Referenced by TModInfo().

TModLoad()

template<class M>

CModule * TModLoad	(	ModHandle	p,
		CUser *	pUser,
		CIRCNetwork *	pNetwork,
		const CString &	sModName,
		const CString &	sModPath,
		CModInfo::EModuleType	eType )

References TModLoad().

Referenced by TModLoad().